implab/implabjs-core Commit - r133:09ea4b9e3735

working on fluent configuration

cin -

r133:09ea4b9e3735 ioc ts support

parent child

Context file:

r133:09ea4b9e3735

Expand all files

src/main/ts/di/fluent/Configuration.ts created 644 +59 0

@@ -0,0 +1,59
	1	import { Container } from "../Container";
	2	import { argumentNotNull, each } from "../../safe";
	3	import { DescriptorBuilder } from "./DescriptorBuilder";
	4
	5	enum State {
	6	ready,
	7
	8	pending
	9	}
	10
	11	export class Configuration<S extends object, Y extends keyof S = keyof S> {
	12
	13	private _state = State.ready;
	14
	15	_completion: PromiseLike<void> = Promise.resolve();
	16
	17	_builders: { [k in keyof S]?: (service: DescriptorBuilder<S[k], S>) => void } = {};
	18
	19	register<K extends Y>(name: K, builder: (service: DescriptorBuilder<S[K], S>) => void): Configuration<S, Exclude<Y, K>> {
	20	argumentNotNull(builder, "builder");
	21
	22	return this;
	23	}
	24
	25	private _moveStart() {
	26	if (this._state !== State.ready)
	27	throw new Error("Invalid operation");
	28
	29	this._state = State.pending;
	30	}
	31
	32	private _moveDone() {
	33	this._state = State.ready;
	34	}
	35
	36	apply(target: Container<S>) {
	37	this._moveStart();
	38
	39	let pending = 1;
	40
	41	this._completion = new Promise((resolve, reject) => {
	42	each(this._builders, (v, k) => {
	43	pending++;
	44	const d = new DescriptorBuilder<any, S>(target, result => {
	45	target.register(k, result);
	46	if (!--pending)
	47	resolve();
	48	});
	49
	50	try {
	51	v(d);
	52	} catch (e) {
	53	reject(e);
	54	}
	55	});
	56	}).then(() => this._moveDone());
	57	}
	58
	59	}

src/main/ts/di/fluent/DescriptorBuilder.ts created 644 +58 0

@@ -0,0 +1,58
	1	import { Resolver, ServiceModule, LazyDependencyOptions, DependencyOptions } from "./interfaces";
	2	import { AnnotationBuilder } from "../Annotations";
	3	import { Container } from "../Container";
	4	import { Descriptor, ILifetime, ContainerKeys } from "../interfaces";
	5	import { ActivationContext } from "../ActivationContext";
	6
	7	export class DescriptorBuilder<T, S extends object> {
	8	readonly _container: Container<S>;
	9	readonly _cb: (d: Descriptor<S, T>) => void;
	10
	11	constructor(container: Container<S>, cb: (d: Descriptor<S, T>) => void) {
	12	this._container = container;
	13	this._cb = cb;
	14	}
	15	service(service: AnnotationBuilder<T, S> \| ServiceModule<T, S>) {
	16
	17	}
	18
	19	factory(f: (resolve: Resolver<S>, activate: (lifetime: ILifetime, factory: () => any, cleanup?: (item: any) => void) => any) => T): void {
	20	this._cb({
	21	activate(context: ActivationContext<S>) {
	22	const resolve = (name: ContainerKeys<S>, opts?: DependencyOptions \| LazyDependencyOptions) => {
	23	if (opts && "lazy" in opts && opts.lazy) {
	24	const c2 = context.clone();
	25	return () => {
	26	return opts.optional ? c2.resolve(name, opts.default) : c2.resolve(name);
	27	};
	28	} else {
	29	return opts && opts.optional ? context.resolve(name, opts.default) : context.resolve(name);
	30	}
	31	};
	32
	33	const activate = (lifetime: ILifetime, factory: () => any, cleanup?: (item: any) => void) => {
	34	if (lifetime.has()) {
	35	return lifetime.get();
	36	} else {
	37	lifetime.enter();
	38	const instance = factory();
	39	lifetime.store(instance, cleanup);
	40	return instance;
	41	}
	42
	43	};
	44
	45	return f(resolve, activate);
	46	}
	47	});
	48	}
	49
	50	value(v: T): void {
	51	this._cb({
	52	activate() {
	53	return v;
	54	}
	55	});
	56	}
	57
	58	}

docs/ru/observable.md +10 -10

             # Observable
             Универсальный способ организации потока сообщений. Данный механизм может
             использоваться для оповещения об изменениях состояний объектов или для доставки
             самостоятельных событий, например, связанных с действиями пользователя.
             Является реализацией классического шаблона наблюдателя с возможность сообщить
-            о коце потока событий. Данная реализация не содержит никаких дополнительных
+            о конце потока событий. Данная реализация не содержит никаких дополнительных
             функций, таких как фильтрация, канал с состоянием, преобразования сообщений и
             т.п. Это сделано специально, чтобы реализация оставалась максимально простой.
             Пример того, как можно создать последовательность из 10 событий:
             ```ts
             var events = new Observable(async (notify, error, complete) => {
                 // цикл в котором возникает событие
                 for(let i = 0; i < 10; i++) {
                     await delay(1000);
                     // в качестве данных передается номер события
                     notify(i);
                 }
                 // по окончании последовательности информируем, что событий больше не будет
-                compelte();
+                complete();
             });
             // создаем окно с отображением хода событий
             var progress = showProgress({ min: 0, max: 9, current: 0});
             // подписываемся на события
             events.on(
                 // обработчик очередного события
                 msg => {
                     progress.setValue(msg);
                 }.
                 // обработчик ошибки
                 e => {
                     progress.showError(e);
                 },
                 // обработчик конца потока
                 () => {
                     progress.close();
                 }
             );
             // ожидание следующего события
             let firstEvent = await events.next();
             ```
             `Observable` можно создавать из событий другого объекта, например, виджета:
             ```ts
-            // клсс
+            // класс
             class Canvas {
-                readonly mouseMove: IObservable<[number,number]>
+                mouseMove: IObservable<[number,number]>;
                 postCreate() {
                     // превращаем события виджета в Observable
                     this.mouseMove = new Observable<[number,number]>((notify) => {
                         this.mousePad.on('mousemove',(e) => notify([e.clientX, e.clientY]) );
                     });
                 }
             }
             ```
             Если объект инкапсулирует в себе `Observable`, он также может сохранить методы
             для оповещения подписчиков для дальнейшего их использования внутри класса.
             ```ts
             // класс, который будет генерировать события местоположения
             class PositionTracker implements IDestroyable {
                 // _nextPosition и _complete будут связаны с position при создании
                 // экземпляра PositionTracker.
                 _nextPosition: (pos: Position) => void
                 _complete: () => void
                 readonly position: IObservable<Position>
                 // конструктор
                 constructor(...args: any[]) {
                     super(args);
                     // создаем Observable
                     this.position = new Observable<Position>((notify, error, complete) => {
                         // сохраняем методы для оповещения о новом местоположении
                         this._nextPosition = notify;
                         // метод об оповещении конца потока событий
                         this._complete = complete
                     });
                 }
                 // метод для очистки ресурсов
                 destroy() {
                     this._complete();
                     super();
                 }
             }
             ```
-            Существует также несколько варинатов получения сообщений
+            Существует также несколько вариантов получения сообщений
             ```ts
             // регистрация метода для получений событий
             let subscription = pushEvents.on((msg) => {
                 displayPopup(msg);
             });
             // подписку можно отменить, после чего обработчики больше не будут вызываться
             subcription.destroy();
             // если требуется получить только одно сообщение можно использовать
             // асинхронный метод next(ct?: ICancellation)
             let msg = await pushEvents.next();
             // пример метода для получения координат с карты, который использует
             // событие нажатия мышью для определения координат.
             class Map {
                 /**
                 Получает координаты по щелчку мыши.
                 @async
                 @returns [lon,lat]
                 */
                 async peekCoordinates(ct: ICancellation = Cancellation.none) {
                     // получаем событие клика
                     let evt = this.viewport.click.next(ct);
                     // преобразуем позицию на экране в координаты карты
-                    return this.clientToCoodinates([evt.clientx,evt.clientY]);
+                    return this.clientToCoordinates([evt.clientX,evt.clientY]);
                 }
             }
             let map : Map; // где-то объявлено
             // пример получения координат с карты
             let coords = await map.peekCoordinates();
             ```
             ## Observable и последовательности
-            Можно сичтать, что `Observable` это некоторая аналогия итератора только в
+            Можно считать, что `Observable` это некоторая аналогия итератора только в
-            парадигме событийного (или реактивного) программировния. Следует также понимать,
+            парадигме событийного (или реактивного) программирования. Следует также понимать,
             что при переходе от синхронного процедурного программирования к событийному так
             же меняется и направление управления (Inverse Of Control), что означает
             следующее:
             * при работе с итераторами клиенты сами определяют момент чтения следующего
               элемента последовательности.
             * при работе с `Observable` клиенты вынуждены обрабатывать эти события по мере
               их поступления и не могут на это повлиять.
-            Последний пункт можно изменить применив, например, буффер или канал с
+            Последний пункт можно изменить применив, например, буфер или канал с
             состоянием, т.е. очередь, но данные механизмы выходят за рамки простого шаблона
             наблюдателя.
             ```ts
             // обработка в цикле не гарантирует получения всех сообщений
             while(1) {
                 // ожидаем следующее событие, по сути это подписка только на одно событие
                 let next = await events.next();
                 // такой цикл может пропускать сообщения, поскольку асинхронная операция
                 // позволит возобновить создание новых событий, на которые мы не подписаны
                 await processEvent(next);
                 // не только асинхронные операции могут привести к пропуску события
                 // например вызов метода, который приводит к созданию события так же
                 // приведет к тому, что созданное событие не будет обработано в текущем
                 // цикле
                 doSmthAndRiseEvent();
             }
             // для получения всех сообщений нужно регистрировать подписчика
             events.on((data) => {
                 // будет вызван для всех сообщений
                 processEvent(data);
             });
-            ```
  No newline at end of file
+            ```

src/main/ts/Observable.ts +1 -7

             import { IObservable, IDestroyable, ICancellation, IObserver } from "./interfaces";
             import { Cancellation } from "./Cancellation";
-            import { argumentNotNull, destroyed } from "./safe";
+            import { argumentNotNull } from "./safe";
             type Handler<T> = (x: T) => void;
             type Initializer<T> = (notify: Handler<T>, error: (e: any) => void, complete: () => void) => void;
             const noop = () => { };
-            const nulObserver: IObserver<any> = Object.freeze({
-                next: noop,
-                error: noop,
-                complete: noop
-            });
             function isObserver(val: any): val is IObserver<any> {
                 return val && (typeof val.next === "function");
             }
             export class Observable<T> implements IObservable<T> {
                 private _once = new Array<IObserver<T>>();
                 private _observers = new Array<IObserver<T>>();
                 private _complete = false;
                 private _error: any;
                 constructor(func?: Initializer<T>) {
                     if (func)
                         func(
                             this._notifyNext.bind(this),
                             this._notifyError.bind(this),
                             this._notifyCompleted.bind(this)
                         );
                 }
                 /**
                  * Registers handlers for the current observable object.
                  *
                  * @param next the handler for events
                  * @param error the handler for a error
                  * @param complete the handler for a completion
                  * @returns {IDestroyable} the handler for the current subscription, this
                  *  handler can be used to unsubscribe from events.
                  *
                  */
                 on(next: Handler<T>, error?: Handler<any>, complete?: () => void): IDestroyable {
                     argumentNotNull(next, "next");
                     const me = this;
                     const observer: IObserver<T> & IDestroyable = {
                         next: next.bind(null),
                         error: error ? error.bind(null) : noop,
                         complete: complete ? complete.bind(null) : noop,
                         destroy() {
                             me._removeObserver(this);
                         }
                     };
                     this._addObserver(observer);
                     return observer;
                 }
                 subscribe(next: IObserver<T> | Handler<T>, error?: Handler<any>, complete?: () => void): IDestroyable {
                     if (isObserver(next)) {
                         this._addObserver(next);
                         return {
                             destroy: () => this._removeObserver(next)
                         };
                     } else {
                         const observer = {
                             next: next.bind(null),
                             error: error ? error.bind(null) : noop,
                             complete: complete ? complete.bind(null) : noop
                         };
                         this._addObserver(observer);
                         return {
                             destroy: () => this._removeObserver(observer)
                         };
                     }
                 }
                 private _addObserver(observer: IObserver<T>) {
                     if (this._complete) {
                         try {
                             if (this._error)
                                 observer.error(this._error);
                             else
                                 observer.complete();
                         } catch (e) {
                             this.onObserverException(e);
                         }
                     } else {
                         this._observers.push(observer);
                     }
                 }
                 /**
                  * Waits for the next event. This method can't be used to read messages
                  * as a sequence since it can skip some messages between calls.
                  *
                  * @param ct a cancellation token
                  */
                 next(ct: ICancellation = Cancellation.none) {
                     return new Promise<T>((resolve, reject) => {
                         const observer: IObserver<T> = {
                             next: resolve,
                             error: reject,
                             complete: () => reject("No more events are available")
                         };
                         if (this._addOnce(observer) && ct.isSupported()) {
                             ct.register(e => {
                                 this._removeOnce(observer);
                                 reject(e);
                             });
                         }
                     });
                 }
                 private _addOnce(observer: IObserver<T>) {
                     if (this._complete) {
                         try {
                             if (this._error)
                                 observer.error(this._error);
                             else
                                 observer.complete();
                         } catch (e) {
                             this.onObserverException(e);
                         }
                         return false;
                     }
                     this._once.push(observer);
                     return true;
                 }
                 protected onObserverException(e: any) {
                 }
                 private _removeOnce(d: IObserver<T>) {
                     const i = this._once.indexOf(d);
                     if (i >= 0)
                         this._once.splice(i, 1);
                 }
                 private _removeObserver(d: IObserver<T>) {
                     const i = this._observers.indexOf(d);
                     if (i >= 0)
                         this._observers.splice(i, 1);
                 }
                 private _notify(guard: (observer: IObserver<T>) => void) {
                     this._once.forEach(guard);
                     this._once = [];
                     this._observers.forEach(guard);
                 }
                 protected _notifyNext(evt: T) {
                     const guard = (observer: IObserver<T>) => {
                         try {
                             observer.next(evt);
                         } catch (e) {
                             this.onObserverException(e);
                         }
                     };
                     this._notify(guard);
                 }
                 protected _notifyError(e: any) {
                     const guard = (observer: IObserver<T>) => {
                         try {
                             observer.error(e);
                         } catch (e) {
                             this.onObserverException(e);
                         }
                     };
                     this._notify(guard);
                     this._observers = [];
                     this._complete = true;
                 }
                 protected _notifyCompleted() {
                     const guard = (observer: IObserver<T>) => {
                         try {
                             observer.complete();
                         } catch (e) {
                             this.onObserverException(e);
                         }
                     };
                     this._notify(guard);
                     this._observers = [];
                     this._complete = true;
                 }
             }

src/main/ts/di/ActivationContext.ts +7 -4

             import { TraceSource } from "../log/TraceSource";
-            import { argumentNotNull, argumentNotEmptyString } from "../safe";
+            import { argumentNotEmptyString } from "../safe";
-            import { Descriptor, ContainerServiceMap, ContainerKeys, ContainerResolve } from "./interfaces";
+            import { Descriptor, ContainerServiceMap, ContainerKeys, TypeOfService } from "./interfaces";
             import { Container } from "./Container";
             import { MapOf } from "../interfaces";
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
             export interface ActivationContextInfo {
                 name: string;
                 service: string;
             }
             export class ActivationContext<S extends object> {
                 _cache: MapOf<any>;
                 _services: ContainerServiceMap<S>;
                 _visited: MapOf<any>;
                 _name: string;
                 _service: Descriptor<S, any>;
                 _container: Container<S>;
                 _parent: ActivationContext<S> | undefined;
                 constructor(container: Container<S>, services: ContainerServiceMap<S>, name: string, service: Descriptor<S, any>) {
                     this._name = name;
                     this._service = service;
                     this._visited = {};
                     this._cache = {};
                     this._services = services;
                     this._container = container;
                 }
                 getName() {
                     return this._name;
                 }
                 getContainer() {
                     return this._container;
                 }
-                resolve<K extends ContainerKeys<S>>(name: K, def?: ContainerResolve<S, K>) {
+                resolve<K extends ContainerKeys<S>>(name: K): TypeOfService<S, K>;
+                resolve<K extends ContainerKeys<S>, T>(name: K, def: T): TypeOfService<S, K> | T;
+                resolve<K extends ContainerKeys<S>>(name: K, def: undefined): TypeOfService<S, K> | undefined;
+                resolve<K extends ContainerKeys<S>, T>(name: K, def?: T): TypeOfService<S, K> | T | undefined {
                     const d = this._services[name];
                     if (d !== undefined) {
                         return this.activate(d, name.toString());
                     } else {
-                        if (def !== undefined && def !== null)
+                        if (arguments.length > 1)
                             return def;
                         else
                             throw new Error(`Service ${name} not found`);
                     }
                 }
                 /**
                  * registers services local to the the activation context
                  *
                  * @name{string} the name of the service
                  * @service{string} the service descriptor to register
                  */
                 register<K extends keyof S>(name: K, service: Descriptor<S, S[K]>) {
                     argumentNotEmptyString(name, "name");
                     this._services[name] = service as any;
                 }
                 has(id: string) {
                     return id in this._cache;
                 }
                 get<T>(id: string) {
                     return this._cache[id];
                 }
                 store(id: string, value: any) {
                     return (this._cache[id] = value);
                 }
                 activate<T>(d: Descriptor<S, T>, name: string) {
                     if (trace.isLogEnabled())
                         trace.log(`enter ${name} ${d}`);
                     const ctx = this.enter(d, name);
                     const v = d.activate(ctx);
                     if (trace.isLogEnabled())
                         trace.log(`leave ${name}`);
                     return v;
                 }
                 visit(id: string) {
                     const count = this._visited[id] || 0;
                     this._visited[id] = count + 1;
                     return count;
                 }
                 getStack(): ActivationContextInfo[] {
                     const stack = [{
                         name: this._name,
                         service: this._service.toString()
                     }];
                     return this._parent ?
                         stack.concat(this._parent.getStack()) :
                         stack;
                 }
                 private enter(service: Descriptor<S, any>, name: string): this {
                     const clone = Object.create(this);
                     clone._name = name;
                     clone._services = Object.create(this._services);
                     clone._parent = this;
                     clone._service = service;
                     return clone;
                 }
                 /** Creates a clone for the current context, used to protect it from modifications */
                 clone(): this {
                     const clone = Object.create(this);
                     clone._services = Object.create(this._services);
                     return clone;
                 }
             }

src/main/ts/di/Annotations.ts +1 -6

             import { TypeRegistration } from "./Configuration";
             import { ExtractDependency } from "./fluent/interfaces";
-            import { RegistrationBuilder } from "./fluent/RegistrationBuilder";
-            export class AnnotaionBuilder<T, S extends object> {
+            export class AnnotationBuilder<T, S extends object> {
                 wire<P extends any[]>(...args: P) {
                     return <C extends new (...args: ExtractDependency<P, S>) => T>(constructor: C) => {
                     };
                 }
                 inject<P extends any[]>(...args: P) {
                     return <X extends { [m in M]: (...args: any) => any }, M extends keyof (T | X)>(
                         target: X,
                         memberName: M,
                         descriptor: TypedPropertyDescriptor< T[M] extends ((...args: ExtractDependency<P, S>) => any) ? any : never >
                     ) => {
                     };
                 }
                 getDescriptor(): TypeRegistration<new () => T, S> {
                     throw new Error();
                 }
-                getRegistrationBuilder(): RegistrationBuilder<T, S> {
-                    throw new Error();
             }

src/main/ts/di/Configuration.ts +26 -8

             import {
                 PartialServiceMap,
                 ActivationType,
                 ContainerKeys,
-                ContainerResolve
+                TypeOfService,
+                ILifetimeManager
             } from "./interfaces";
             import { argumentNotEmptyString, isPrimitive, isPromise, delegate, argumentOfType, argumentNotNull, get, primitive } from "../safe";
             import { AggregateDescriptor } from "./AggregateDescriptor";
             import { ValueDescriptor } from "./ValueDescriptor";
             import { Container } from "./Container";
             import { ReferenceDescriptor } from "./ReferenceDescriptor";
             import { TypeServiceDescriptor } from "./TypeServiceDescriptor";
             import { FactoryServiceDescriptor } from "./FactoryServiceDescriptor";
             import { TraceSource } from "../log/TraceSource";
             import { ConfigError } from "./ConfigError";
             import { Cancellation } from "../Cancellation";
             import { makeResolver } from "./ResolverHelper";
             import { ICancellation } from "../interfaces";
             import { isDescriptor } from "./traits";
             import { LazyReferenceDescriptor } from "./LazyReferenceDescriptor";
             import { LifetimeManager } from "./LifetimeManager";
             export interface RegistrationScope<S extends object> {
                 /** сервисы, которые регистрируются в контексте активации и таким образом
                  * могут переопределять ранее зарегистрированные сервисы. за это свойство
                  * нужно платить, кроме того порядок активации будет влиять на результат
                  * разрешения зависимостей.
                  */
                 services?: RegistrationMap<S>;
             }
             /**
-             * Базовый интефейс конфигурации сервисов
+             * Базовый интерфейс конфигурации сервисов
              */
             export interface ServiceRegistration<T, S extends object> extends RegistrationScope<S> {
                 activation?: ActivationType;
                 params?: any;
+                /** Специальный идентификатор используется при активации singleton, если
+                 * не указан для TypeRegistration вычисляется как oid($type)
+                 */
+                typeId?: string;
                 inject?: object | object[];
                 cleanup?: ((instance: T) => void) | string;
             }
             export interface TypeRegistration<C extends new (...args: any[]) => any, S extends object> extends ServiceRegistration<InstanceType<C>, S> {
                 $type: string | C;
                 params?: Registration<ConstructorParameters<C>, S>;
             }
             export interface StrictTypeRegistration<C extends new (...args: any[]) => any, S extends object> extends ServiceRegistration<InstanceType<C>, S> {
                 $type: C;
                 params?: Registration<ConstructorParameters<C>, S>;
             }
             export interface FactoryRegistration<F extends (...args: any[]) => any, S extends object> extends ServiceRegistration<ReturnType<F>, S> {
                 $factory: string | F;
             }
             export interface ValueRegistration<T> {
                 $value: T;
                 parse?: boolean;
             }
             export interface DependencyRegistration<S extends object, K extends ContainerKeys<S> = ContainerKeys<S>> extends RegistrationScope<S> {
                 $dependency: K;
                 lazy?: boolean;
                 optional?: boolean;
-                default?: ContainerResolve<S, K>;
+                default?: TypeOfService<S, K>;
             }
             export interface LazyDependencyRegistration<S extends object, K extends ContainerKeys<S> = ContainerKeys<S>> extends DependencyRegistration<S, K> {
                 lazy: true;
             }
             export type Registration<T, S extends object> = T extends primitive ? T :
                 (
                     T |
                     { [k in keyof T]: Registration<T[k], S> } |
                     TypeRegistration<new (...args: any[]) => T, S> |
                     FactoryRegistration<(...args: any[]) => T, S> |
                     ValueRegistration<any> |
                     DependencyRegistration<S, keyof S>
                 );
             export type RegistrationMap<S extends object> = {
                 [k in keyof S]?: Registration<S[k], S>;
             };
             const _activationTypes: { [k in ActivationType]: number; } = {
                 singleton: 1,
                 container: 2,
                 hierarchy: 3,
                 context: 4,
                 call: 5
             };
             export function isTypeRegistration(x: any): x is TypeRegistration<new () => any, any> {
                 return (!isPrimitive(x)) && ("$type" in x);
             }
             export function isFactoryRegistration(x: any): x is FactoryRegistration<() => any, any> {
                 return (!isPrimitive(x)) && ("$factory" in x);
             }
             export function isValueRegistration(x: any): x is ValueRegistration<any> {
                 return (!isPrimitive(x)) && ("$value" in x);
             }
             export function isDependencyRegistration<S extends object>(x: any): x is DependencyRegistration<S, keyof S> {
                 return (!isPrimitive(x)) && ("$dependency" in x);
             }
             export function isActivationType(x: string): x is ActivationType {
                 return typeof x === "string" && x in _activationTypes;
             }
             const trace = TraceSource.get("@implab/core/di/Configuration");
             async function mapAll(data: any[], map?: (v: any, k: number) => any): Promise<any[]>;
             async function mapAll(data: any, map?: (v: any, k: string) => any): Promise<any>;
             async function mapAll(data: any, map?: (v: any, k: any) => any): Promise<any> {
                 if (data instanceof Array) {
                     return Promise.all(map ? data.map(map) : data);
                 } else {
                     const keys = Object.keys(data);
                     const o: any = {};
                     await Promise.all(keys.map(async k => {
                         const v = map ? map(data[k], k) : data[k];
                         o[k] = isPromise(v) ? await v : v;
                     }));
                     return o;
                 }
             }
             export type ModuleResolver = (moduleName: string, ct?: ICancellation) => any;
             export class Configuration<S extends object> {
                 _hasInnerDescriptors = false;
                 readonly _container: Container<S>;
                 _path: Array<string>;
                 _configName: string | undefined;
                 _require: ModuleResolver | undefined;
                 constructor(container: Container<S>) {
                     argumentNotNull(container, "container");
                     this._container = container;
                     this._path = [];
                 }
                 async loadConfiguration(moduleName: string, contextRequire?: any, ct = Cancellation.none) {
                     argumentNotEmptyString(moduleName, "moduleName");
                     trace.log(
                         "loadConfiguration moduleName={0}, contextRequire={1}",
                         moduleName,
                         contextRequire ? typeof (contextRequire) : "<nil>"
                     );
                     this._configName = moduleName;
                     const r = await makeResolver(undefined, contextRequire);
                     const config = await r(moduleName, ct);
                     await this._applyConfiguration(
                         config,
                         await makeResolver(moduleName, contextRequire),
                         ct
                     );
                 }
                 async applyConfiguration(data: RegistrationMap<S>, contextRequire?: any, ct = Cancellation.none) {
                     argumentNotNull(data, "data");
                     await this._applyConfiguration(data, await makeResolver(void (0), contextRequire), ct);
                 }
                 async _applyConfiguration(data: RegistrationMap<S>, resolver?: ModuleResolver, ct = Cancellation.none) {
                     trace.log("applyConfiguration");
                     this._configName = "$";
                     if (resolver)
                         this._require = resolver;
                     let services: PartialServiceMap<S>;
                     try {
                         services = await this._visitRegistrations(data, "$");
                     } catch (e) {
                         throw this._makeError(e);
                     }
                     this._container.register(services);
                 }
                 _makeError(inner: any) {
                     const e = new ConfigError("Failed to load configuration", inner);
                     e.configName = this._configName || "<inline>";
                     e.path = this._makePath();
                     return e;
                 }
                 _makePath() {
                     return this._path
                         .reduce(
                             (prev, cur) => typeof cur === "number" ?
                                 `${prev}[${cur}]` :
                                 `${prev}.${cur}`
                         )
                         .toString();
                 }
                 async _resolveType(moduleName: string, localName: string) {
                     trace.log("resolveType moduleName={0}, localName={1}", moduleName, localName);
                     try {
                         const m = await this._loadModule(moduleName);
-                        return localName ? get(localName, m) : m;
+                        if (localName) {
+                            return get(localName, m);
+                        } else {
+                            if (m instanceof Function)
+                                return m;
+                            if ("default" in m)
+                                return m.default;
+                            return m;
+                        }
                     } catch (e) {
                         trace.error("Failed to resolve type moduleName={0}, localName={1}", moduleName, localName);
                         throw e;
                     }
                 }
                 _loadModule(moduleName: string) {
                     trace.debug("loadModule {0}", moduleName);
                     if (!this._require)
                         throw new Error("Module loader isn't specified");
                     return this._require(moduleName);
                 }
                 async _visitRegistrations(data: RegistrationMap<S>, name: string) {
                     this._enter(name);
                     if (data.constructor &&
                         data.constructor.prototype !== Object.prototype)
                         throw new Error("Configuration must be a simple object");
                     const services = await mapAll(data, async (v, k) => {
                         const d = await this._visit(v, k.toString());
                         return isDescriptor(d) ? d : new AggregateDescriptor(d);
                     }) as PartialServiceMap<S>;
                     this._leave();
                     return services;
                 }
                 _enter(name: string) {
                     this._path.push(name.toString());
                     trace.debug(">{0}", name);
                 }
                 _leave() {
                     const name = this._path.pop();
                     trace.debug("<{0}", name);
                 }
                 async _visit(data: any, name: string): Promise<any> {
                     if (isPrimitive(data) || isDescriptor(data))
                         return data;
                     if (isDependencyRegistration<S>(data)) {
                         return this._visitDependencyRegistration(data, name);
                     } else if (isValueRegistration(data)) {
                         return this._visitValueRegistration(data, name);
                     } else if (isTypeRegistration(data)) {
                         return this._visitTypeRegistration(data, name);
                     } else if (isFactoryRegistration(data)) {
                         return this._visitFactoryRegistration(data, name);
                     } else if (data instanceof Array) {
                         return this._visitArray(data, name);
                     }
                     return this._visitObject(data, name);
                 }
                 async _visitObject(data: any, name: string) {
                     if (data.constructor &&
                         data.constructor.prototype !== Object.prototype)
                         return new ValueDescriptor(data);
                     this._enter(name);
                     const v = await mapAll(data, delegate(this, "_visit"));
                     // TODO: handle inline descriptors properly
                     // const ex = {
                     //     activate(ctx) {
                     //         const value = ctx.activate(this.prop, "prop");
                     //         // some code
                     //     },
                     //     // will be turned to ReferenceDescriptor
                     //     prop: { $dependency: "depName" }
                     // };
                     this._leave();
                     return v;
                 }
                 async _visitArray(data: any[], name: string) {
                     if (data.constructor &&
                         data.constructor.prototype !== Array.prototype)
                         return new ValueDescriptor(data);
                     this._enter(name);
                     const v = await mapAll(data, delegate(this, "_visit"));
                     this._leave();
                     return v;
                 }
                 _makeServiceParams(data: ServiceRegistration<any, S>) {
                     const opts: any = {
                     };
                     if (data.services)
                         opts.services = this._visitRegistrations(data.services, "services");
                     if (data.inject) {
                         this._enter("inject");
                         opts.inject = mapAll(
                             data.inject instanceof Array ?
                                 data.inject :
                                 [data.inject],
                             delegate(this, "_visitObject")
                         );
                         this._leave();
                     }
                     if ("params" in data)
                         opts.params = data.params instanceof Array ?
                             this._visitArray(data.params, "params") :
                             this._visit(data.params, "params");
                     if (data.activation) {
-                        opts.activation = this._getLifetimeManager(data.activation);
+                        opts.activation = this._getLifetimeManager(data.activation, data.typeId);
                     }
                     if (data.cleanup)
                         opts.cleanup = data.cleanup;
                     return opts;
                 }
                 async _visitValueRegistration<T>(data: ValueRegistration<T>, name: string) {
                     this._enter(name);
                     const d = data.parse ? new AggregateDescriptor(data.$value) : new ValueDescriptor(data.$value);
                     this._leave();
                     return d;
                 }
                 async _visitDependencyRegistration<K extends keyof S>(data: DependencyRegistration<S, K>, name: string) {
                     argumentNotEmptyString(data && data.$dependency, "data.$dependency");
                     this._enter(name);
                     const options = {
                         name: data.$dependency,
                         optional: data.optional,
                         default: data.default,
                         services: data.services && await this._visitRegistrations(data.services, "services")
                     };
                     const d = data.lazy ? new LazyReferenceDescriptor<S, K>(options) : new ReferenceDescriptor<S, K>(options);
                     this._leave();
                     return d;
                 }
                 async _visitTypeRegistration(data: TypeRegistration<new () => any, S>, name: string) {
                     argumentNotNull(data.$type, "data.$type");
                     this._enter(name);
                     const opts = this._makeServiceParams(data);
                     if (data.$type instanceof Function) {
                         opts.type = data.$type;
                     } else {
                         const [moduleName, typeName] = data.$type.split(":", 2);
-                        opts.type = this._resolveType(moduleName, typeName);
+                        const t = opts.type = this._resolveType(moduleName, typeName);
+                        if (!(t instanceof Function))
+                            throw Error("$type (" + data.$type + ") is not a constructable");
                     }
                     const d = new TypeServiceDescriptor<S, any, any[]>(
                         await mapAll(opts)
                     );
                     this._leave();
                     return d;
                 }
                 async _visitFactoryRegistration(data: FactoryRegistration<() => any, S>, name: string) {
                     argumentOfType(data.$factory, Function, "data.$factory");
                     this._enter(name);
                     const opts = this._makeServiceParams(data);
                     opts.factory = data.$factory;
                     const d = new FactoryServiceDescriptor<S, any, any[]>(
                         await mapAll(opts)
                     );
                     this._leave();
                     return d;
                 }
-                _getLifetimeManager(activation: ActivationType) {
+                _getLifetimeManager(activation: ActivationType, typeId: string | undefined): ILifetimeManager {
                     switch (activation) {
                         case "container":
                             return this._container.getLifetimeManager();
                         case "hierarchy":
                             return LifetimeManager.hierarchyLifetime;
                         case "context":
                             return LifetimeManager.contextLifetime;
                         case "singleton":
-                            return LifetimeManager.singletonLifetime;
+                            if (typeId === undefined)
+                                throw Error("The singleton activation requires a typeId");
+                            return LifetimeManager.singletonLifetime(typeId);
                         default:
                             return LifetimeManager.empty;
                     }
                 }
             }

src/main/ts/di/Container.ts +4 -7

             import { ActivationContext } from "./ActivationContext";
             import { ValueDescriptor } from "./ValueDescriptor";
             import { ActivationError } from "./ActivationError";
-            import { ServiceMap, Descriptor, PartialServiceMap, ContainerProvided, Resolver, ContainerServiceMap, ContainerKeys, ContainerResolve, ILifetimeManager } from "./interfaces";
+            import { ServiceMap, Descriptor, PartialServiceMap, ContainerProvided, ServiceLocator, ContainerServiceMap, ContainerKeys, TypeOfService, ILifetimeManager } from "./interfaces";
             import { TraceSource } from "../log/TraceSource";
             import { Configuration, RegistrationMap } from "./Configuration";
             import { Cancellation } from "../Cancellation";
             import { MapOf, IDestroyable } from "../interfaces";
             import { isDescriptor } from "./traits";
             import { LifetimeManager } from "./LifetimeManager";
             import { each } from "../safe";
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
-            export class Container<S extends object = any> implements Resolver<S>, IDestroyable {
+            export class Container<S extends object = any> implements ServiceLocator<S>, IDestroyable {
                 readonly _services: ContainerServiceMap<S>;
-                readonly _cache: MapOf<any>;
                 readonly _lifetimeManager: ILifetimeManager;
                 readonly _cleanup: (() => void)[];
                 readonly _root: Container<S>;
                 readonly _parent?: Container<S>;
                 _disposed: boolean;
                 constructor(parent?: Container<S>) {
                     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) as any;
                     this._disposed = false;
                     this._lifetimeManager = new LifetimeManager();
                 }
                 getRootContainer() {
                     return this._root;
                 }
                 getParent() {
                     return this._parent;
                 }
                 getLifetimeManager() {
                     return this._lifetimeManager;
                 }
-                resolve<K extends ContainerKeys<S>>(name: K, def?: ContainerResolve<S, K>): ContainerResolve<S, K> {
+                resolve<K extends ContainerKeys<S>>(name: K, def?: TypeOfService<S, K>): TypeOfService<S, K> {
                     trace.debug("resolve {0}", name);
                     const d = this._services[name];
                     if (d === undefined) {
                         if (def !== undefined)
                             return def;
                         else
                             throw new Error("Service '" + name + "' isn't found");
                     } else {
                         const context = new ActivationContext<S>(this, this._services, String(name), d);
                         try {
                             return d.activate(context);
                         } catch (error) {
                             throw new ActivationError(name.toString(), context.getStack(), error);
                         }
                     }
                 }
                 /**
                  * @deprecated use resolve() method
                  */
-                getService<K extends ContainerKeys<S>>(name: K, def?: ContainerResolve<S, K>) {
+                getService<K extends ContainerKeys<S>>(name: K, def?: TypeOfService<S, K>) {
                     return this.resolve(name, def);
                 }
                 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]>) {
                     if (arguments.length === 1) {
                         const data = nameOrCollection as ServiceMap<S>;
                         each(data, (v, k) => this.register(k, v));
                     } else {
                         if (!isDescriptor(service))
                             throw new Error("The service parameter must be a descriptor");
                         this._services[nameOrCollection as K] = service as any;
                     }
                     return this;
                 }
                 onDispose(callback: () => void) {
                     if (!(callback instanceof Function))
                         throw new Error("The callback must be a function");
                     this._cleanup.push(callback);
                 }
                 destroy() {
                     return this.dispose();
                 }
                 dispose() {
                     if (this._disposed)
                         return;
                     this._disposed = true;
                     for (const f of this._cleanup)
                         f();
                 }
                 /**
                  * @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.
                  *
                  * @param{Function} opts.contextRequire
                  *  The function which will be used to load a configuration or types for services.
                  *
                  */
                 async configure(config: string | RegistrationMap<S>, opts?: any, ct = Cancellation.none) {
                     const c = new Configuration<S>(this);
                     if (typeof (config) === "string") {
                         return c.loadConfiguration(config, opts && opts.contextRequire, ct);
                     } else {
                         return c.applyConfiguration(config, opts && opts.contextRequire, ct);
                     }
                 }
                 createChildContainer<S2 extends object = S>(): Container<S & S2> {
                     return new Container<S & S2>(this as any);
                 }
             }

src/main/ts/di/LazyReferenceDescriptor.ts +4 -5

             import { argumentNotEmptyString, each } from "../safe";
             import { ActivationContext } from "./ActivationContext";
-            import { Descriptor, PartialServiceMap, ContainerResolve, ContainerKeys } from "./interfaces";
+            import { Descriptor, PartialServiceMap, TypeOfService, ContainerKeys } from "./interfaces";
             import { ActivationError } from "./ActivationError";
             export interface ReferenceDescriptorParams<S extends object, K extends ContainerKeys<S>> {
                 name: K;
                 optional?: boolean;
-                default?: ContainerResolve<S, K>;
+                default?: TypeOfService<S, K>;
                 services?: PartialServiceMap<S>;
             }
             export class LazyReferenceDescriptor<S extends object = any, K extends ContainerKeys<S> = ContainerKeys<S>>
-                implements Descriptor<S, ((args?: PartialServiceMap<S>) => ContainerResolve<S, K>)> {
+                implements Descriptor<S, ((args?: PartialServiceMap<S>) => TypeOfService<S, K>)> {
                 _name: K;
                 _optional = false;
-                _default: ContainerResolve<S, K> | undefined;
+                _default: TypeOfService<S, K> | undefined;
                 _services: PartialServiceMap<S>;
                 constructor(opts: ReferenceDescriptorParams<S, K>) {
                     argumentNotEmptyString(opts && opts.name, "opts.name");
                     this._name = opts.name;
                     this._optional = !!opts.optional;
                     this._default = opts.default;
                     this._services = (opts.services || {}) as PartialServiceMap<S>;
                 }
                 activate(context: ActivationContext<S>) {
                     // добавляем сервисы
                     if (this._services) {
                         each(this._services, (v, k) => context.register(k, v));
                     }
                     const saved = context.clone();
                     return (cfg?: PartialServiceMap<S>) => {
                         // защищаем контекст на случай исключения в процессе
                         // активации
                         const ct = cfg ? saved.clone() : saved;
                         try {
                             if (cfg) {
                                 each(cfg, (v, k) => ct.register(k, v));
                             }
                             return this._optional ? ct.resolve(this._name, this._default) : ct
                                 .resolve(this._name);
                         } catch (error) {
                             throw new ActivationError(this._name.toString(), ct.getStack(), error);
                         }
                     };
                 }
                 toString() {
                     const opts = [];
                     if (this._optional)
                         opts.push("optional");
                     opts.push("lazy");
                     const parts = [
                         "@ref "
                     ];
                     if (opts.length) {
                         parts.push("{");
                         parts.push(opts.join());
                         parts.push("} ");
                     }
                     parts.push(this._name.toString());
                     if (this._default !== undefined && this._default !== null) {
                         parts.push(" = ");
                         parts.push(String(this._default));
                     }
                     return parts.join("");
                 }
             }

src/main/ts/di/LifetimeManager.ts +16 -26

             import { IDestroyable, MapOf } from "../interfaces";
             import { argumentNotNull, isDestroyable } from "../safe";
             import { ILifetimeManager, ILifetime } from "./interfaces";
             import { ActivationContext } from "./ActivationContext";
             function safeCall(item: () => void) {
                 try {
                     item();
                 } catch {
                     // silence!
                 }
             }
             const emptyLifetime: ILifetime = {
                 has() {
                     return false;
                 },
                 enter() {
                 },
                 get() {
                     throw new Error("The specified item isn't registered with this lifetime manager");
                 },
                 store() {
                     // does nothing
                 }
             };
+            let nextId = 0;
             export class LifetimeManager implements IDestroyable, ILifetimeManager {
                 private _cleanup: (() => void)[] = [];
                 private _cache: MapOf<any> = {};
                 private _destroyed = false;
                 private _pending: MapOf<boolean> = {};
-                initialize(id: string): ILifetime {
+                initialize(): ILifetime {
                     const self = this;
+                    const id = ++nextId;
                     return {
                         has() {
                             return (id in self._cache);
                         },
                         get() {
                             const t = self._cache[id];
                             if (t === undefined)
                                 throw new Error(`The item with with the key ${id} isn't found`);
                             return t;
                         },
                         enter() {
                             if (self._pending[id])
                                 throw Error(`Cyclic reference detected: the item with the key ${id} is already activating.`);
                             self._pending[id] = true;
                         },
                         store(item: any, cleanup?: (item: any) => void) {
                             argumentNotNull(id, "id");
                             argumentNotNull(item, "item");
                             if (this.has())
                                 throw new Error(`The item with with the key ${id} already registered with this lifetime manager`);
                             delete self._pending[id];
                             self._cache[id] = item;
                             if (self._destroyed)
                                 throw new Error("Lifetime manager is destroyed");
                             if (cleanup) {
                                 self._cleanup.push(() => cleanup(item));
                             } else if (isDestroyable(item)) {
                                 self._cleanup.push(() => item.destroy());
                             }
                         }
                     };
                 }
                 destroy() {
                     if (!this._destroyed) {
                         this._destroyed = true;
                         this._cleanup.forEach(safeCall);
                         this._cleanup.length = 0;
                     }
                 }
                 static readonly empty: ILifetimeManager = {
                     initialize(): ILifetime {
                         return emptyLifetime;
-                    },
-                    destroy() {
-                        throw new Error("Trying to destroy empty lifetime manager, this is a bug.");
                     }
                 };
                 static readonly hierarchyLifetime: ILifetimeManager = {
-                    initialize(id: string, context: ActivationContext<any>): ILifetime {
+                    initialize(context: ActivationContext<any>): ILifetime {
-                        return context.getContainer().getLifetimeManager().initialize(id, context);
+                        return context.getContainer().getLifetimeManager().initialize(context);
-                    },
-                    destroy() {
-                        throw new Error("Trying to destroy hierarchy lifetime manager, this is a bug.");
-                };
-                static readonly singletonLifetime: ILifetimeManager = {
-                    initialize(id: string): ILifetime {
-                        return singletonLifetimeManager.initialize(id);
-                    },
-                    destroy() {
-                        throw new Error("Trying to destroy singleton lifetime manager, this is a bug.");
                     }
                 };
                 static readonly contextLifetime: ILifetimeManager = {
-                    initialize(id: string, context: ActivationContext<any>): ILifetime {
+                    initialize(context: ActivationContext<any>): ILifetime {
+                        const id = String(++nextId);
                         return {
                             enter() {
                                 if (context.visit(id))
                                     throw new Error("Cyclic reference detected");
                             },
                             get() {
                                 return context.get(id);
                             },
                             has() {
                                 return context.has(id);
                             },
                             store(item: any) {
                                 context.store(id, item);
                             }
                         };
-                    },
-                    destroy() {
-                        throw new Error("Trying to destroy empty lifetime manager, this is a bug.");
                     }
                 };
+                static singletonLifetime(typeId: string): ILifetimeManager {
+                    return {
+                        initialize() {
+                            return emptyLifetime;
+                        }
+                    };
+                }
             }
-            const singletonLifetimeManager = new LifetimeManager();

src/main/ts/di/ReferenceDescriptor.ts +4 -4

             import { argumentNotEmptyString, each } from "../safe";
             import { ActivationContext } from "./ActivationContext";
-            import { Descriptor, PartialServiceMap, ContainerResolve, ContainerKeys } from "./interfaces";
+            import { Descriptor, PartialServiceMap, TypeOfService, ContainerKeys } from "./interfaces";
             export interface ReferenceDescriptorParams<S extends object, K extends ContainerKeys<S>> {
                 name: K;
                 optional?: boolean;
-                default?: ContainerResolve<S, K>;
+                default?: TypeOfService<S, K>;
                 services?: PartialServiceMap<S>;
             }
             export class ReferenceDescriptor<S extends object = any, K extends ContainerKeys<S> = ContainerKeys<S>>
-                implements Descriptor<S, ContainerResolve<S, K>> {
+                implements Descriptor<S, TypeOfService<S, K>> {
                 _name: K;
                 _optional = false;
-                _default: ContainerResolve<S, K> | undefined;
+                _default: TypeOfService<S, K> | undefined;
                 _services: PartialServiceMap<S>;
                 constructor(opts: ReferenceDescriptorParams<S, K>) {
                     argumentNotEmptyString(opts && opts.name, "opts.name");
                     this._name = opts.name;
                     this._optional = !!opts.optional;
                     this._default = opts.default;
                     this._services = (opts.services || {}) as PartialServiceMap<S>;
                 }
                 activate(context: ActivationContext<S>) {
                     // добавляем сервисы
                     if (this._services) {
                         each(this._services, (v, k) => context.register(k, v));
                     }
                     const res = this._optional ?
                         context.resolve(this._name, this._default) :
                         context.resolve(this._name);
                     return res;
                 }
                 toString() {
                     const opts = [];
                     if (this._optional)
                         opts.push("optional");
                     const parts = [
                         "@ref "
                     ];
                     if (opts.length) {
                         parts.push("{");
                         parts.push(opts.join());
                         parts.push("} ");
                     }
                     parts.push(this._name.toString());
                     if (this._default !== undefined && this._default !== null) {
                         parts.push(" = ");
                         parts.push(String(this._default));
                     }
                     return parts.join("");
                 }
             }

src/main/ts/di/ServiceDescriptor.ts +10 -10

             import { ActivationContext } from "./ActivationContext";
-            import { Descriptor, ServiceMap, PartialServiceMap, ILifetimeManager } from "./interfaces";
+            import { Descriptor, ServiceMap, PartialServiceMap, ILifetimeManager, ILifetime } from "./interfaces";
-            import { argumentNotNull, isPrimitive, keys, isNull } from "../safe";
+            import { isPrimitive, keys, isNull } from "../safe";
             import { TraceSource } from "../log/TraceSource";
             import { isDescriptor } from "./traits";
             import { LifetimeManager } from "./LifetimeManager";
             import { MatchingMemberKeys } from "../interfaces";
-            import { Container } from "./Container";
-            let cacheId = 0;
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
             function injectMethod<T, M extends keyof T, S extends object, A>(target: T, method: M, context: ActivationContext<S>, args: A) {
                 const m = target[method];
                 if (!m || typeof m !== "function")
                     throw new Error("Method '" + method + "' not found");
                 if (args instanceof Array)
                     return m.apply(target, _parse(args, context, "." + method));
                 else
                     return m.call(target, _parse(args, context, "." + method));
             }
             function makeCleanupCallback<T>(method: Cleaner<T>) {
                 if (typeof (method) === "function") {
                     return (target: T) => {
                         method(target);
                     };
                 } else {
                     return (target: T) => {
                         const m = target[method] as any;
                         m.apply(target);
                     };
                 }
             }
             function _parse(value: any, context: ActivationContext<any>, path: string): any {
                 if (isPrimitive(value))
                     return value as any;
                 trace.debug("parse {0}", path);
                 if (isDescriptor(value))
                     return context.activate(value, path);
                 if (value instanceof Array)
                     return value.map((x, i) => _parse(x, context, `${path}[${i}]`)) as any;
                 const t: any = {};
                 keys(value).forEach(p => t[p] = _parse(value[p], context, `${path}.${p}`));
                 return t;
             }
             export type Cleaner<T> = ((x: T) => void) | MatchingMemberKeys<() => void, T>;
             export type InjectionSpec<T> = {
                 [m in keyof T]?: any;
             };
             export interface ServiceDescriptorParams<S extends object, T, P extends any[]> {
                 lifetime?: ILifetimeManager;
                 params?: P;
                 inject?: InjectionSpec<T>[];
                 services?: PartialServiceMap<S>;
                 cleanup?: Cleaner<T>;
             }
             export class ServiceDescriptor<S extends object, T, P extends any[]> implements Descriptor<S, T> {
                 _services: ServiceMap<S>;
                 _params: P | undefined;
                 _inject: InjectionSpec<T>[];
                 _cleanup: ((item: T) => void) | undefined;
-                _cacheId = String(++cacheId);
+                _lifetimeManager = LifetimeManager.empty;
-                _lifetime = LifetimeManager.empty;
+                _objectLifetime: ILifetime | undefined;
                 constructor(opts: ServiceDescriptorParams<S, T, P>) {
                     if (opts.lifetime)
-                        this._lifetime = opts.lifetime;
+                        this._lifetimeManager = opts.lifetime;
                     if (!isNull(opts.params))
                         this._params = opts.params;
                     this._inject = opts.inject || [];
                     this._services = (opts.services || {}) as ServiceMap<S>;
                     if (opts.cleanup) {
                         if (!(typeof (opts.cleanup) === "string" || opts.cleanup instanceof Function))
                             throw new Error(
                                 "The cleanup parameter must be either a function or a function name");
                         this._cleanup = makeCleanupCallback(opts.cleanup);
                     }
                 }
                 activate(context: ActivationContext<S>) {
-                    const lifetime = this._lifetime.initialize(this._cacheId, context);
+                    if (!this._objectLifetime)
+                        this._objectLifetime = this._lifetimeManager.initialize(context);
+                    const lifetime = this._objectLifetime;
                     if (lifetime.has()) {
                         return lifetime.get();
                     } else {
                         lifetime.enter();
                         const instance = this._create(context);
-                        lifetime.store(this._cacheId, this._cleanup);
+                        lifetime.store(instance, this._cleanup);
                         return instance;
                     }
                 }
                 _factory(...params: any[]): T {
                     throw Error("Not implemented");
                 }
                 _create(context: ActivationContext<S>) {
                     trace.debug(`constructing ${context._name}`);
                     if (this._services) {
                         keys(this._services).forEach(p => context.register(p, this._services[p]));
                     }
                     let instance: T;
                     if (this._params === undefined) {
                         instance = this._factory();
                     } else if (this._params instanceof Array) {
                         instance = this._factory.apply(this, _parse(this._params, context, "args"));
                     } else {
                         instance = this._factory(_parse(this._params, context, "args"));
                     }
                     if (this._inject) {
                         this._inject.forEach(spec => {
                             for (const m in spec)
                                 injectMethod(instance, m, context, spec[m]);
                         });
                     }
                     return instance;
                 }
                 clone() {
                     return Object.create(this);
                 }
             }

src/main/ts/di/fluent/interfaces.ts +20 -43

@@ -1,71 +1,48
1	import { primitive } from "../../safe";	1	import { primitive } from "../../safe";
2	import { A~~ctivationType~~ } from "../~~interface~~s";	2	import { AnnotationBuilder } from "../Annotations";
3	import { AnnotaionBuilder } from "../Annotations";	3	import { ILifetime, TypeOfService, ContainerKeys } from "../interfaces";
4	import { LazyDependencyRegistration, DependencyRegistration } from "../Configuration";
5	import { Container } from "../Container";
6		4
7	export interface DependencyOptions<T> {	5	export interface DependencyOptions {
8	optional?: boolean;	6	optional?: boolean;
9	default?: T;	7	default?: any;
10	}	8	}
11		9
12	export interface LazyDependencyOptions<T> extends DependencyOptions<T> {	10	export interface LazyDependencyOptions extends DependencyOptions {
13	lazy: true;	11	lazy: true;
14	}	12	}
15		13
16	export type ExtractService<K, S> = K extends keyof S ? S[K] : K;	14	export type ExtractService<K, S> = K extends keyof S ? S[K] : never;
17		15
18	export type ExtractDependency<D, S> = D extends { $dependency: infer K } ?	16	export type ExtractDependency<D, S> = D extends { $dependency: infer K } ?
19	D extends { lazy: true } ? () => ExtractService<K, S> : ExtractService<K, S> :	17	D extends { lazy: true } ? () => ExtractService<K, S> : ExtractService<K, S> :
20	D extends { $type: new (...args: any[]) => infer I } ? I :	18	D extends { $type: new (...args: any[]) => infer I } ? I :
21	D extends { $factory: (...args: any[]) => infer R } ? R :	19	D extends { $factory: (...args: any[]) => infer R } ? R :
22	WalkDependencies<D, S>;	20	WalkDependencies<D, S>;
23		21
24	export type WalkDependencies<D, S> = D extends primitive ? D :	22	export type WalkDependencies<D, S> = D extends primitive ? D :
25	{ [K in keyof D]: ExtractDependency<D[K], S> };	23	{ [K in keyof D]: ExtractDependency<D[K], S> };
26		24
27	export type ServiceModule<T, S extends object, M extends keyof any = "service"> = {	25	export type ServiceModule<T, S extends object, M extends keyof any = "service"> = {
28	[m in M]: AnnotaionBuilder<T, S>;	26	[m in M]: AnnotationBuilder<T, S>;
29	};	27	};
30		28
31	export interface ServiceRecordBuilder<T, S extends object> {	29	export type InferReferenceType<S extends object, K extends keyof ContainerKeys<S>, O> = O extends { default: infer X } ? (TypeOfService<S, K> \| X) :
32	type<P extends any[], C extends new (...args: ExtractDependency<P, S>) => T>(	30	O extends { optional: true } ? (TypeOfService<S, K> \| undefined) :
33	target: C, ...params: P): ConstructorBuilder<C, S>;	31	TypeOfService<S, K>;
34	factory<P extends any[], F extends (...args: ExtractDependency<P, S>) => T>(	32
35	target: F, ...params: P): FactoryBuilder<F, S>;	33	export interface Resolver<S extends object> {
36	wired<M extends keyof any>(module: ServiceModule<T, S, M>, m: M): RegistrationBuilder<T, S>;	34	<K extends keyof ContainerKeys<S>, O extends LazyDependencyOptions>(this: void, name: K, opts: O): () => InferReferenceType<S, K, O>;
37	wired(module: ServiceModule<T, S>): RegistrationBuilder<T, S>;	35	<K extends keyof ContainerKeys<S>, O extends DependencyOptions>(this: void, name: K, opts?: O): InferReferenceType<S, K, O>;
38	}	36	}
39		37
40	export interface RegistrationVisitor {	38	export interface DescriptorBuilder<T, S extends object> {
41	visitDependency(): void;	39	service(service: AnnotationBuilder<T, S> \| ServiceModule<T, S>): void;
42
43	visitObject(): void;
44
45	visitTypeRegistration(): void;
46		40
47	visitFactoryRegistration(): void;	41	factory(f: (resolve: Resolver<S>, activate: <T2>(lifetime: ILifetime, factory: () => T2, cleanup?: (item: T2) => void) => T2) => T): void;
48		42
49	}	43	value(v: T): void;
50
51	export interface ServiceRegistration {
52	visit(visitor: RegistrationVisitor): void;
53	}	44	}
54		45
55	export interface ConfigBu~~ilde~~r<S extends object, Y extends keyof S = keyof S> {	46	export interface Configuration<S extends object, Y extends keyof S = keyof S> {
56	register<K extends Y>(name: K, builder: (t: ~~ServiceRecord~~Builder<S[K], S>) => void \| ~~Promise~~<~~void~~>): ConfigBu~~ilde~~r<S, Exclude<Y, K>>;	47	register<K extends Y>(name: K, builder: (d: DescriptorBuilder<S[K], S>) => void): Configuration<S, Exclude<Y, K>>;
57	register<K extends Y, V>(name: S[K] extends ExtractDependency<V, S> ? K : never, value: V): ConfigBuilder<S, Exclude<Y, K>>;
58	register<K extends Y>(name: K, value: S[K], raw: true): ConfigBuilder<S, Exclude<Y, K>>;
59
60	apply(container: Container<S>): Promise<void>;
61	}	48	}
62
63	export interface ServicesDeclaration<S extends object> {
64	build<T>(this: void): ServiceRecordBuilder<T, S>;
65	annotate<T>(this: void): AnnotaionBuilder<T, S>;
66
67	dependency<K extends keyof S>(this: void, name: K, opts: LazyDependencyOptions<S[K]>): LazyDependencyRegistration<S, K>;
68	dependency<K extends keyof S>(this: void, name: K, opts?: DependencyOptions<S[K]>): DependencyRegistration<S, K>;
69
70	configure(): ConfigBuilder<S>;
71	}

src/main/ts/di/interfaces.ts +12 -8

             import { ActivationContext } from "./ActivationContext";
-            import { IDestroyable } from "../interfaces";
             export interface Descriptor<S extends object = any, T = any> {
                 activate(context: ActivationContext<S>): T;
             }
             export type ServiceMap<S extends object> = {
                 [k in keyof S]: Descriptor<S, S[k]>;
             };
             export type ContainerKeys<S extends object> = keyof S | keyof ContainerProvided<S>;
-            export type ContainerResolve<S extends object, K> =
+            export type TypeOfService<S extends object, K> =
                 K extends keyof ContainerProvided<S> ? ContainerProvided<S>[K] :
                 K extends keyof S ? S[K] : never;
             export type ContainerServiceMap<S extends object> = {
-                [K in ContainerKeys<S>]: Descriptor<S, ContainerResolve<S, K>>;
+                [K in ContainerKeys<S>]: Descriptor<S, TypeOfService<S, K>>;
             };
             export type PartialServiceMap<S extends object> = {
                 [k in keyof S]?: Descriptor<S, S[k]>;
             };
-            export interface Resolver<S extends object> {
+            export interface ServiceLocator<S extends object> {
-                resolve<K extends ContainerKeys<S>>(name: K, def?: ContainerResolve<S, K>): ContainerResolve<S, K>;
+                resolve<K extends ContainerKeys<S>>(name: K, def?: TypeOfService<S, K>): TypeOfService<S, K>;
             }
             export interface ContainerProvided<S extends object> {
-                container: Resolver<S>;
+                container: ServiceLocator<S>;
             }
             export type ContainerRegistered<S extends object> = /*{
                 [K in Exclude<keyof S, keyof ContainerProvided<S>>]: S[K];
             };*/
                 Exclude<S, ContainerProvided<S>>;
             export type ActivationType = "singleton" | "container" | "hierarchy" | "context" | "call";
-            export interface ILifetimeManager extends IDestroyable {
+            export interface ILifetimeManager {
-                initialize(id: string, context: ActivationContext<any>): ILifetime;
+                initialize(context: ActivationContext<any>): ILifetime;
             }
+            /**
+             * Интерфейс для управления жизнью экземпляра объекта. Каждая регистрация имеет
+             * свой собственный объект `ILifetime`, который создается при первой активации
+             */
             export interface ILifetime {
+                /** Проверяет, что уже создан экземпляр объекта */
                 has(): boolean;
                 get(): any;
                 enter(): void;
                 store(item: any, cleanup?: (item: any) => void): void;
             }

src/main/ts/di/traits.ts +5 -32

@@ -1,50 +1,23
1	import { isPrimitive } from "../safe";	1	import { isPrimitive } from "../safe";
2	import { Descriptor } from "./interfaces";	2	import { Descriptor } from "./interfaces";
3	import { ServicesDeclaration, ServiceRecordBuilder, ServiceModule, RegistrationBuilder, ExtractDependency } from "./fluent/interfaces";	3	import { AnnotationBuilder } from "./Annotations";
4	import { ~~AnnotaionBuilder~~ } from "./~~Annotations~~";	4	import { Configuration } from "./fluent/Configuration";
5	import { FactoryBuilder } from "./fluent/FactoryBuilder";
6	import { ConstructorBuilder } from "./fluent/ConstructorBuiler";
7		5
8	export function isDescriptor(x: any): x is Descriptor {	6	export function isDescriptor(x: any): x is Descriptor {
9	return (!isPrimitive(x)) &&	7	return (!isPrimitive(x)) &&
10	(x.activate instanceof Function);	8	(x.activate instanceof Function);
11	}	9	}
12		10
13	export function declare<S extends object>(): ~~ServicesDeclaration~~<S> {	11	export function declare<S extends object>() {
14	return {	12	return {
15	annotate<T>() {	13	annotate<T>() {
16	return new AnnotaionBuilder<T, S>();	14	return new AnnotationBuilder<T, S>();
17	},	15	},
18	build<T>(): ServiceRecordBuilder<T, S> {	16	configure(): Configuration<S> {
19	return {
20	factory<P extends any[], F extends (...args: ExtractDependency<P, S>) => T>(
21	target: F,
22	...params: P
23	): FactoryBuilder<F, S> {
24	return new FactoryBuilder(target, params);
25	},
26
27	type<P extends any[], C extends new (...args: ExtractDependency<P, S>) => T>(
28	target: C, ...params: P
29	): ConstructorBuilder<C, S> {
30	return new ConstructorBuilder(target, params);
31	},
32
33	wired<M extends keyof any>(module: ServiceModule<T, S, M>, m?: M): RegistrationBuilder<T, S> {
34	const service = m ?
35	module[m] :
36	(module as ServiceModule<T, S>).service;
37	if (!service)
38	throw new Error("The specified module doen's provides a service annotation");
39	return service.getRegistrationBuilder();
40	}
41	};
42	},
43	configure() {
44	throw new Error();	17	throw new Error();
45	},	18	},
46	dependency() {	19	dependency() {
47	throw new Error();	20	throw new Error();
48	}	21	}
49	};	22	};
50	}	23	}

src/test/ts/mock/config.ts +17 -14

@@ -1,17 +1,20
1	import { configure, ~~dependency~~, ~~build~~ } from "./services";	1	import { configure } from "./services";
2		2
3	export const config = configure()	3	export const config = configure()
4	.register("bar", async s => s.wired(await import("./Bar"), "service"))	4	.register("host", s => s.value("example.com"))
5	.register("box", s => import("./Box").then(m => s.wired(m)))	5	.register("bar2", bar2 => Promise.all([import("./Foo"), import("./Bar")])
6	.register("host", "example.com")	6	.then(([{ Foo }, { Bar }]) => {
7	// .registerType("bar2", Bar, [{ foo: dependency("foo"), host: "" }]);	7	const lifetime: any = undefined; // new HierarchyLifetime()
8	.register("bar2", async s => s.type((await import("./Bar")).Bar,	8	bar2.factory((resolve, activate) => {
9	{	9	const bar = new Bar({
10	foo: build().type((await import("./Foo")).Foo)	10	foo: activate(lifetime, () => new Foo()),
11	.activate("context"),	11	nested: {
12	~~nested~~: { lazy: ~~dependency~~("foo", { lazy: true }) },	12	lazy: resolve("foo", { lazy: true })
13	host: dependency("host")	13	},
14	},	14	host: resolve("host")
15	"")	15	}, "some text");
16	.inject("setName", dependency("host"))	16	bar.setName(resolve("host"));
		17	return bar;
		18	});
		19	})
17	);	20	);

src/test/ts/mock/services.ts +2 -2

             import { Foo } from "./Foo";
             import { Bar } from "./Bar";
             import { Box } from "./Box";
-            import { declare } from "../di/fluent/interfaces";
+            import { declare } from "../di/traits";
             /**
              * Сервисы доступные внутри контейнера
              */
             export interface Services {
                 foo: Foo;
                 bar: Bar;
                 bar2: Bar;
                 box: Box<Bar>;
                 host: string;
             }
             /**
              * Экспортируем вспомогательные функции для описания сервисов и кинфогурации
              */
-            export const { dependency, build, annotate, configure } = declare<Services>();
+            export const { dependency, annotate, configure } = declare<Services>();

src/main/ts/di/fluent/ConfigBuilder.ts removed 0 -17

NO CONTENT: file was removed

src/main/ts/di/fluent/ConstructorBuiler.ts removed 0 -17

NO CONTENT: file was removed

src/main/ts/di/fluent/FactoryBuilder.ts removed 0 -14

NO CONTENT: file was removed

src/main/ts/di/fluent/RegistrationBuilder.ts removed 0 -37

NO CONTENT: file was removed

src/main/ts/di/fluent/ServiceRecordBuilder.ts removed 0 0

NO CONTENT: file was removed

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages