implab/implabjs-core Commit - r138:a2fb9af6341c

Merge with ioc ts support

cin -

r138:a2fb9af6341c v1.4.0-rc1 default

parent child

Context file:

r138:a2fb9af6341c

Expand all files

src/main/ts/EventProvider.ts created 644 +41 0

@@ -0,0 +1,41
	1	import { IDestroyable } from "./interfaces";
	2	import { Observable } from "./Observable";
	3
	4	/**
	5	* Event proviers are used to produce events, throug this object you can feed
	6	* the Observable with input events. Once the EventProvider is destroyed the
	7	* bound obsevable is disconnected and marked as 'done'.
	8	*/
	9	export class EventProvider<T> implements IDestroyable {
	10
	11	_observable: Observable<T> \| undefined;
	12
	13	_next: ((evt: T) => void) \| undefined;
	14	_done: (() => void) \| undefined;
	15
	16	constructor() {
	17	this._observable = new Observable<T>((next, _error, done) => {
	18	this._next = next;
	19	this._done = done;
	20	});
	21	}
	22
	23	destroy(): void {
	24	if (this._observable) {
	25	// break all references
	26	this._observable = undefined;
	27	this._next = undefined;
	28	this._done = undefined;
	29	}
	30	}
	31	post(event: T) {
	32	return this._next && this._next(event);
	33	}
	34
	35	getObservable() {
	36	if (!this._observable)
	37	throw new Error("The object is destroyed");
	38
	39	return this._observable;
	40	}
	41	}

src/main/ts/di/LazyReferenceDescriptor.ts created 644 +83 0

@@ -0,0 +1,83
	1	import { argumentNotEmptyString, each } from "../safe";
	2	import { ActivationContext } from "./ActivationContext";
	3	import { Descriptor, PartialServiceMap, TypeOfService, ContainerKeys } from "./interfaces";
	4	import { ActivationError } from "./ActivationError";
	5
	6	export interface ReferenceDescriptorParams<S extends object, K extends ContainerKeys<S>> {
	7	name: K;
	8	optional?: boolean;
	9	default?: TypeOfService<S, K>;
	10	services?: PartialServiceMap<S>;
	11	}
	12
	13	export class LazyReferenceDescriptor<S extends object = any, K extends ContainerKeys<S> = ContainerKeys<S>>
	14	implements Descriptor<S, ((args?: PartialServiceMap<S>) => TypeOfService<S, K>)> {
	15
	16	_name: K;
	17
	18	_optional = false;
	19
	20	_default: TypeOfService<S, K> \| undefined;
	21
	22	_services: PartialServiceMap<S>;
	23
	24	constructor(opts: ReferenceDescriptorParams<S, K>) {
	25	argumentNotEmptyString(opts && opts.name, "opts.name");
	26	this._name = opts.name;
	27	this._optional = !!opts.optional;
	28	this._default = opts.default;
	29
	30	this._services = (opts.services \|\| {}) as PartialServiceMap<S>;
	31	}
	32
	33	activate(context: ActivationContext<S>) {
	34	// добавляем сервисы
	35	if (this._services) {
	36	each(this._services, (v, k) => context.register(k, v));
	37	}
	38
	39	const saved = context.clone();
	40
	41	return (cfg?: PartialServiceMap<S>): any => {
	42	// защищаем контекст на случай исключения в процессе
	43	// активации
	44	const ct = cfg ? saved.clone() : saved;
	45	try {
	46	if (cfg) {
	47	each(cfg, (v, k) => ct.register(k, v));
	48	}
	49
	50	return this._optional ? ct.resolve(this._name, this._default) : ct
	51	.resolve(this._name);
	52	} catch (error) {
	53	throw new ActivationError(this._name.toString(), ct.getStack(), error);
	54	}
	55	};
	56	}
	57
	58	toString() {
	59	const opts = [];
	60	if (this._optional)
	61	opts.push("optional");
	62
	63	opts.push("lazy");
	64
	65	const parts = [
	66	"@ref "
	67	];
	68	if (opts.length) {
	69	parts.push("{");
	70	parts.push(opts.join());
	71	parts.push("} ");
	72	}
	73
	74	parts.push(this._name.toString());
	75
	76	if (this._default !== undefined && this._default !== null) {
	77	parts.push(" = ");
	78	parts.push(String(this._default));
	79	}
	80
	81	return parts.join("");
	82	}
	83	}

src/main/ts/di/LifetimeManager.ts created 644 +198 0

@@ -0,0 +1,198
	1	import { IDestroyable, MapOf } from "../interfaces";
	2	import { argumentNotNull, isDestroyable, primitive, isNull, argumentNotEmptyString } from "../safe";
	3	import { ILifetime } from "./interfaces";
	4	import { ActivationContext } from "./ActivationContext";
	5	import { Container } from "./Container";
	6
	7	function safeCall(item: () => void) {
	8	try {
	9	item();
	10	} catch {
	11	// silence!
	12	}
	13	}
	14
	15	const emptyLifetime: ILifetime = Object.freeze({
	16	has() {
	17	return false;
	18	},
	19
	20	initialize() {
	21
	22	},
	23
	24	get() {
	25	throw new Error("The specified item isn't registered with this lifetime manager");
	26	},
	27
	28	store() {
	29	// does nothing
	30	}
	31
	32	});
	33
	34	const unknownLifetime: ILifetime = Object.freeze({
	35	has() {
	36	return false;
	37	},
	38	initialize() {
	39	throw new Error("Can't call initialize on the unknown lifetime object");
	40	},
	41	get() {
	42	throw new Error("The lifetime object isn't initialized");
	43	},
	44	store() {
	45	throw new Error("Can't store a value in the unknown lifetime object");
	46	}
	47	});
	48
	49	let nextId = 0;
	50
	51	const singletons: { [k in keyof any]: any; } = {};
	52
	53	export class LifetimeManager implements IDestroyable {
	54	private _cleanup: (() => void)[] = [];
	55	private _cache: MapOf<any> = {};
	56	private _destroyed = false;
	57
	58	private _pending: MapOf<boolean> = {};
	59
	60	create(): ILifetime {
	61	const self = this;
	62	const id = ++nextId;
	63	return {
	64	has() {
	65	return (id in self._cache);
	66	},
	67
	68	get() {
	69	const t = self._cache[id];
	70	if (t === undefined)
	71	throw new Error(`The item with with the key ${id} isn't found`);
	72	return t;
	73	},
	74
	75	initialize() {
	76	if (self._pending[id])
	77	throw Error(`Cyclic reference detected: the item with the key ${id} is already activating.`);
	78	self._pending[id] = true;
	79	},
	80
	81	store(item: any, cleanup?: (item: any) => void) {
	82	argumentNotNull(id, "id");
	83	argumentNotNull(item, "item");
	84
	85	if (this.has())
	86	throw new Error(`The item with with the key ${id} already registered with this lifetime manager`);
	87	delete self._pending[id];
	88
	89	self._cache[id] = item;
	90
	91	if (self._destroyed)
	92	throw new Error("Lifetime manager is destroyed");
	93	if (cleanup) {
	94	self._cleanup.push(() => cleanup(item));
	95	} else if (isDestroyable(item)) {
	96	self._cleanup.push(() => item.destroy());
	97	}
	98	}
	99	};
	100	}
	101
	102	destroy() {
	103	if (!this._destroyed) {
	104	this._destroyed = true;
	105	this._cleanup.forEach(safeCall);
	106	this._cleanup.length = 0;
	107	}
	108	}
	109
	110	static empty(): ILifetime {
	111	return emptyLifetime;
	112	}
	113
	114	static hierarchyLifetime(): ILifetime {
	115	let _lifetime = unknownLifetime;
	116	return {
	117	initialize(context: ActivationContext<any>) {
	118	if (_lifetime !== unknownLifetime)
	119	throw new Error("Cyclic reference activation detected");
	120
	121	_lifetime = context.getContainer().getLifetimeManager().create();
	122	},
	123	get() {
	124	return _lifetime.get();
	125	},
	126	has() {
	127	return _lifetime.has();
	128	},
	129	store(item: any, cleanup?: (item: any) => void) {
	130	return _lifetime.store(item, cleanup);
	131	}
	132	};
	133	}
	134
	135	static contextLifetime(): ILifetime {
	136	let _lifetime = unknownLifetime;
	137	return {
	138	initialize(context: ActivationContext<any>) {
	139	if (_lifetime !== unknownLifetime)
	140	throw new Error("Cyclic reference detected");
	141	_lifetime = context.createLifetime();
	142	},
	143	get() {
	144	return _lifetime.get();
	145	},
	146	has() {
	147	return _lifetime.has();
	148	},
	149	store(item: any) {
	150	_lifetime.store(item);
	151	}
	152	};
	153	}
	154
	155	static singletonLifetime(typeId: string): ILifetime {
	156	argumentNotEmptyString(typeId, "typeId");
	157	let pending = false;
	158	return {
	159	has() {
	160	return typeId in singletons;
	161	},
	162	get() {
	163	if (!this.has())
	164	throw new Error(`The instance ${typeId} doesn't exists`);
	165	return singletons[typeId];
	166	},
	167	initialize() {
	168	if (pending)
	169	throw new Error("Cyclic reference detected");
	170	pending = true;
	171	},
	172	store(item: any) {
	173	singletons[typeId] = item;
	174	pending = false;
	175	}
	176	};
	177	}
	178
	179	static containerLifetime(container: Container<any>) {
	180	let _lifetime = unknownLifetime;
	181	return {
	182	initialize(context: ActivationContext<any>) {
	183	if (_lifetime !== unknownLifetime)
	184	throw new Error("Cyclic reference detected");
	185	_lifetime = container.getLifetimeManager().create();
	186	},
	187	get() {
	188	return _lifetime.get();
	189	},
	190	has() {
	191	return _lifetime.has();
	192	},
	193	store(item: any) {
	194	_lifetime.store(item);
	195	}
	196	};
	197	}
	198	}

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

@@ -0,0 +1,147
	1	import { Resolver, RegistrationBuilder } from "./interfaces";
	2	import { Container } from "../Container";
	3	import { Descriptor, ILifetime, ActivationType, PartialServiceMap } from "../interfaces";
	4	import { DescriptorImpl } from "./DescriptorImpl";
	5	import { LifetimeManager } from "../LifetimeManager";
	6	import { isString, each, isPrimitive, isPromise, oid } from "../../safe";
	7
	8	export class DescriptorBuilder<S extends object, T> {
	9	private readonly _container: Container<S>;
	10	private readonly _cb: (d: Descriptor<S, T>) => void;
	11
	12	private readonly _eb: (err: any) => void;
	13
	14	private _lifetime = LifetimeManager.empty();
	15
	16	private _overrides?: PartialServiceMap<S>;
	17
	18	private _cleanup?: (item: T) => void;
	19
	20	private _factory?: (resolve: Resolver<S>) => T;
	21
	22	private _pending = 1;
	23
	24	private _failed = false;
	25
	26	constructor(container: Container<S>, cb: (d: Descriptor<S, T>) => void, eb: (err: any) => void) {
	27	this._container = container;
	28	this._cb = cb;
	29	this._eb = eb;
	30	}
	31
	32	build<T2>(): DescriptorBuilder<S, T2> {
	33	this._defer();
	34	return new DescriptorBuilder<S, T2>(this._container, () => this._complete(), err => this._fail(err));
	35	}
	36
	37	override<K extends keyof S>(name: K, builder: RegistrationBuilder<S, S[K]>): this;
	38	override<K extends keyof S>(services: { [name in K]: RegistrationBuilder<S, S[K]> }): this;
	39	override<K extends keyof S>(nameOrServices: K \| { [name in K]: RegistrationBuilder<S, S[K]> }, builder?: RegistrationBuilder<S, S[K]>): this {
	40	const overrides: PartialServiceMap<S> = this._overrides ?
	41	this._overrides :
	42	(this._overrides = {});
	43
	44	const guard = (v: void \| Promise<void>) => {
	45	if (isPromise(v))
	46	v.catch(err => this._fail(err));
	47	};
	48
	49	if (isPrimitive(nameOrServices)) {
	50	if (builder) {
	51	this._defer();
	52	const d = new DescriptorBuilder<S, S[K]>(
	53	this._container,
	54	result => {
	55	overrides[nameOrServices] = result;
	56	this._complete();
	57	},
	58	err => this._fail(err)
	59	);
	60
	61	try {
	62	guard(builder(d));
	63	} catch (err) {
	64	this._fail(err);
	65	}
	66	}
	67	} else {
	68	each(nameOrServices, (v, k) => this.override(k, v));
	69	}
	70	return this;
	71	}
	72
	73	lifetime(lifetime: "singleton", typeId: string): this;
	74	lifetime(lifetime: ILifetime \| Exclude<ActivationType, "singleton">): this;
	75	lifetime(lifetime: ILifetime \| ActivationType, typeId?: string): this {
	76	if (isString(lifetime)) {
	77	this._lifetime = this._resolveLifetime(lifetime, typeId);
	78	} else {
	79	this._lifetime = lifetime;
	80	}
	81	return this;
	82	}
	83
	84	cleanup(cb: (item: T) => void): this {
	85	this._cleanup = cb;
	86	return this;
	87	}
	88
	89	factory(f: (resolve: Resolver<S>) => T): void {
	90	this._factory = f;
	91	this._complete();
	92	}
	93
	94	value(v: T): void {
	95	this._cb({
	96	activate() {
	97	return v;
	98	}
	99	});
	100	}
	101
	102	_resolveLifetime(activation: ActivationType, typeId?: string \| object) {
	103	switch (activation) {
	104	case "container":
	105	return LifetimeManager.containerLifetime(this._container);
	106	case "hierarchy":
	107	return LifetimeManager.hierarchyLifetime();
	108	case "context":
	109	return LifetimeManager.contextLifetime();
	110	case "singleton":
	111	if (!typeId)
	112	throw Error("The singleton activation requires a typeId");
	113
	114	const _oid = isString(typeId) ? typeId : oid(typeId);
	115
	116	return LifetimeManager.singletonLifetime(_oid);
	117	default:
	118	return LifetimeManager.empty();
	119	}
	120	}
	121
	122	_defer() {
	123	this._pending++;
	124	}
	125
	126	_complete() {
	127	if (--this._pending === 0) {
	128	if (!this._factory)
	129	throw new Error("The factory must be specified");
	130
	131	this._cb(new DescriptorImpl<S, T>({
	132	lifetime: this._lifetime,
	133	factory: this._factory,
	134	overrides: this._overrides,
	135	cleanup: this._cleanup
	136	}));
	137	}
	138	}
	139
	140	_fail(err: any) {
	141	if (!this._failed) {
	142	this._failed = true;
	143	this._eb.call(undefined, err);
	144	}
	145	}
	146
	147	}

src/main/ts/di/fluent/DescriptorImpl.ts created 644 +63 0

@@ -0,0 +1,63
	1	import { Descriptor, PartialServiceMap, ILifetime, ContainerKeys } from "../interfaces";
	2	import { ActivationContext } from "../ActivationContext";
	3	import { each } from "../../safe";
	4	import { DependencyOptions, LazyDependencyOptions, Resolver } from "./interfaces";
	5
	6	export interface DescriptorImplArgs<S extends object, T> {
	7	lifetime: ILifetime;
	8
	9	factory: (resolve: Resolver<S>) => T;
	10
	11	cleanup?: (item: T) => void;
	12
	13	overrides?: PartialServiceMap<S>;
	14	}
	15
	16	export class DescriptorImpl<S extends object, T> implements Descriptor<S, T> {
	17
	18	private readonly _overrides?: PartialServiceMap<S>;
	19
	20	private readonly _lifetime: ILifetime;
	21
	22	private readonly _factory: (resolve: Resolver<S>) => T;
	23
	24	private readonly _cleanup?: (item: T) => void;
	25
	26	constructor(args: DescriptorImplArgs<S, T>) {
	27	this._lifetime = args.lifetime;
	28	this._factory = args.factory;
	29	if (args.cleanup)
	30	this._cleanup = args.cleanup;
	31	if (args.overrides)
	32	this._overrides = args.overrides;
	33	}
	34
	35	activate(context: ActivationContext<S>): T {
	36
	37	if (this._lifetime.has())
	38	return this._lifetime.get();
	39
	40	this._lifetime.initialize(context);
	41
	42	if (this._overrides)
	43	each(this._overrides, (v, k) => context.register(k, v));
	44
	45	const resolve = (name: ContainerKeys<S>, opts?: DependencyOptions \| LazyDependencyOptions) => {
	46	if (opts && "lazy" in opts && opts.lazy) {
	47	const c2 = context.clone();
	48	return () => {
	49	return opts.optional ? c2.resolve(name, opts.default) : c2.resolve(name);
	50	};
	51	} else {
	52	return opts && opts.optional ? context.resolve(name, opts.default) : context.resolve(name);
	53	}
	54	};
	55
	56	const instance = this._factory.call(undefined, resolve);
	57
	58	this._lifetime.store(instance, this._cleanup);
	59
	60	return instance;
	61	}
	62
	63	}

src/main/ts/di/fluent/FluentConfiguration.ts created 644 +60 0

@@ -0,0 +1,60
	1	import { Container } from "../Container";
	2	import { argumentNotNull, each, isPrimitive, isPromise } from "../../safe";
	3	import { DescriptorBuilder } from "./DescriptorBuilder";
	4	import { RegistrationBuilder, FluentRegistrations } from "./interfaces";
	5	import { Cancellation } from "../../Cancellation";
	6
	7	export class FluentConfiguration<S extends object, Y extends keyof S = keyof S> {
	8
	9	_builders: { [k in keyof S]?: RegistrationBuilder<S, S[k]> } = {};
	10
	11	register<K extends Y>(name: K, builder: RegistrationBuilder<S, S[K]>): FluentConfiguration<S, Exclude<Y, K>>;
	12	register<K extends Y>(config: FluentRegistrations<K, S>): FluentConfiguration<S, Exclude<Y, K>>;
	13	register<K extends Y>(nameOrConfig: K \| FluentRegistrations<K, S>, builder?: RegistrationBuilder<S, S[K]>): FluentConfiguration<S, Exclude<Y, K>> {
	14	if (isPrimitive(nameOrConfig)) {
	15	argumentNotNull(builder, "builder");
	16	this._builders[nameOrConfig] = builder;
	17	} else {
	18	each(nameOrConfig, (v, k) => this.register(k, v));
	19	}
	20
	21	return this;
	22	}
	23
	24	apply<SC extends object>(target: Container<SC>, ct = Cancellation.none) {
	25
	26	let pending = 1;
	27
	28	const _t2 = target as unknown as Container<SC & S>;
	29
	30	return new Promise<Container<SC & S>>((resolve, reject) => {
	31	function guard(v: void \| Promise<void>) {
	32	if (isPromise(v))
	33	v.catch(reject);
	34	}
	35
	36	function complete() {
	37	if (!--pending)
	38	resolve(_t2);
	39	}
	40	each(this._builders, (v, k) => {
	41	pending++;
	42	const d = new DescriptorBuilder<SC & S, any>(_t2,
	43	result => {
	44	_t2.register(k, result);
	45	complete();
	46	},
	47	reject
	48	);
	49
	50	try {
	51	guard(v(d, ct));
	52	} catch (e) {
	53	reject(e);
	54	}
	55	});
	56	complete();
	57	});
	58	}
	59
	60	}

src/main/ts/di/fluent/interfaces.ts created 644 +52 0

@@ -0,0 +1,52
	1	import { primitive } from "../../safe";
	2	import { TypeOfService, ContainerKeys, ActivationType, ILifetime } from "../interfaces";
	3	import { ICancellation } from "../../interfaces";
	4
	5	export interface DependencyOptions {
	6	optional?: boolean;
	7	default?: any;
	8	}
	9
	10	export interface LazyDependencyOptions extends DependencyOptions {
	11	lazy: true;
	12	}
	13
	14	export type ExtractService<K, S> = K extends keyof S ? S[K] : never;
	15
	16	export type ExtractDependency<D, S> = D extends { $dependency: infer K } ?
	17	D extends { lazy: true } ? () => ExtractService<K, S> : ExtractService<K, S> :
	18	D extends { $type: new (...args: any[]) => infer I } ? I :
	19	D extends { $factory: (...args: any[]) => infer R } ? R :
	20	WalkDependencies<D, S>;
	21
	22	export type WalkDependencies<D, S> = D extends primitive ? D :
	23	{ [K in keyof D]: ExtractDependency<D[K], S> };
	24
	25	export type InferReferenceType<S extends object, K extends ContainerKeys<S>, O> = O extends { default: infer X } ? (TypeOfService<S, K> \| X) :
	26	O extends { optional: true } ? (TypeOfService<S, K> \| undefined) :
	27	TypeOfService<S, K>;
	28
	29	export interface Resolver<S extends object> {
	30	<K extends ContainerKeys<S>, O extends LazyDependencyOptions>(this: void, name: K, opts: O): () => InferReferenceType<S, K, O>;
	31	<K extends ContainerKeys<S>, O extends DependencyOptions>(this: void, name: K, opts?: O): InferReferenceType<S, K, O>;
	32	}
	33
	34	export interface DescriptorBuilder<S extends object, T> {
	35	factory(f: (resolve: Resolver<S>) => T): void;
	36
	37	build<T2>(): DescriptorBuilder<S, T2>;
	38
	39	override<K extends keyof S>(name: K, builder: RegistrationBuilder<S, S[K]>): this;
	40	override<K extends keyof S>(services: { [name in K]: RegistrationBuilder<S, S[K]> }): this;
	41
	42	lifetime(lifetime: "singleton", typeId: any): this;
	43	lifetime(lifetime: ILifetime \| Exclude<ActivationType, "singleton">): this;
	44
	45	cleanup(cb: (item: T) => void): this;
	46
	47	value(v: T): void;
	48	}
	49
	50	export type RegistrationBuilder<S extends object, T> = (d: DescriptorBuilder<S, T>, ct?: ICancellation) => void \| Promise<void>;
	51
	52	export type FluentRegistrations<K extends keyof S, S extends object> = { [k in K]: RegistrationBuilder<S, S[k]> };

src/main/ts/di/traits.ts created 644 +11 0

@@ -0,0 +1,11
	1	import { isPrimitive } from "../safe";
	2	import { Descriptor } from "./interfaces";
	3	import { FluentConfiguration } from "./fluent/FluentConfiguration";
	4	export function isDescriptor(x: any): x is Descriptor {
	5	return (!isPrimitive(x)) &&
	6	(x.activate instanceof Function);
	7	}
	8
	9	export function fluent<S extends object>() {
	10	return new FluentConfiguration<S>();
	11	}

src/test/ts/mock/Box.ts created 644 +28 0

@@ -0,0 +1,28
	1	import { Bar } from "./Bar";
	2
	3	// export service descriptor
	4	// через service передается информация о типе зависимости
	5	// даже если это шаблон.
	6	// export const service = annotate<Box<Bar>>();
	7
	8	// @service.wire()
	9	export class Box<T> {
	10	private _value: T \| undefined;
	11
	12	constructor(value?: T) {
	13	this._value = value;
	14	}
	15
	16	// @service.inject(dependency("bar"))
	17	setValue(value: T) {
	18	this._value = value;
	19	return value;
	20	}
	21
	22	getValue() {
	23	if (this._value === undefined)
	24	throw new Error("Trying to get a value from the empty box");
	25
	26	return this._value;
	27	}
	28	}

src/test/ts/mock/config.ts created 644 +14 0

@@ -0,0 +1,14
	1	import { Services } from "./services";
	2	import { fluent } from "../di/traits";
	3	import { Box } from "./Box";
	4
	5	export default fluent<Services>().register({
	6	host: it => it.value("example.com"),
	7
	8	foo: it => import("./Foo").then(({ Foo }) => it
	9	.factory(() => new Foo())
	10	),
	11
	12	box: it => it
	13	.factory($dependency => new Box($dependency("foo")))
	14	});

src/test/ts/mock/services.ts created 644 +15 0

@@ -0,0 +1,15
	1	import { Foo } from "./Foo";
	2	import { Bar } from "./Bar";
	3	import { Box } from "./Box";
	4
	5	/**
	6	* Сервисы доступные внутри контейнера
	7	*/
	8	export interface Services {
	9	foo: Foo;
	10
	11	box: Box<Foo>;
	12
	13	host: string;
	14
	15	}

src/test/ts/tests/FluentContainerTests.ts created 644 +63 0

@@ -0,0 +1,63
	1	import { test } from "./TestTraits";
	2	import { fluent } from "../di/traits";
	3	import { Bar } from "../mock/Bar";
	4	import { Container } from "../di/Container";
	5	import { Foo } from "../mock/Foo";
	6	import { Box } from "../mock/Box";
	7	import { delay } from "../safe";
	8	import { Services } from "../mock/services";
	9
	10	test("Simple fluent config", async t => {
	11	const config = fluent<{ host: string; bar: Bar; foo: Foo }>()
	12	.register({
	13	host: it => it.value("example.com"),
	14	bar: it => it.factory(resolve => new Bar({ host: resolve("host") }, "s-bar")),
	15	foo: it => import("../mock/Foo").then(m => it.lifetime("container").factory(() => new m.Foo()))
	16	});
	17
	18	const c1 = new Container<{}>();
	19	const container = await config.apply(c1);
	20
	21	t.equal(container.resolve("host"), "example.com", "The value should be resolved");
	22	t.assert(container.resolve("bar"), "The service should de activated");
	23	t.equal(container.resolve("foo"), container.resolve("foo"), "The service should be activated once");
	24	});
	25
	26	test("Nested async configuration", async t => {
	27	const container = await new Container<{
	28	foo: Foo;
	29	box: Box<Foo>
	30	}>().fluent({
	31	foo: it => delay(0).then(() => it.factory(() => new Foo())),
	32	box: it => it.lifetime("context").factory($dependency => new Box($dependency("foo")))
	33	});
	34
	35	t.assert(container.resolve("box").getValue(), "The dependency should be set");
	36	t.equals(container.resolve("box").getValue(), container.resolve("box").getValue(), "The service should be activated once")
	37	});
	38
	39	test("Bad fluent config", async t => {
	40	try {
	41	await new Container<{
	42	foo: Foo;
	43	box: Box<Foo>
	44	}>().fluent({
	45	foo: it => delay(0).then(() => it.factory(() => new Foo())),
	46	box: it => it.lifetime("context")
	47	.override("foo", () => { throw new Error("bad override"); })
	48	.factory($dependency => new Box($dependency("foo")))
	49	});
	50	t.fail("Should throw");
	51	} catch (e) {
	52	t.pass("The configuration should fail");
	53	t.equal(e.message, "bad override", "the error should pass");
	54	}
	55	});
	56
	57	test("Load fluent config", async t => {
	58	const container = new Container<Services>();
	59
	60	await container.configure("../mock/config", { contextRequire: require });
	61
	62	t.assert(container.resolve("host"), "Should resolve simple value");
	63	});

.project +11 0

@@ -14,4 +14,15
14	<natures>	14	<natures>
15	<nature>org.eclipse.buildship.core.gradleprojectnature</nature>	15	<nature>org.eclipse.buildship.core.gradleprojectnature</nature>
16	</natures>	16	</natures>
		17	<filteredResources>
		18	<filter>
		19	<id>1599549685358</id>
		20	<name></name>
		21	<type>30</type>
		22	<matcher>
		23	<id>org.eclipse.core.resources.regexFilterMatcher</id>
		24	<arguments>node_modules\|.git\|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
		25	</matcher>
		26	</filter>
		27	</filteredResources>
17	</projectDescription>	28	</projectDescription>

.settings/org.eclipse.buildship.core.prefs +11 0

@@ -1,2 +1,13
		1	arguments=
		2	auto.sync=false
		3	build.scans.enabled=false
		4	connection.gradle.distribution=GRADLE_DISTRIBUTION(WRAPPER)
1	connection.project.dir=	5	connection.project.dir=
2	eclipse.preferences.version=1	6	eclipse.preferences.version=1
		7	gradle.user.home=
		8	java.home=/usr/lib64/jvm/java
		9	jvm.arguments=
		10	offline.mode=false
		11	override.workspace.settings=true
		12	show.console.view=true
		13	show.executions.view=true

build.gradle +6 -2

             plugins {
-              id "org.implab.gradle-typescript" version "1.3.0"
+              id "org.implab.gradle-typescript" version "1.3.3"
               id "org.implab.gradle-hg"
               id "ivy-publish"
             }
                 compilerOptions {
                     types = []
                     declaration = true
+                    experimentalDecorators = true
+                    strict = true
+                    // dojo-typings are sick
+                    skipLibCheck = true
                     if(symbols != 'none') {
                         sourceMap = true
-                        sourceRoot = "_src"
+                        sourceRoot = packageName
                     }
                     if (flavour == 'node') {

docs/ru/observable.md +10 -10

             самостоятельных событий, например, связанных с действиями пользователя.
             Является реализацией классического шаблона наблюдателя с возможность сообщить
-            о коце потока событий. Данная реализация не содержит никаких дополнительных
+            о конце потока событий. Данная реализация не содержит никаких дополнительных
             функций, таких как фильтрация, канал с состоянием, преобразования сообщений и
             т.п. Это сделано специально, чтобы реализация оставалась максимально простой.
                     notify(i);
                 }
                 // по окончании последовательности информируем, что событий больше не будет
-                compelte();
+                complete();
             });
             // создаем окно с отображением хода событий
             `Observable` можно создавать из событий другого объекта, например, виджета:
             ```ts
-            // клсс
+            // класс
             class Canvas {
-                readonly mouseMove: IObservable<[number,number]>
+                mouseMove: IObservable<[number,number]>;
                 postCreate() {
                     // превращаем события виджета в Observable
             }
             ```
-            Существует также несколько варинатов получения сообщений
+            Существует также несколько вариантов получения сообщений
             ```ts
             // регистрация метода для получений событий
                     let evt = this.viewport.click.next(ct);
                     // преобразуем позицию на экране в координаты карты
-                    return this.clientToCoodinates([evt.clientx,evt.clientY]);
+                    return this.clientToCoordinates([evt.clientX,evt.clientY]);
                 }
             }
             ## Observable и последовательности
-            Можно сичтать, что `Observable` это некоторая аналогия итератора только в
+            Можно считать, что `Observable` это некоторая аналогия итератора только в
-            парадигме событийного (или реактивного) программировния. Следует также понимать,
+            парадигме событийного (или реактивного) программирования. Следует также понимать,
             что при переходе от синхронного процедурного программирования к событийному так
             же меняется и направление управления (Inverse Of Control), что означает
             следующее:
             * при работе с `Observable` клиенты вынуждены обрабатывать эти события по мере
               их поступления и не могут на это повлиять.
-            Последний пункт можно изменить применив, например, буффер или канал с
+            Последний пункт можно изменить применив, например, буфер или канал с
             состоянием, т.е. очередь, но данные механизмы выходят за рамки простого шаблона
             наблюдателя.
                 // будет вызван для всех сообщений
                 processEvent(data);
             });
-            ```
  No newline at end of file
+            ```

src/amd/js/data/StoreAdapter.js 0 -1

                             });
                             mapped.total = total;
                             var results = new QueryResults(mapped);
-                            console.log(results);
                             return results;
                         });
                     },

src/amd/ts/di/ResolverHelper.ts +1 -1

             trace.debug("globalRequire = {0}", globalRequire);
             class ModuleResolver {
-                _base: string;
+                _base: string | undefined;
                 _require: Require;
                 constructor(req: Require, base?: string) {

src/amd/ts/log/trace.ts +2 -2

                         cb = filter;
                         filter = undefined;
                     }
-                    let test: Predicate<string>;
+                    let test: Predicate<string> | undefined;
                     if (filter instanceof RegExp) {
                         test = chId => filter.test(chId);
                     } else if (filter instanceof Function) {
                     if (test) {
                         TraceSource.on(source => {
                             source.level = this.level;
-                            if (test(source.id))
+                            if (test && test(source.id))
                                 source.events.on(cb);
                         });
                     } else {

src/amd/ts/text/TemplateCompiler.ts +2 -1

             import { TraceSource, DebugLevel } from "../log/TraceSource";
             import { ITemplateParser, TokenType } from "./TemplateParser";
             import m = require("module");
+            import { isKeyof } from "../safe";
             const trace = TraceSource.get(m.id);
             // Escape a string for HTML interpolation.
             function escapeHtml(string: any) {
-                return ("" + string).replace(htmlEscaper, match => htmlEscapes[match]);
+                return ("" + string).replace(htmlEscaper, match => isKeyof(match, htmlEscapes) ? htmlEscapes[match] : "");
             }
             export class TemplateCompiler {

src/amd/ts/text/TemplateParser.ts +3 -1

                 _tokens: string[];
                 _pos = -1;
                 _type: TokenType;
-                _value: string;
+                _value: string | undefined;
                 constructor(text: string) {
                     argumentNotEmptyString(text, "text");
                 }
                 value() {
+                    if (!this._value)
+                        throw new Error("The current token doesn't have a value");
                     return this._value;
                 }

src/amd/ts/text/format.ts +13 -8

             import { format as dojoFormatDate } from "dojo/date/locale";
             import { Formatter, compile as _compile } from "./StringFormat";
-            import { isNumber, isNull } from "../safe";
+            import { isNumber, isNull, get } from "../safe";
             interface NumberFormatOptions {
                 round?: number;
                 pattern?: string;
             }
-            function convertNumber(value: any, pattern: string) {
+            function convertNumber(value: any, _pattern?: string) {
                 if (isNumber(value)) {
                     const nopt = {} as NumberFormatOptions;
-                    if (pattern.indexOf("!") === 0) {
+                    let pattern = _pattern;
+                    if (pattern && pattern.indexOf("!") === 0) {
                         nopt.round = -1;
                         pattern = pattern.substr(1);
                     }
                     nopt.pattern = pattern;
                     return dojoFormatNumber(value, nopt);
+                } else {
+                    return "";
                 }
             }
-            function convertDate(value: any, pattern: string) {
+            function convertDate(value: any, pattern?: string) {
                 if (value instanceof Date) {
-                    const m = pattern.match(/^(\w+)-(\w+)$/);
+                    const m = pattern && pattern.match(/^(\w+)-(\w+)$/);
                     if (m)
                         return dojoFormatDate(value, {
                             selector: m[2],
                             selector: "date",
                             datePattern: pattern
                         });
+                } else {
+                    return "";
                 }
             }
                 return _formatter.format(msg, ...args);
             }
-            function _convert(value: any, pattern: string) {
+            function _convert(value: any, pattern?: string) {
                 return _formatter.convert(value, pattern);
             }
                 export function compile(text: string) {
                     const template = _compile(text);
-                    return (...data) => {
+                    return (...data: any[]) => {
                         return template((name, pattern) => {
-                            const value = data[name];
+                            const value = get(name, data);
                             return !isNull(value) ? convert(value, pattern) : "";
                         });
                     };

src/amd/ts/text/template-compile.ts +1 -1

                     callback(cache[url]);
                 } else {
                     trace.debug("{0} -> {1}: load", id, url);
-                    request(url).then(compile).then((tc: TemplateFn) => {
+                    request<string>(url).then(compile).then((tc: TemplateFn) => {
                         trace.debug("{0}: compiled", url);
                         callback(cache[url] = tc);
                     }, (err: any) => {

src/cjs/ts/di/ResolverHelper.ts +2 -2

             const trace = TraceSource.get(module.id);
             const mainModule = require.main;
-            const mainRequire = (id: string) => mainModule.require(id);
+            const mainRequire = (id: string) => mainModule ? mainModule.require(id) : require;
             class ModuleResolver {
-                _base: string;
+                _base: string | undefined;
                 _require: NodeRequireFunction;
                 constructor(req: NodeRequireFunction, base?: string) {

src/main/ts/Cancellation.ts +4 -4

             export class Cancellation implements ICancellation {
                 private _reason: any;
-                private _cbs: Array<(e: any) => void>;
+                private _cbs: Array<(e: any) => void> | undefined;
                 constructor(action: (cancel: (e?: any) => void) => void) {
                     argumentNotNull(action, "action");
                     }
                 }
-                private _unregister(cb) {
+                private _unregister(cb: any) {
                     if (this._cbs) {
                         const i = this._cbs.indexOf(cb);
                         if (i >= 0)
                     }
                 }
-                private _cancel(reason) {
+                private _cancel(reason: any) {
                     if (this._reason)
                         return;
                     if (this._cbs) {
                         this._cbs.forEach(cb => cb(reason));
-                        this._cbs = null;
+                        this._cbs = undefined;
                     }
                 }

src/main/ts/Observable.ts +15 -24

             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;
+            type Initializer<T> = (notify: Handler<T>, error: (e: any) => void, complete: () => void) => void;
             const noop = () => { };
                 private _observers = new Array<IObserver<T>>();
-                private _complete: boolean;
+                private _complete = false;
                 private _error: any;
                     const me = this;
                     const observer: IObserver<T> & IDestroyable = {
-                        next,
+                        next: next.bind(null),
                         error: error ? error.bind(null) : noop,
                         complete: complete ? complete.bind(null) : noop,
                 subscribe(next: IObserver<T> | Handler<T>, error?: Handler<any>, complete?: () => void): IDestroyable {
                     if (isObserver(next)) {
-                        const me = this;
+                        this._addObserver(next);
-                        const subscription = {
+                        return {
-                            destroy() {
+                            destroy: () => this._removeObserver(next)
-                                me._removeObserver(next);
                         };
-                        this._addObserver(next);
+                    } else {
-                        return subscription;
-                    } else if (next) {
                         const observer = {
-                            next,
+                            next: next.bind(null),
-                            error,
+                            error: error ? error.bind(null) : noop,
-                            complete
+                            complete: complete ? complete.bind(null) : noop
                         };
-                        const me = this;
-                        const subscription = {
+                        this._addObserver(observer);
-                            destroy() {
+                        return {
-                                me._removeObserver(observer);
+                            destroy: () => this._removeObserver(observer)
                         };
-                        this._addObserver(observer);
-                        return subscription;
-                    } else {
-                        return destroyed;
                     }
                 }

src/main/ts/ObservableValue.ts +2 0

                 }
                 setValue(value: T) {
+                    if (this._value !== value) {
                         this._value = value;
                         this._notifyNext(value);
                     }
+                }
                 on(next: Handler<T>, error?: Handler<any>, complete?: () => void): IDestroyable {
                     argumentNotNull(next, "next");

src/main/ts/Uuid.ts +36 -20

             //     Copyright (c) 2010-2012 Robert Kieffer
             //     MIT License - http://opensource.org/licenses/mit-license.php
+            import { MapOf } from "./interfaces";
             declare const window: any;
-            declare const require;
+            declare const require: any;
-            declare const Buffer;
+            declare const Buffer: any;
             const _window: any = "undefined" !== typeof window ? window : null;
+            interface WritableArrayLike<T> {
+                length: number;
+                [n: number]: T;
+            }
             // Unique ID creation requires a high quality random # generator. We
             // feature
             // detect to determine the best RNG source, normalizing to a function
             // that
             // returns 128-bits of randomness, since that's what's usually required
-            let _rng;
+            let _rng: () => WritableArrayLike<number> = () => [];
             function setupBrowser() {
                 // Allow for MSIE11 msCrypto
                     // If all else fails, use Math.random(). It's fast, but is of
                     // unspecified
                     // quality.
-                    const _rnds = new Array(16);
+                    const _rnds = new Array<number>(16);
                     _rng = () => {
-                        for (let i = 0, r; i < 16; i++) {
+                        for (let i = 0, r = 0; i < 16; i++) {
                             if ((i & 0x03) === 0) {
                                 r = Math.random() * 0x100000000;
                             }
             const BufferClass = ("function" === typeof Buffer) ? Buffer : Array;
             // Maps for number <-> hex string conversion
-            const _byteToHex = [];
+            const _byteToHex: string[] = [];
-            const _hexToByte = {};
+            const _hexToByte: MapOf<number> = {};
             for (let i = 0; i < 256; i++) {
                 _byteToHex[i] = (i + 0x100).toString(16).substr(1);
                 _hexToByte[_byteToHex[i]] = i;
             }
             // **`parse()` - Parse a UUID into it's component bytes**
-            function _parse(s, buf?, offset?): Array<string> {
+            function _parse(s: string, buf: number[] = [], offset?: number): number[] {
                 const i = (buf && offset) || 0; let ii = 0;
-                buf = buf || [];
                 s.toLowerCase().replace(/[0-9a-f]{2}/g, oct => {
                     if (ii < 16) { // Don't overflow!
                         buf[i + ii++] = _hexToByte[oct];
                     }
+                    return "";
                 });
                 // Zero out remaining bytes if string was short
             }
             // **`unparse()` - Convert UUID byte array (ala parse()) into a string**
-            function _unparse(buf, offset?): string {
+            function _unparse(buf: ArrayLike<number>, offset?: number): string {
                 let i = offset || 0; const bth = _byteToHex;
                 return bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]] +
                     bth[buf[i++]] + "-" + bth[buf[i++]] + bth[buf[i++]] + "-" +
             // Previous uuid creation time
             let _lastMSecs = 0; let _lastNSecs = 0;
+            interface V1Options {
+                clockseq?: number;
+                msecs?: number;
+                nsecs?: number;
+                node?: number[];
+            }
             // See https://github.com/broofa/node-uuid for API details
-            function _v1(options?, buf?, offset?): string {
+            function _v1(options?: V1Options): string;
+            function _v1(options: V1Options, buf: number[], offset?: number): number[];
+            function _v1(options: V1Options = {}, buf?: number[], offset?: number): string | number[] {
                 let i = buf && offset || 0;
                 const b = buf || [];
-                options = options || {};
                 let clockseq = (options.clockseq != null) ? options.clockseq : _clockseq;
                 // UUID timestamps are 100 nano-second units since the Gregorian
                 return buf ? buf : _unparse(b);
             }
+            interface V4Opptions {
+                rng?: () => WritableArrayLike<number>;
+                random?: number[];
+            }
             // **`v4()` - Generate random UUID**
             // See https://github.com/broofa/node-uuid for API details
-            function _v4(options?, buf?, offset?): string {
+            function _v4(options?: V4Opptions): string;
+            function _v4(options: V4Opptions, buf: number[], offset?: number): number[];
+            function _v4(options: V4Opptions = {}, buf?: number[], offset?: number): string | number[] {
                 // Deprecated - 'format' argument, as supported in v1.2
                 const i = buf && offset || 0;
-                if (typeof (options) === "string") {
-                    buf = (options === "binary") ? new BufferClass(16) : null;
-                    options = null;
-                options = options || {};
                 const rnds = options.random || (options.rng || _rng)();
                 // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`

src/main/ts/components/ActivatableMixin.ts +8 -2

             export function ActivatableMixin<TBase extends Constructor<AsyncComponent>>(Base: TBase) {
                 return class extends Base implements IActivatable {
-                    _controller: IActivationController;
+                    _controller: IActivationController | undefined;
-                    _active: boolean;
+                    _active = false;
                     isActive() {
                         return this._active;
                     }
+                    hasActivationController() {
+                        return !!this._controller;
+                    }
                     getActivationController() {
+                        if (!this._controller)
+                            throw Error("Activation controller isn't set");
                         return this._controller;
                     }

src/main/ts/components/AsyncComponent.ts +4 -3

             import { IAsyncComponent, ICancellation, ICancellable, IDestroyable } from "../interfaces";
             import { destroy } from "../safe";
+            const noop = () => void (0);
             export class AsyncComponent implements IAsyncComponent, ICancellable {
-                _cancel: (e: any) => void;
+                _cancel: ((e: any) => void) = noop;
                 _completion: Promise<void> = Promise.resolve();
                             // after the operation is complete we need to cleanup the
                             // resources
                             destroy(h);
-                            this._cancel = null;
+                            this._cancel = noop;
                         }
                     };
                 }
                 cancel(reason: any) {
-                    if (this._cancel)
                     this._cancel(reason);
                 }
             }

src/main/ts/di/ActivationContext.ts +100 -62

@@ -1,7 +1,8
1	import { TraceSource } from "../log/TraceSource";	1	import { TraceSource } from "../log/TraceSource";
2	import { ~~argumentNotNull~~, argumentNotEmptyString, ~~isPrimitive~~, ~~each~~, ~~isNull~~ } from "../safe";	2	import { argumentNotEmptyString } from "../safe";
3	import { Descriptor, ServiceMap } from "./interfaces";	3	import { Descriptor, ContainerServiceMap, ContainerKeys, TypeOfService, ILifetime } from "./interfaces";
4	import { Container } from "./Container";	4	import { Container } from "./Container";
		5	import { MapOf } from "../interfaces";
5		6
6	const trace = TraceSource.get("@implab/core/di/ActivationContext");	7	const trace = TraceSource.get("@implab/core/di/ActivationContext");
7		8
@@ -10,50 +11,85 export interface ActivationContextInfo {
10		11
11	service: string;	12	service: string;
12		13
13	scope: ServiceMap;
14	}	14	}
15		15
16	export class ActivationContext {	16	let nextId = 1;
17	_cache: object;
18		17
19	_services: ServiceMap;	18	/** This class is created once per `Container.resolve` method call and used to
		19	* cache dependencies and to track created instances. The activation context
		20	* tracks services with `context` activation type.
		21	*/
		22	export class ActivationContext<S extends object> {
		23	_cache: MapOf<any>;
20		24
21	_stack: ActivationContextInfo[];	25	_services: ContainerServiceMap<S>;
22		26
23	_visited: ~~object~~;	27	_visited: MapOf<any>;
24		28
25	_name: string;	29	_name: string;
26		30
27	_localized: boolean;	31	_service: Descriptor<S, any>;
28		32
29	container: Container;	33	_container: Container<S>;
		34
		35	_parent: ActivationContext<S> \| undefined;
30		36
31	constructor(container: Container, services: ServiceMap, name?: string, cache?: object, visited?) {	37	/** Creates a new activation context with the specified parameters.
32	argumentNotNull(container, "container");	38	* @param container the container which starts the activation process
33	argumentNotNull(services, "services");	39	* @param services the initial service registrations
34		40	* @param name the name of the service being activated, this parameter is
		41	* used for the debug purpose.
		42	* @param service the service to activate, this parameter is used for the
		43	* debug purpose.
		44	*/
		45	constructor(container: Container<S>, services: ContainerServiceMap<S>, name: string, service: Descriptor<S, any>) {
35	this._name = name;	46	this._name = name;
36	this._~~visited~~ = ~~visited~~ \|\| {};	47	this._service = service;
37	this._~~stack~~ = [];	48	this._visited = {};
38	this._cache = ~~cache~~ \|\| {};	49	this._cache = {};
39	this._services = services;	50	this._services = services;
40	this.container = container;	51	this._container = container;
41	}	52	}
42		53
		54	/** the name of the current resolving dependency */
43	getName() {	55	getName() {
44	return this._name;	56	return this._name;
45	}	57	}
46		58
47	resolve(name, def?): any {	59	/** Returns the container for which 'resolve' method was called */
		60	getContainer() {
		61	return this._container;
		62	}
		63
		64	/** Resolves the specified dependency in the current context
		65	* @param name The name of the dependency being resolved
		66	*/
		67	resolve<K extends ContainerKeys<S>>(name: K): TypeOfService<S, K>;
		68	/** Resolves the specified dependency with the specified default value if
		69	* the dependency is missing.
		70	*
		71	* @param name The name of the dependency being resolved
		72	* @param def A default value to return in case of the specified dependency
		73	* is missing.
		74	*/
		75	resolve<K extends ContainerKeys<S>, T>(name: K, def: T): TypeOfService<S, K> \| T;
		76	/** Resolves the specified dependency and returns undefined in case if the
		77	* dependency is missing.
		78	*
		79	* @param name The name of the dependency being resolved
		80	*/
		81	resolve<K extends ContainerKeys<S>>(name: K, def: undefined): TypeOfService<S, K> \| undefined;
		82	resolve<K extends ContainerKeys<S>, T>(name: K, def?: T): TypeOfService<S, K> \| T \| undefined {
48	const d = this._services[name];	83	const d = this._services[name];
49		84
50	if (!d)	85	if (d !== undefined) {
		86	return this.activate(d, name.toString());
		87	} else {
51	if (arguments.length > 1)	88	if (arguments.length > 1)
52	return def;	89	return def;
53	else	90	else
54	throw new Error(`Service ${name} not found`);	91	throw new Error(`Service ${name} not found`);
55		92	}
56	return this.activate(d, name);
57	}	93	}
58		94
59	/**	95	/**
@@ -62,41 +98,36 export class ActivationContext {
62	* @name{string} the name of the service	98	* @name{string} the name of the service
63	* @service{string} the service descriptor to register	99	* @service{string} the service descriptor to register
64	*/	100	*/
65	register(name: ~~string~~, service: Descriptor) {	101	register<K extends keyof S>(name: K, service: Descriptor<S, S[K]>) {
66	argumentNotEmptyString(name, "name");	102	argumentNotEmptyString(name, "name");
67		103
68	this._services[name] = service;	104	this._services[name] = service as any;
69	}	105	}
70		106
71	clone() {	107	createLifetime(): ILifetime {
72	return new ActivationContext(	108	const id = nextId++;
73	this.container,	109	const me = this;
74	this._services,	110	return {
75	~~this~~.~~_name~~,	111	initialize() {
76	~~this~~.~~_cache~~,	112	},
77	~~this~~.~~_visited~~	113	has() {
78	);	114	return id in me._cache;
		115	},
		116	get() {
		117	return me._cache[id];
		118	},
		119	store(item: any) {
		120	me._cache[id] = item;
		121	}
		122	};
79	}	123	}
80		124
81	has(id: string) {	125	activate<T>(d: Descriptor<S, T>, name: string) {
82	return id in this._cache;
83	}
84
85	get(id: string) {
86	return this._cache[id];
87	}
88
89	store(id: string, value) {
90	return (this._cache[id] = value);
91	}
92
93	activate(d: Descriptor, name: string) {
94	if (trace.isLogEnabled())	126	if (trace.isLogEnabled())
95	trace.log(`enter ${name} ${d}`);	127	trace.log(`enter ${name} ${d}`);
96		128
97	this.enter(~~name~~, d.~~toString~~());	129	const ctx = this.enter(d, name);
98	const v = d.activate(~~this~~);	130	const v = d.activate(ctx);
99	this.leave();
100		131
101	if (trace.isLogEnabled())	132	if (trace.isLogEnabled())
102	trace.log(`leave ${name}`);	133	trace.log(`leave ${name}`);
@@ -110,23 +141,30 export class ActivationContext {
110	return count;	141	return count;
111	}	142	}
112		143
113	getStack() {	144	getStack(): ActivationContextInfo[] {
114	return this._stack.slice().reverse();	145	const stack = [{
		146	name: this._name,
		147	service: this._service.toString()
		148	}];
		149
		150	return this._parent ?
		151	stack.concat(this._parent.getStack()) :
		152	stack;
115	}	153	}
116		154
117	private enter(name: string, service: string) {	155	private enter(service: Descriptor<S, any>, name: string): this {
118	this._stack.push({	156	const clone = Object.create(this);
119	name,	157	clone._name = name;
120	service,	158	clone._services = Object.create(this._services);
121	scope: this._services	159	clone._parent = this;
122	});	160	clone._service = service;
123	this._name = name;	161	return clone;
124	this._services = Object.create(this._services);
125	}	162	}
126		163
127	private leave() {	164	/** Creates a clone for the current context, used to protect it from modifications */
128	const ctx = this._stack.pop();	165	clone(): this {
129	this._services = ctx.scope;	166	const clone = Object.create(this);
130	this._name = ctx.name;	167	clone._services = Object.create(this._services);
		168	return clone;
131	}	169	}
132	}	170	}

src/main/ts/di/ActivationError.ts +6 -3

-            import { ActivationContextInfo } from "./ActivationContext";
+            export interface ActivationItem {
+                name: string;
+                service: string;
+            }
             export class ActivationError {
-                activationStack: ActivationContextInfo[];
+                activationStack: ActivationItem[];
                 service: string;
                 message: string;
-                constructor(service: string, activationStack: ActivationContextInfo[], innerException) {
+                constructor(service: string, activationStack: ActivationItem[], innerException: any) {
                     this.message = "Failed to activate the service";
                     this.activationStack = activationStack;
                     this.service = service;

src/main/ts/di/AggregateDescriptor.ts +15 -12

-            import { Descriptor, isDescriptor } from "./interfaces";
+            import { Descriptor } from "./interfaces";
             import { ActivationContext } from "./ActivationContext";
             import { isPrimitive } from "../safe";
+            import { isDescriptor } from "./traits";
-            export class AggregateDescriptor implements Descriptor {
+            export class AggregateDescriptor<S extends object, T> implements Descriptor<S, T> {
-                _value: object;
+                _value: any;
-                constructor(value: object) {
+                constructor(value: any) {
                     this._value = value;
                 }
-                activate(context: ActivationContext) {
+                activate(context: ActivationContext<S>): T {
                     return this._parse(this._value, context, "$value");
                 }
-                // TODO: make async
+                _parse(value: any, context: ActivationContext<S>, path: string): any {
-                _parse(value, context: ActivationContext, path: string) {
                     if (isPrimitive(value))
-                        return value;
+                        return value as any;
                     if (isDescriptor(value))
                         return context.activate(value, path);
                     if (value instanceof Array)
-                        return value.map((x, i) => this._parse(x, context, `${path}[${i}]`));
+                        return value.map((x, i) => this._parse(x, context, `${path}[${i}]`)) as any;
-                    const t = {};
+                    const t: any = {};
-                    for (const p of Object.keys(value))
+                    for (const p in value)
                         t[p] = this._parse(value[p], context, `${path}.${p}`);
                     return t;
                 }
                 toString() {
                     return "@walk";
                 }
+                clone() {
+                    return this;
                 }
+            }

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

             export class ConfigError extends Error {
-                inner: any;
+                inner?: {};
-                path: string;
+                path?: string;
-                configName: string;
+                configName?: string;
-                constructor(message: string, inner?: any) {
+                constructor(message: string, inner?: {}) {
                     super(message);
                     this.inner = inner;
                 }

src/main/ts/di/Configuration.ts +183 -80

             import {
-                ServiceRegistration,
+                PartialServiceMap,
-                TypeRegistration,
-                FactoryRegistration,
-                ServiceMap,
-                isDescriptor,
-                isDependencyRegistration,
-                DependencyRegistration,
-                ValueRegistration,
                 ActivationType,
-                isValueRegistration,
+                ContainerKeys,
-                isTypeRegistration,
+                TypeOfService,
-                isFactoryRegistration
+                ILifetime
             } from "./interfaces";
-            import { argumentNotEmptyString, isPrimitive, isPromise, delegate, argumentOfType, argumentNotNull, get } from "../safe";
+            import { argumentNotEmptyString, isPrimitive, isPromise, delegate, argumentOfType, argumentNotNull, get, primitive } from "../safe";
             import { AggregateDescriptor } from "./AggregateDescriptor";
             import { ValueDescriptor } from "./ValueDescriptor";
             import { Container } from "./Container";
             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?: 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: object | any[], map?: (v, k) => 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 {
             export type ModuleResolver = (moduleName: string, ct?: ICancellation) => any;
-            type _key = string | number;
+            export class Configuration<S extends object> {
-            export class Configuration {
                 _hasInnerDescriptors = false;
-                _container: Container;
+                readonly _container: Container<S>;
-                _path: Array<_key>;
+                _path: Array<string>;
-                _configName: string;
+                _configName: string | undefined;
-                _require: ModuleResolver;
+                _require: ModuleResolver | undefined;
-                constructor(container: Container) {
+                constructor(container: Container<S>) {
                     argumentNotNull(container, "container");
                     this._container = container;
                     this._path = [];
                     this._configName = moduleName;
-                    const r = await makeResolver(null, contextRequire);
+                    const r = await makeResolver(undefined, contextRequire);
                     const config = await r(moduleName, ct);
                     );
                 }
-                async applyConfiguration(data: object, contextRequire?: any, ct = Cancellation.none) {
+                async applyConfiguration(data: RegistrationMap<S>, opts: { contextRequire?: any; baseModule?: string }, ct = Cancellation.none) {
                     argumentNotNull(data, "data");
+                    const _opts = opts || {};
-                    await this._applyConfiguration(data, await makeResolver(void (0), contextRequire), ct);
+                    await this._applyConfiguration(data, await makeResolver(_opts.baseModule, _opts.contextRequire), ct);
                 }
-                async _applyConfiguration(data: object, resolver?: ModuleResolver, ct = Cancellation.none) {
+                async _applyConfiguration(data: RegistrationMap<S>, resolver?: ModuleResolver, ct = Cancellation.none) {
                     trace.log("applyConfiguration");
                     this._configName = "$";
                     if (resolver)
                         this._require = resolver;
-                    let services: ServiceMap;
+                    let services: PartialServiceMap<S>;
                     try {
                         services = await this._visitRegistrations(data, "$");
                     this._container.register(services);
                 }
-                _makeError(inner) {
+                _makeError(inner: any) {
                     const e = new ConfigError("Failed to load configuration", inner);
-                    e.configName = this._configName;
+                    e.configName = this._configName || "<inline>";
                     e.path = this._makePath();
                     return e;
                 }
                     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, name: _key) {
+                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 o: ServiceMap = {};
-                    const keys = Object.keys(data);
                     const services = await mapAll(data, async (v, k) => {
-                        const d = await this._visit(v, k);
+                        const d = await this._visit(v, k.toString());
                         return isDescriptor(d) ? d : new AggregateDescriptor(d);
-                    }) as ServiceMap;
+                    }) as PartialServiceMap<S>;
                     this._leave();
                     return services;
                 }
-                _enter(name: _key) {
+                _enter(name: string) {
-                    this._path.push(name);
+                    this._path.push(name.toString());
                     trace.debug(">{0}", name);
                 }
                     trace.debug("<{0}", name);
                 }
-                async _visit(data, name: string) {
+                _visit(data: any, name: string): Promise<any> {
-                    if (isPrimitive(data) || isDescriptor(data))
+                    if (isPrimitive(data))
-                        return data;
+                        return Promise.resolve(new ValueDescriptor(data));
+                    if (isDescriptor(data))
+                        return Promise.resolve(data);
-                    if (isDependencyRegistration(data)) {
+                    if (isDependencyRegistration<S>(data)) {
                         return this._visitDependencyRegistration(data, name);
                     } else if (isValueRegistration(data)) {
                         return this._visitValueRegistration(data, name);
                     return this._visitObject(data, name);
                 }
-                async _visitObject(data: object, name: _key) {
+                async _visitObject(data: any, name: string) {
                     if (data.constructor &&
                         data.constructor.prototype !== Object.prototype)
                         return new ValueDescriptor(data);
                     return v;
                 }
-                async _visitArray(data: any[], name: _key) {
+                async _visitArray(data: any[], name: string) {
                     if (data.constructor &&
                         data.constructor.prototype !== Array.prototype)
                         return new ValueDescriptor(data);
                     return v;
                 }
-                _makeServiceParams(data: ServiceRegistration) {
+                _makeServiceParams(data: ServiceRegistration<any, S>) {
                     const opts: any = {
-                        owner: this._container
                     };
                     if (data.services)
                         opts.services = this._visitRegistrations(data.services, "services");
                             this._visit(data.params, "params");
                     if (data.activation) {
-                        if (typeof (data.activation) === "string") {
+                        opts.activation = this._getLifetimeManager(data.activation, data.typeId);
-                            switch (data.activation.toLowerCase()) {
-                                case "singleton":
-                                    opts.activation = ActivationType.Singleton;
-                                    break;
-                                case "container":
-                                    opts.activation = ActivationType.Container;
-                                    break;
-                                case "hierarchy":
-                                    opts.activation = ActivationType.Hierarchy;
-                                    break;
-                                case "context":
-                                    opts.activation = ActivationType.Context;
-                                    break;
-                                case "call":
-                                    opts.activation = ActivationType.Call;
-                                    break;
-                                default:
-                                    throw new Error("Unknown activation type: " +
-                                        data.activation);
-                        } else {
-                            opts.activation = Number(data.activation);
                     }
                     if (data.cleanup)
                     return opts;
                 }
-                async _visitValueRegistration(data: ValueRegistration, name: _key) {
+                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(data: DependencyRegistration, name: _key) {
+                async _visitDependencyRegistration<K extends keyof S>(data: DependencyRegistration<S, K>, name: string) {
                     argumentNotEmptyString(data && data.$dependency, "data.$dependency");
                     this._enter(name);
-                    const d = new ReferenceDescriptor({
+                    const options = {
                         name: data.$dependency,
-                        lazy: data.lazy,
                         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, name: _key) {
+                async _visitTypeRegistration(data: TypeRegistration<new () => any, S>, name: string) {
                     argumentNotNull(data.$type, "data.$type");
                     this._enter(name);
                         opts.type = data.$type;
                     } else {
                         const [moduleName, typeName] = data.$type.split(":", 2);
-                        opts.type = this._resolveType(moduleName, typeName);
+                        opts.type = this._resolveType(moduleName, typeName).then(t => {
+                            if (!(t instanceof Function))
+                                throw Error("$type (" + data.$type + ") is not a constructable");
+                            return t;
+                        });
                     }
-                    const d = new TypeServiceDescriptor(
+                    const d = new TypeServiceDescriptor<S, any, any[]>(
                         await mapAll(opts)
                     );
                     return d;
                 }
-                async _visitFactoryRegistration(data: FactoryRegistration, name: _key) {
+                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(
+                    const d = new FactoryServiceDescriptor<S, any, any[]>(
                         await mapAll(opts)
                     );
                     this._leave();
                     return d;
                 }
+                _getLifetimeManager(activation: ActivationType, typeId: string | undefined): ILifetime {
+                    switch (activation) {
+                        case "container":
+                            return LifetimeManager.containerLifetime(this._container);
+                        case "hierarchy":
+                            return LifetimeManager.hierarchyLifetime();
+                        case "context":
+                            return LifetimeManager.contextLifetime();
+                        case "singleton":
+                            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 +66 -45

             import { ActivationContext } from "./ActivationContext";
             import { ValueDescriptor } from "./ValueDescriptor";
             import { ActivationError } from "./ActivationError";
-            import { isDescriptor, ServiceMap } from "./interfaces";
+            import { ServiceMap, Descriptor, PartialServiceMap, ServiceLocator, ContainerServiceMap, ContainerKeys, TypeOfService } from "./interfaces";
             import { TraceSource } from "../log/TraceSource";
-            import { Configuration } from "./Configuration";
+            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";
+            import { FluentRegistrations } from "./fluent/interfaces";
+            import { FluentConfiguration } from "./fluent/FluentConfiguration";
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
-            export class Container {
+            export class Container<S extends object = any> implements ServiceLocator<S>, IDestroyable {
-                _services: ServiceMap;
+                readonly _services: ContainerServiceMap<S>;
-                _cache: object;
+                readonly _lifetimeManager: LifetimeManager;
+                readonly _cleanup: (() => void)[];
-                _cleanup: (() => void)[];
+                readonly _root: Container<S>;
-                _root: Container;
+                readonly _parent?: Container<S>;
-                _parent: Container;
+                _disposed: boolean;
-                constructor(parent?: Container) {
+                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);
+                    this._services.container = new ValueDescriptor(this) as any;
+                    this._disposed = false;
+                    this._lifetimeManager = new LifetimeManager();
                 }
                 getRootContainer() {
                     return this._parent;
                 }
-                resolve(name: string, def?) {
+                getLifetimeManager() {
+                    return this._lifetimeManager;
+                }
+                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 (arguments.length > 1)
+                        if (def !== undefined)
                             return def;
                         else
                             throw new Error("Service '" + name + "' isn't found");
+                    } else {
-                    const context = new ActivationContext(this, this._services);
+                        const context = new ActivationContext<S>(this, this._services, String(name), d);
                         try {
-                        return context.activate(d, name);
+                            return d.activate(context);
                         } catch (error) {
-                        throw new ActivationError(name, context.getStack(), error);
+                            throw new ActivationError(name.toString(), context.getStack(), error);
+                        }
                     }
                 }
                 /**
                  * @deprecated use resolve() method
                  */
-                getService() {
+                getService<K extends ContainerKeys<S>>(name: K, def?: TypeOfService<S, K>) {
-                    return this.resolve.apply(this, arguments);
+                    return this.resolve(name, def);
                 }
-                register(nameOrCollection, service?) {
+                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;
+                        const data = nameOrCollection as ServiceMap<S>;
-                        for (const name in data)
-                            this.register(name, data[name]);
+                        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] = service;
+                        this._services[nameOrCollection as K] = service as any;
                     }
                     return this;
                 }
-                onDispose(callback) {
+                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._cleanup) {
+                    if (this._disposed)
+                        return;
+                    this._disposed = true;
                     for (const f of this._cleanup)
                         f();
-                        this._cleanup = null;
                 }
                 /**
                  * @param{String|Object} config
-                 *  The configuration of the contaier. Can be either a string or an object,
+                 *  The configuration of the container. 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.
+                 *  services which will be registered in the container.
                  *
                  * @param{Function} opts.contextRequire
                  *  The function which will be used to load a configuration or types for services.
                  *
                  */
-                async configure(config: string | object, opts?: any, ct = Cancellation.none) {
+                async configure(config: string | RegistrationMap<S>, opts?: { contextRequire: any; baseModule?: string }, ct = Cancellation.none) {
-                    const c = new Configuration(this);
+                    const _opts = Object.create(opts || null);
                     if (typeof (config) === "string") {
-                        return c.loadConfiguration(config, opts && opts.contextRequire, ct);
+                        _opts.baseModule = config;
+                        const module = await import(config);
+                        if (module && module.default && typeof (module.default.apply) === "function")
+                            return module.default.apply(this);
+                        else
+                            return this._applyLegacyConfig(module, _opts, ct);
                     } else {
-                        return c.applyConfiguration(config, opts && opts.contextRequire, ct);
+                        return this._applyLegacyConfig(config, _opts, ct);
                     }
                 }
-                createChildContainer() {
+                async _applyLegacyConfig(config: RegistrationMap<S>, opts: { contextRequire: any; baseModule?: string }, ct = Cancellation.none) {
-                    return new Container(this);
+                    return new Configuration<S>(this).applyConfiguration(config, opts);
-                has(id) {
-                    return id in this._cache;
                 }
-                get(id) {
+                async fluent<K extends keyof S>(config: FluentRegistrations<K, S>, ct = Cancellation.none): Promise<this> {
-                    return this._cache[id];
+                    await new FluentConfiguration<S>().register(config).apply(this, ct);
+                    return this;
                 }
-                store(id, value) {
+                createChildContainer<S2 extends object = S>(): Container<S & S2> {
-                    return (this._cache[id] = value);
+                    return new Container<S & S2>(this as any);
                 }
             }

src/main/ts/di/FactoryServiceDescriptor.ts +5 -10

             import { ServiceDescriptor, ServiceDescriptorParams } from "./ServiceDescriptor";
-            import { Factory } from "../interfaces";
             import { argumentNotNull, oid } from "../safe";
-            import { ActivationType } from "./interfaces";
-            export interface FactoryServiceDescriptorParams extends ServiceDescriptorParams {
+            export interface FactoryServiceDescriptorParams<S extends object, T, P extends any[]> extends ServiceDescriptorParams<S, T, P> {
-                factory: Factory;
+                factory: (...args: P) => T;
             }
-            export class FactoryServiceDescriptor extends ServiceDescriptor {
+            export class FactoryServiceDescriptor<S extends object, T, P extends any[]> extends ServiceDescriptor<S, T, P> {
-                constructor(opts: FactoryServiceDescriptorParams) {
+                constructor(opts: FactoryServiceDescriptorParams<S, T, P>) {
                     super(opts);
                     argumentNotNull(opts && opts.factory, "opts.factory");
                     // bind to null
-                    this._factory = (...args) => opts.factory.apply(null, args);
+                    this._factory = (...args) => opts.factory.apply(null, args as any);
-                    if (opts.activation === ActivationType.Singleton) {
-                        this._cacheId = oid(opts.factory);
                 }
             }

src/main/ts/di/ReferenceDescriptor.ts +42 -54

@@ -1,83 +1,71
1	import { ~~isNull~~, argumentNotEmptyString, each } from "../safe";	1	import { argumentNotEmptyString, each } from "../safe";
2	import { ActivationContext } from "./ActivationContext";	2	import { ActivationContext } from "./ActivationContext";
3	import { ~~ServiceMap~~, ~~Descriptor~~ } from "./interfaces";	3	import { Descriptor, PartialServiceMap, TypeOfService, ContainerKeys } from "./interfaces";
4	import { ActivationError } from "./ActivationError";	4
		5	export interface ReferenceDescriptorParams<S extends object, K extends ContainerKeys<S>> {
		6	/**
		7	* The name of the descriptor
		8	*/
		9	name: K;
5		10
6	export interface ReferenceDescriptorParams {	11	/**
7	name: string;	12	* The flag that indicates that the referenced service isn't required to exist.
8	lazy?: boolean;	13	* If the reference is optional and the referenced service doesn't exist,
		14	* the undefined or a default value will be returned.
		15	*/
9	optional?: boolean;	16	optional?: boolean;
10	default?;	17
11	services?: ServiceMap;	18	/**
		19	* a default value for the reference when the referenced service doesn't exist.
		20	*/
		21	default?: TypeOfService<S, K>;
		22
		23	/**
		24	* The service overrides
		25	*/
		26	services?: PartialServiceMap<S>;
12	}	27	}
13		28
14	export class ReferenceDescriptor implements Descriptor {	29	export class ReferenceDescriptor<S extends object = any, K extends ContainerKeys<S> = ContainerKeys<S>>
15	_name: string;	30	implements Descriptor<S, TypeOfService<S, K>> {
16		31
17	_lazy = false;	32	_name: K;
18		33
19	_optional = false;	34	_optional = false;
20		35
21	_default: any;	36	_default: TypeOfService<S, K> \| undefined;
22		37
23	_services: ServiceMap;	38	_services: PartialServiceMap<S>;
24		39
25	constructor(opts: ReferenceDescriptorParams) {	40	constructor(opts: ReferenceDescriptorParams<S, K>) {
26	argumentNotEmptyString(opts && opts.name, "opts.name");	41	argumentNotEmptyString(opts && opts.name, "opts.name");
27	this._name = opts.name;	42	this._name = opts.name;
28	this._lazy = !!opts.lazy;
29	this._optional = !!opts.optional;	43	this._optional = !!opts.optional;
30	this._default = opts.default;	44	this._default = opts.default;
31	this._services = opts.services;
32	}
33		45
34	activate(context: ActivationContext, name: string) {	46	this._services = (opts.services \|\| {}) as PartialServiceMap<S>;
35	// добавляем сервисы
36	if (this._services) {
37	for (const p of Object.keys(this._services))
38	context.register(p, this._services[p]);
39	}	47	}
40		48
41	if (this._lazy) {	49	/** This method activates the referenced service if one exists
42	const saved = context.clone();	50	* @param context activation context which is used during current activation
43		51	*/
44	return (cfg: ServiceMap) => {	52	activate(context: ActivationContext<S>): any {
45	// защищаем контекст на случай исключения в процессе	53	// добавляем сервисы
46	// активации	54	if (this._services) {
47	const ct = saved.clone();	55	each(this._services, (v, k) => context.register(k, v));
48	try {
49	if (cfg) {
50	for (const k in cfg)
51	ct.register(k, cfg[k]);
52	}	56	}
53		57
54	return this._optional ? ct.resolve(this._name, this._default) : ct	58	const res = this._optional ?
55	.resolve(this._name);
56	} catch (error) {
57	throw new ActivationError(this._name, ct.getStack(), error);
58	}
59	};
60	} else {
61	// добавляем сервисы
62	if (this._services) {
63	for (const p of Object.keys(this._services))
64	context.register(p, this._services[p]);
65	}
66
67	const v = this._optional ?
68	context.resolve(this._name, this._default) :	59	context.resolve(this._name, this._default) :
69	context.resolve(this._name);	60	context.resolve(this._name);
70		61
71	return v;	62	return res;
72	}
73	}	63	}
74		64
75	toString() {	65	toString() {
76	const opts = [];	66	const opts = [];
77	if (this._optional)	67	if (this._optional)
78	opts.push("optional");	68	opts.push("optional");
79	if (this._lazy)
80	opts.push("lazy");
81		69
82	const parts = [	70	const parts = [
83	"@ref "	71	"@ref "
@@ -88,11 +76,11 export class ReferenceDescriptor impleme
88	parts.push("} ");	76	parts.push("} ");
89	}	77	}
90		78
91	parts.push(this._name);	79	parts.push(this._name.toString());
92		80
93	if (!isNull(this._default)) {	81	if (this._default !== undefined && this._default !== null) {
94	parts.push(" = ");	82	parts.push(" = ");
95	parts.push(this._default);	83	parts.push(String(this._default));
96	}	84	}
97		85
98	return parts.join("");	86	return parts.join("");

src/main/ts/di/ServiceDescriptor.ts +64 -144

@@ -1,16 +1,17
1	import { ActivationContext } from "./ActivationContext";	1	import { ActivationContext } from "./ActivationContext";
2	import { Descriptor, ~~ActivationType~~, ServiceMap, ~~isDescriptor~~ } from "./interfaces";	2	import { Descriptor, ServiceMap, PartialServiceMap, ILifetime } from "./interfaces";
3	import { Container } from "./Container";	3	import { isPrimitive, keys, isNull } from "../safe";
4	import { argumentNotNull, isPrimitive } from "../safe";
5	import { TraceSource } from "../log/TraceSource";	4	import { TraceSource } from "../log/TraceSource";
6		5	import { isDescriptor } from "./traits";
7	let cacheId = 0;	6	import { LifetimeManager } from "./LifetimeManager";
		7	import { MatchingMemberKeys } from "../interfaces";
8		8
9	const trace = TraceSource.get("@implab/core/di/ActivationContext");	9	const trace = TraceSource.get("@implab/core/di/ActivationContext");
10		10
11	function injectMethod(target, method, context, args) {	11	function injectMethod<T, M extends keyof T, S extends object, A>(target: T, method: M, context: ActivationContext<S>, args: A) {
		12
12	const m = target[method];	13	const m = target[method];
13	if (!m)	14	if (!m \|\| typeof m !== "function")
14	throw new Error("Method '" + method + "' not found");	15	throw new Error("Method '" + method + "' not found");
15		16
16	if (args instanceof Array)	17	if (args instanceof Array)
@@ -19,22 +20,22 function injectMethod(target, method, co
19	return m.call(target, _parse(args, context, "." + method));	20	return m.call(target, _parse(args, context, "." + method));
20	}	21	}
21		22
22	function makeClenupCallback(~~target~~, method: ((~~instance~~) => ~~void~~) \| ~~string~~) {	23	function makeCleanupCallback<T>(method: Cleaner<T>) {
23	if (typeof (method) === "~~string~~") {	24	if (typeof (method) === "function") {
24	return () => {	25	return (target: T) => {
25	target[~~method~~]();	26	method(target);
26	};	27	};
27	} else {	28	} else {
28	return () => {	29	return (target: T) => {
29	method(target);	30	const m = target[method] as any;
		31	m.apply(target);
30	};	32	};
31	}	33	}
32	}	34	}
33		35
34	// TODO: make async	36	function _parse(value: any, context: ActivationContext<any>, path: string): any {
35	function _parse(value, context: ActivationContext, path: string) {
36	if (isPrimitive(value))	37	if (isPrimitive(value))
37	return value;	38	return value as any;
38		39
39	trace.debug("parse {0}", path);	40	trace.debug("parse {0}", path);
40		41
@@ -42,178 +43,92 function _parse(value, context: Activati
42	return context.activate(value, path);	43	return context.activate(value, path);
43		44
44	if (value instanceof Array)	45	if (value instanceof Array)
45	return value.map((x, i) => _parse(x, context, `${path}[${i}]`));	46	return value.map((x, i) => _parse(x, context, `${path}[${i}]`)) as any;
46		47
47	const t = {};	48	const t: any = {};
48	for (const p of Object.keys(value))	49
49	t[p] = _parse(value[p], context, `${path}.${p}`);	50	keys(value).forEach(p => t[p] = _parse(value[p], context, `${path}.${p}`));
50		51
51	return t;	52	return t;
52	}	53	}
53		54
54	export interface ServiceDescriptorParams {	55	export type Cleaner<T> = ((x: T) => void) \| MatchingMemberKeys<() => void, T>;
55	activation?: ActivationType;
56		56
57	owner: Container;	57	export type InjectionSpec<T> = {
		58	[m in keyof T]?: any;
		59	};
58		60
59	params?;	61	export interface ServiceDescriptorParams<S extends object, T, P extends any[]> {
		62	lifetime?: ILifetime;
60		63
61	inject?: object[];	64	params?: P;
62		65
63	services?: ServiceMap;	66	inject?: InjectionSpec<T>[];
64		67
65	cleanup?: ((x) => void) \| string;	68	services?: PartialServiceMap<S>;
		69
		70	cleanup?: Cleaner<T>;
66	}	71	}
67		72
68	export class ServiceDescriptor implements Descriptor {	73	export class ServiceDescriptor<S extends object, T, P extends any[]> implements Descriptor<S, T> {
69	_instance;	74	_services: ServiceMap<S>;
70
71	_hasInstance = false;
72
73	_activationType = ActivationType.Call;
74		75
75	_services: ServiceMap;	76	_params: P \| undefined;
76
77	_params;
78		77
79	_inject: ~~object~~[];	78	_inject: InjectionSpec<T>[];
80		79
81	_cleanup: ((x) => void) \| ~~string~~;	80	_cleanup: ((item: T) => void) \| undefined;
82		81
83	_cacheId: any;	82	_lifetime = LifetimeManager.empty();
84		83
85	_owner: Container;	84	_objectLifetime: ILifetime \| undefined;
86		85
87	constructor(opts: ServiceDescriptorParams) {	86	constructor(opts: ServiceDescriptorParams<S, T, P>) {
88	argumentNotNull(opts, "opts");
89	argumentNotNull(opts.owner, "owner");
90		87
91	this._owner = opts.owner;	88	if (opts.lifetime)
		89	this._lifetime = opts.lifetime;
92		90
93	if ("activation" in opts)	91	if (!isNull(opts.params))
94	this._activationType = opts.activation;
95
96	if ("params" in opts)
97	this._params = opts.params;	92	this._params = opts.params;
98		93
99	if (opts.inject)	94	this._inject = opts.inject \|\| [];
100	this._inject = opts.inject;
101		95
102	if (opts.services)	96	this._services = (opts.services \|\| {}) as ServiceMap<S>;
103	this._services = opts.services;
104		97
105	if (opts.cleanup) {	98	if (opts.cleanup) {
106	if (!(typeof (opts.cleanup) === "string" \|\| opts.cleanup instanceof Function))	99	if (!(typeof (opts.cleanup) === "string" \|\| opts.cleanup instanceof Function))
107	throw new Error(	100	throw new Error(
108	"The cleanup parameter must be either a function or a function name");	101	"The cleanup parameter must be either a function or a function name");
109		102
110	this._cleanup = opts.cleanup;	103	this._cleanup = makeCleanupCallback(opts.cleanup);
111	}	104	}
112	}	105	}
113		106
114	activate(context: ActivationContext) {	107	activate(context: ActivationContext<S>) {
115	// if we have a local service records, register them first	108	const lifetime = this._lifetime;
116	let instance;
117
118	// ensure we have a cache id
119	if (!this._cacheId)
120	this._cacheId = ++cacheId;
121
122	switch (this._activationType) {
123	case ActivationType.Singleton: // SINGLETON
124	// if the value is cached return it
125	if (this._hasInstance)
126	return this._instance;
127
128	// singletons are bound to the root container
129	const container = context.container.getRootContainer();
130
131	if (container.has(this._cacheId)) {
132	instance = container.get(this._cacheId);
133	} else {
134	instance = this._create(context);
135	container.store(this._cacheId, instance);
136	if (this._cleanup)
137	container.onDispose(
138	makeClenupCallback(instance, this._cleanup));
139	}
140
141	this._hasInstance = true;
142	return (this._instance = instance);
143
144	case ActivationType.Container: // CONTAINER
145	// return a cached value
146
147	if (this._hasInstance)
148	return this._instance;
149		109
150	// create an instance	110	if (lifetime.has()) {
151	instance = this._create(context);	111	return lifetime.get();
152		112	} else {
153	// the instance is bound to the container	113	lifetime.initialize(context);
154	if (this._c~~leanup~~)	114	const instance = this._create(context);
155	this._owner.onDispose(	115	lifetime.store(instance, this._cleanup);
156	makeClenupCallback(instance, this._cleanup));	116	return instance;
157
158	// cache and return the instance
159	this._hasInstance = true;
160	return (this._instance = instance);
161	case ActivationType.Context: // CONTEXT
162	// return a cached value if one exists
163
164	if (context.has(this._cacheId))
165	return context.get(this._cacheId);
166	// context context activated instances are controlled by callers
167	return context.store(this._cacheId, this._create(context));
168	case ActivationType.Call: // CALL
169	// per-call created instances are controlled by callers
170	return this._create(context);
171	case ActivationType.Hierarchy: // HIERARCHY
172	// hierarchy activated instances are behave much like container activated
173	// except they are created and bound to the child container
174
175	// return a cached value
176	if (context.container.has(this._cacheId))
177	return context.container.get(this._cacheId);
178
179	instance = this._create(context);
180
181	if (this._cleanup)
182	context.container.onDispose(makeClenupCallback(
183	instance,
184	this._cleanup));
185
186	return context.container.store(this._cacheId, instance);
187	default:
188	throw new Error("Invalid activation type: " + this._activationType);
189	}	117	}
190	}	118	}
191		119
192	isInstanceCreated() {	120	_factory(...params: any[]): T {
193	return this._hasInstance;
194	}
195
196	getInstance() {
197	return this._instance;
198	}
199
200	_factory(...params: any[]): any {
201	throw Error("Not implemented");	121	throw Error("Not implemented");
202	}	122	}
203		123
204	_create(context: ActivationContext) {	124	_create(context: ActivationContext<S>) {
205	trace.debug(`constructing ${context._name}`);	125	trace.debug(`constructing ${context._name}`);
206		126
207	if (this._activationType !== ActivationType.Call &&
208	context.visit(this._cacheId) > 0)
209	throw new Error("Recursion detected");
210
211	if (this._services) {	127	if (this._services) {
212	for (const p in this._services)	128	keys(this._services).forEach(p => context.register(p, this._services[p]));
213	context.register(p, this._services[p]);
214	}	129	}
215		130
216	let instance;	131	let instance: T;
217		132
218	if (this._params === undefined) {	133	if (this._params === undefined) {
219	instance = this._factory();	134	instance = this._factory();
@@ -231,4 +146,9 export class ServiceDescriptor implement
231	}	146	}
232	return instance;	147	return instance;
233	}	148	}
		149
		150	clone() {
		151	return Object.create(this);
234	}	152	}
		153
		154	}

src/main/ts/di/TypeServiceDescriptor.ts +8 -8

             import { ServiceDescriptor, ServiceDescriptorParams } from "./ServiceDescriptor";
-            import { Constructor, Factory } from "../interfaces";
             import { argumentNotNull, isPrimitive } from "../safe";
-            export interface TypeServiceDescriptorParams extends ServiceDescriptorParams {
+            export interface TypeServiceDescriptorParams<S extends object, T extends object, P extends any[]> extends ServiceDescriptorParams<S, T, P> {
-                type: Constructor;
+                type: new (...args: any[]) => T;
             }
-            export class TypeServiceDescriptor extends ServiceDescriptor {
+            export class TypeServiceDescriptor<S extends object, T extends object, P extends any[]> extends ServiceDescriptor<S, T, P> {
-                _type: Constructor;
+                _type: new (...args: any[]) => T;
-                constructor(opts: TypeServiceDescriptorParams) {
+                constructor(opts: TypeServiceDescriptorParams<S, T, P>) {
                     super(opts);
                     argumentNotNull(opts && opts.type, "opts.type");
                     if (this._params) {
                         if (this._params.length) {
                             this._factory = (...args) => {
-                                const t = Object.create(ctor.prototype);
+                                /*const t = Object.create(ctor.prototype);
                                 const inst = ctor.apply(t, args);
-                                return isPrimitive(inst) ? t : inst;
+                                return isPrimitive(inst) ? t : inst;*/
+                                return new ctor(...args);
                             };
                         } else {
                             this._factory = arg => {

src/main/ts/di/ValueDescriptor.ts +3 -3

             import { Descriptor } from "./interfaces";
-            export class ValueDescriptor implements Descriptor {
+            export class ValueDescriptor<T> implements Descriptor<any, T> {
-                _value;
+                _value: T;
-                constructor(value) {
+                constructor(value: T) {
                     this._value = value;
                 }

src/main/ts/di/interfaces.ts +36 -58

@@ -1,75 +1,53
1	import { isNull, isPrimitive } from "../safe";
2	import { ActivationContext } from "./ActivationContext";	1	import { ActivationContext } from "./ActivationContext";
3	import { Constructor, Factory } from "../interfaces";
4
5	export interface Descriptor {
6	activate(context: ActivationContext, name?: string);
7	}
8
9	export function isDescriptor(x): x is Descriptor {
10	return (!isPrimitive(x)) &&
11	(x.activate instanceof Function);
12	}
13		2
14	export interface ServiceMap {	3	export interface Descriptor<S extends object = any, T = any> {
15	[s: string]: Descriptor;	4	activate(context: ActivationContext<S>): T;
16	}
17
18	export enum ActivationType {
19	Singleton = 1,
20	Container,
21	Hierarchy,
22	Context,
23	Call
24	}
25
26	export interface RegistrationWithServices {
27	services?: object;
28	}	5	}
29		6
30	export interface ServiceRegistration extends RegistrationWithServices {	7	export type ServiceMap<S extends object> = {
31		8	[k in keyof S]: Descriptor<S, S[k]>;
32	activation?: "singleton" \| "container" \| "hierarchy" \| "context" \| "call";	9	};
33		10
34	params?;	11	export type ContainerKeys<S extends object> = keyof S \| keyof ContainerProvided<S>;
35		12
36	inject?: object \| object[];	13	export type TypeOfService<S extends object, K> =
		14	K extends keyof ContainerProvided<S> ? ContainerProvided<S>[K] :
		15	K extends keyof S ? S[K] : never;
37		16
38	cleanup?: (instance) => void \| string;	17	export type ContainerServiceMap<S extends object> = {
39	}	18	[K in ContainerKeys<S>]: Descriptor<S, TypeOfService<S, K>>;
		19	};
40		20
41	export interface TypeRegistration extends ServiceRegistration {	21	export type PartialServiceMap<S extends object> = {
42	$type: string \| Constructor;	22	[k in keyof S]?: Descriptor<S, S[k]>;
43	}	23	};
44		24
45	export interface FactoryRegistration extends ServiceRegistration {	25	export interface ServiceLocator<S extends object> {
46	$factory: string \| Factory;	26	resolve<K extends ContainerKeys<S>>(name: K, def?: TypeOfService<S, K>): TypeOfService<S, K>;
47	}	27	}
48		28
49	export interface ValueRegistration {	29	export interface ContainerProvided<S extends object> {
50	$value;	30	container: ServiceLocator<S>;
51	parse?: boolean;
52	}
53
54	export interface DependencyRegistration extends RegistrationWithServices {
55	$dependency: string;
56	lazy?: boolean;
57	optional?: boolean;
58	default?;
59	}	31	}
60		32
61	export function isTypeRegistration(x): x is TypeRegistration {	33	export type ContainerRegistered<S extends object> = /*{
62	return (!isPrimitive(x)) && ("$type" in x);	34	[K in Exclude<keyof S, keyof ContainerProvided<S>>]: S[K];
63	}	35	};*/
		36	Exclude<S, ContainerProvided<S>>;
64		37
65	export function isFactoryRegistration(x): x is FactoryRegistration {	38	export type ActivationType = "singleton" \| "container" \| "hierarchy" \| "context" \| "call";
66	return (!isPrimitive(x)) && ("$factory" in x);
67	}
68		39
69	export function isValueRegistration(x): x is ValueRegistration {	40	/**
70	return (!isPrimitive(x)) && ("$value" in x);	41	* Интерфейс для управления жизнью экземпляра объекта. Каждая регистрация имеет
71	}	42	* свой собственный объект `ILifetime`, который создается при первой активации
		43	*/
		44	export interface ILifetime {
		45	/** Проверяет, что уже создан экземпляр объекта */
		46	has(): boolean;
72		47
73	export function isDependencyRegistration(x): x is DependencyRegistration {	48	get(): any;
74	return (!isPrimitive(x)) && ("$dependency" in x);	49
		50	initialize(context: ActivationContext<any>): void;
		51
		52	store(item: any, cleanup?: (item: any) => void): void;
75	}	53	}

src/main/ts/interfaces.ts +16 -1

                 prototype: T;
             }
+            export type PromiseOrValue<T> = T | PromiseLike<T>;
             export type Factory<T = {}> = (...args: any[]) => T;
             export type Predicate<T = any> = (x: T) => boolean;
+            export type MatchingMemberKeys<T, From> = { [K in keyof From]: From[K] extends T ? K : never}[keyof From];
+            export type NotMatchingMemberKeys<T, From> = { [K in keyof From]: From[K] extends T ? never : K}[keyof From];
+            export type ExtractMembers<T, From> = Pick<From, MatchingMemberKeys<T, From>>;
+            export type ExcludeMembers<T, From> = Pick<From, NotMatchingMemberKeys<T, From>>;
             export interface MapOf<T> {
                 [key: string]: T;
             }
                  * can be activated and manages the active state of the
                  * component
                  */
-                setActivationController(controller: IActivationController);
+                setActivationController(controller: IActivationController): void;
+                /** Indicates whether this component has an activation controller */
+                hasActivationController(): boolean;
                 /**
                  * Gets the current activation controller for this component
                 activate(component: IActivatable, ct?: ICancellation): Promise<void>;
+                hasActive(): boolean;
                 getActive(): IActivatable;
             }

src/main/ts/log/Registry.ts +4 -4

             import { TraceSource } from "./TraceSource";
             import { argumentNotNull } from "../safe";
-            import { IDestroyable } from "../interfaces";
+            import { IDestroyable, MapOf } from "../interfaces";
             export class Registry {
                 static readonly instance = new Registry();
-                private _registry: object = new Object();
+                private _registry: MapOf<TraceSource> = {};
-                private _listeners: object = new Object();
+                private _listeners: MapOf<(source: TraceSource) => void> = {};
                 private _nextCookie: number = 1;
-                get(id: any): TraceSource {
+                get(id: string): TraceSource {
                     argumentNotNull(id, "id");
                     if (this._registry[id])

src/main/ts/log/TraceEventData.ts +1 -1

                 source: TraceSource;
                 level: number;
                 message: any;
-                args?: any[];
+                args: any[];
                 constructor(source: TraceSource, level: number, message: any, args: any[]) {
                     this.source = source;

src/main/ts/log/TraceSource.ts +8 -8

             import { Observable } from "../Observable";
             import { Registry } from "./Registry";
             import { TraceEventData } from "./TraceEventData";
+            import { EventProvider } from "../EventProvider";
             export const DebugLevel = 400;
             export class TraceSource {
                 readonly id: any;
-                level: number;
+                level = 0;
                 readonly events: Observable<TraceEvent>;
-                _notifyNext: (arg: TraceEvent) => void;
+                private readonly _provider: EventProvider<TraceEvent>;
-                constructor(id: any) {
+                constructor(id?: any) {
                     this.id = id || new Object();
-                    this.events = new Observable(next => {
+                    this._provider = new EventProvider();
-                        this._notifyNext = next;
+                    this.events = this._provider.getObservable();
-                    });
                 }
-                protected emit(level: number, message: any, args?: any[]) {
+                protected emit(level: number, message: any, args: any[]) {
-                    this._notifyNext(new TraceEventData(this, level, message, args));
+                    this._provider.post(new TraceEventData(this, level, message, args));
                 }
                 isDebugEnabled() {

src/main/ts/log/writers/ConsoleLogger.ts +4 0

                         this._writer.setLogLevel("error");
                     }
                     this._writer.write("{0}: ", next.source.id);
+                    if (next.args)
                         this._writer.writeLine(next.message, ...next.args);
+                    else
+                    this._writer.writeLine(next.message);
                 }
                 destroy() {

src/main/ts/log/writers/ConsoleWriter.ts +1 -1

	@@ -1,1 +1,1
	1	export { ConsoleLogger as ConsoleWriter } from "./ConsoleLogger"; No newline at end of file		1	export { ConsoleLogger as ConsoleWriter } from "./ConsoleLogger";

src/main/ts/safe.ts +99 -49

-            import { ICancellable, Constructor } from "./interfaces";
+            import { ICancellable, Constructor, IDestroyable, PromiseOrValue } from "./interfaces";
             import { Cancellation } from "./Cancellation";
             let _nextOid = 0;
                 Symbol("__implab__oid__") :
                 "__implab__oid__";
-            export function oid(instance: object): string {
+            export function oid(instance: null | undefined): undefined;
+            export function oid(instance: NonNullable<any>): string;
+            export function oid(instance: any): string | undefined {
                 if (isNull(instance))
-                    return null;
+                    return undefined;
                 if (_oid in instance)
                     return instance[_oid];
                     return (instance[_oid] = "oid_" + (++_nextOid));
             }
+            export function keys<T>(arg: T): (Extract<keyof T, string>)[] {
+                return isObject(arg) && arg ? Object.keys(arg) as (Extract<keyof T, string>)[] : [];
+            }
+            export function isKeyof<T>(k: string, target: T): k is Extract<keyof T, string> {
+                return target && typeof target === "object" && k in target;
+            }
             export function argumentNotNull(arg: any, name: string) {
                 if (arg === null || arg === undefined)
                     throw new Error("The argument " + name + " can't be null or undefined");
                     throw new Error("The argument '" + name + "' type doesn't match");
             }
-            export function isNull(val: any) {
+            export function isObject(val: any): val is object {
+                return typeof val === "object";
+            }
+            export function isNull(val: any): val is null | undefined {
                 return (val === null || val === undefined);
             }
-            export function isPrimitive(val: any): val is string | number | boolean | undefined | null {
+            export type primitive = symbol | string | number | boolean | undefined | null;
+            export function isPrimitive(val: any): val is primitive {
                 return (val === null || val === undefined || typeof (val) === "string" ||
                     typeof (val) === "number" || typeof (val) === "boolean");
             }
                 return typeof (val) === "string" || val instanceof String;
             }
-            export function isPromise(val: any): val is PromiseLike<any> {
+            export function isPromise<T = any>(val: any): val is PromiseLike<T> {
                 return val && typeof val.then === "function";
             }
                 return val && typeof val.cancel === "function";
             }
-            export function isNullOrEmptyString(val: any): val is string | null | undefined {
+            export function isNullOrEmptyString(val: any): val is ("" | null | undefined) {
-                if (val === null || val === undefined ||
+                return (val === null || val === undefined ||
-                    ((typeof (val) === "string" || val instanceof String) && val.length === 0))
+                    ((typeof (val) === "string" || val instanceof String) && val.length === 0));
-                    return true;
             }
-            export function isNotEmptyArray(arg: any): arg is Array<any> {
+            export function isNotEmptyArray<T = any>(arg: any): arg is T[] {
                 return (arg instanceof Array && arg.length > 0);
             }
-            function _isStrictMode() {
+            function _isStrictMode(this: any) {
                 return !this;
             }
-            function _getNonStrictGlobal() {
+            function _getNonStrictGlobal(this: any) {
                 return this;
             }
              * @param {Function} cb функция, вызываемая для каждого элемента
              * @param {Object} thisArg значение, которое будет передано в качестве
              *                <c>this</c> в <c>cb</c>.
-             * @returns Результат вызова функции <c>cb</c>, либо <c>undefined</c>
+             * @returns {void}
-             *          если достигнут конец массива.
              */
-            export function each(obj, cb, thisArg?) {
+            export function each<T>(obj: T, cb: <X extends keyof T>(v: NonNullable<T[X]>, k: X) => void): void;
+            export function each<T>(array: T[], cb: (v: T, i: number) => void): void;
+            export function each(obj: any, cb: any, thisArg?: any): any;
+            export function each(obj: any, cb: any, thisArg?: any) {
                 argumentNotNull(cb, "cb");
                 if (obj instanceof Array) {
+                    let v: any;
                     for (let i = 0; i < obj.length; i++) {
-                        const x = cb.call(thisArg, obj[i], i);
+                        v = obj[i];
-                        if (x !== undefined)
+                        if (v !== undefined)
-                            return x;
+                            cb.call(thisArg, v, i);
                     }
                 } else {
-                    const keys = Object.keys(obj);
+                    Object.keys(obj).forEach(k => obj[k] !== undefined && cb.call(thisArg, obj[k], k));
-                    for (const k of keys) {
-                        const x = cb.call(thisArg, obj[k], k);
-                        if (x !== undefined)
-                            return x;
                 }
             }
              *  own properties of the source are entirely copied to the destination.
              *
              */
-            export function mixin<T extends object, S extends object>(dest: T, source: S, template?: string[] | object): T & S {
+            export function mixin<T extends object, S extends object>(dest: T, source: S, template?: keyof S[]): T & S;
-                argumentNotNull(dest, "to");
+            export function mixin<T extends object, S extends object, R extends object = T>(dest: T, source: S, template: { [p in keyof S]?: keyof R; }): T & R;
-                const _res = dest as T & S;
+            export function mixin<T extends object, S extends object>(dest: T, source: S, template?: any): any {
+                argumentNotNull(dest, "dest");
+                const _res: any = dest as any;
                 if (isPrimitive(source))
                     return _res;
                 if (template instanceof Array) {
-                    for (const p of template) {
+                    template.forEach(p => {
-                        if (p in source)
+                        if (isKeyof(p, source))
                             _res[p] = source[p];
+                    });
                 } else if (template) {
-                    const keys = Object.keys(source);
+                    keys(source).forEach(p => {
-                    for (const p of keys) {
+                        if (isKeyof(p, template))
-                        if (p in template)
                             _res[template[p]] = source[p];
+                    });
                 } else {
-                    const keys = Object.keys(source);
+                    keys(source).forEach(p => _res[p] = source[p]);
-                    for (const p of keys)
-                        _res[p] = source[p];
                 }
                 return _res;
              * @param{Object} thisArg [Optional] Object which will be passed as 'this' to the function.
              * @param{Function|String} fn [Required] Function wich will be wrapped.
              */
-            export function async(_fn: (...args: any[]) => any, thisArg): (...args: any[]) => PromiseLike<any> {
+            export function async<T, F extends (...args: any[]) => T | PromiseLike<T>>(
+                fn: F,
+                thisArg?: ThisParameterType<F>
+            ): (...args: Parameters<F>) => PromiseLike<T>;
+            export function async<T, M extends string, O extends { [m in M]?: (...args: any[]) => T | PromiseLike<T> }>(
+                fn: M,
+                thisArg: O
+            ): (...args: Parameters<NonNullable<O[M]>>) => PromiseLike<T>;
+            export function async(_fn: any, thisArg: any): (...args: any[]) => PromiseLike<any> {
                 let fn = _fn;
                 if (arguments.length === 2 && !(fn instanceof Function))
                 if (fn == null)
                     throw new Error("The function must be specified");
-                function wrapresult(x, e?): PromiseLike<any> {
+                function wrapresult(x: any, e?: any): PromiseLike<any> {
                     if (e) {
                         return {
                             then(cb, eb) {
                 };
             }
-            type _AnyFn = (...args) => any;
+            export function delegate<T extends object, F extends (this: T, ...args: any[]) => any>(
+                target: T,
-            export function delegate<T, K extends keyof T>(target: T, _method: (K | _AnyFn)) {
+                method: F
-                let method;
+            ): OmitThisParameter<F>;
+            export function delegate<M extends string, T extends { [m in M]?: (...args: any[]) => any; }>(
+                target: T,
+                method: M
+            ): OmitThisParameter<T[M]>;
+            export function delegate(target: any, _method: any): (...args: any[]) => any {
+                let method: any;
                 if (!(_method instanceof Function)) {
                     argumentNotNull(target, "target");
                     method = target[_method];
                 });
             }
+            /** Returns resolved promise, awaiting this method will cause the asynchronous
+             * completion of the rest of the code.
+             */
+            export function fork() {
+                return Promise.resolve();
+            }
+            /** Always throws Error, can be used as a stub for the methods which should be
+             * assigned later and are required to be not null.
+             */
+            export function notImplemented(): never {
+                throw new Error("Not implemeted");
+            }
             /**
              * Iterates over the specified array of items and calls the callback `cb`, if
              * the result of the callback is a promise the next item from the array will be
                     let i = 0;
                     const result = new Array<T2>();
-                    const next = () => {
+                    const next = (): any => {
                         while (i < items.length) {
                             const r = cb(items[i], i);
                             const ri = i;
                     let i = 0;
-                    const next = () => {
+                    const next = (): any => {
                         while (i < items.length) {
                             const r = cb(items[i], i);
                             i++;
             export function first<T>(sequence: PromiseLike<ArrayLike<T>>): PromiseLike<T>;
             export function first<T>(
                 sequence: ArrayLike<T> | PromiseLike<ArrayLike<T>>,
-                cb: (x: T) => void,
+                cb?: (x: T) => void,
                 err?: (x: Error) => void
             ): void;
             /**
                 err?: (x: Error) => void
             ) {
                 if (isPromise(sequence)) {
-                    return sequence.then(res => first(res, cb, err));
+                    return sequence.then(res => first(res, cb as any /* force to pass undefined cb */, err));
                 } else if (sequence && "length" in sequence) {
                     if (sequence.length === 0) {
                         if (err)
                 err?: (x: Error) => any
             ) {
                 if (isPromise(sequence)) {
-                    return sequence.then(res => firstWhere(res, predicate, cb, err));
+                    return sequence.then(res => firstWhere(
+                        res,
+                        predicate as any /* force to pass undefined predicate */,
+                        cb as any /* force to pass undefined cb */,
+                        err)
+                    );
                 } else if (sequence && "length" in sequence) {
                     if (sequence.length === 0) {
                         if (err)
                 }
             }
+            export function isDestroyable(d: any): d is IDestroyable {
+                if (d && "destroy" in d && typeof (destroy) === "function")
+                    return true;
+                return false;
+            }
             export function destroy(d: any) {
                 if (d && "destroy" in d)
                     d.destroy();

src/main/ts/text/Converter.ts +2 -2

             export class Converter {
                 static readonly default = new Converter();
-                convert(value: any, pattern: string) {
+                convert(value: any, pattern?: string) {
                     if (pattern && pattern.toLocaleLowerCase() === "json") {
-                        const seen = [];
+                        const seen: any[] = [];
                         return JSON.stringify(value, (k, v) => {
                             if (!isPrimitive(v)) {
                                 const id = seen.indexOf(v);

src/main/ts/text/FormatCompiler.ts +20 -12

             export class FormatCompiler {
                 _scanner: FormatScanner;
-                _cache: MapOf<CompiledPattern> = {};
+                static _cache: MapOf<CompiledPattern> = {};
-                _parts: Array<string | { name: string; format: string; }>;
+                _parts: Array<string | { name: string; format?: string; }>;
-                compile(pattern: string) {
+                constructor(scanner: FormatScanner) {
-                    let compiledPattern = this._cache && this._cache[pattern];
+                    this._scanner = scanner;
-                    if (!compiledPattern) {
-                        this._scanner = new FormatScanner(pattern);
                     this._parts = [];
+                }
+                compile() {
                     this.visitText();
                     const parts = this._parts;
-                        compiledPattern = (writer: TextWriter, args: any) => {
+                    return (writer: TextWriter, args: any) => {
                         parts.forEach(x => {
                             if (isPrimitive(x))
                                 writer.writeValue(x);
                                 writer.writeValue(get(x.name, args), x.format);
                         });
                     };
-                        if (this._cache)
+                static compile(pattern: string) {
+                    let compiledPattern = this._cache && this._cache[pattern];
+                    if (!compiledPattern) {
+                        const compiler = new this(new FormatScanner(pattern));
+                        compiledPattern = compiler.compile();
                         this._cache[pattern] = compiledPattern;
                     }
                     return compiledPattern;
                         this.dieUnexpectedToken("TEXT");
                     const fieldName = this._scanner.getTokenValue();
-                    const filedFormat = this.readColon() ? this.readFieldFormat() : null;
+                    const filedFormat = this.readColon() ? this.readFieldFormat() : undefined;
                     if (this._scanner.getTokenType() !== TokeType.CurlClose)
                         this.dieUnexpectedToken("}");
                     return true;
                 }
-                pushSubst(fieldName: string, filedFormat: string) {
+                pushSubst(fieldName: string, filedFormat?: string) {
                     // console.log("pushSubst ", fieldName, filedFormat);
                     this._parts.push({ name: fieldName, format: filedFormat });
                 }
                     this._parts.push(text);
                 }
-                dieUnexpectedToken(expected?: string) {
+                dieUnexpectedToken(expected?: string): never {
                     throw new Error(isNullOrEmptyString(expected) ?
                         `Unexpected token ${this._scanner.getTokenValue()}` :
                         `Unexpected token ${this._scanner.getTokenValue()}, expected ${expected}`
                     );
                 }
-                dieUnexpectedEnd(expected?: string) {
+                dieUnexpectedEnd(expected?: string): never {
                     throw new Error(isNullOrEmptyString(expected) ? "Unexpected end of the string" : `Unexpected end of the string, expected ${expected}`);
                 }
             }

src/main/ts/text/FormatScanner.ts +10 -2

             export class FormatScanner {
                 private _text: string;
-                private _tokenType: TokeType;
+                private _tokenType: TokeType | undefined;
-                private _tokenValue: string;
+                private _tokenValue: string | undefined;
                 private _rx = /[^{}:]+|(.)/g;
                 constructor(text: string) {
                         return false;
                     const match = this._rx.exec(this._text);
+                    if (match === null)
+                        return false;
                     this._tokenType = typeMap[match[1]] || TokeType.Text;
                     this._tokenValue = match[0];
                 }
                 getTokenValue() {
+                    if (this._tokenValue === undefined)
+                        throw new Error("The scanner is before the first element");
                     return this._tokenValue;
                 }
                 getTokenType() {
+                    if (this._tokenType === undefined)
+                        throw new Error("The scanner is before the first element");
                     return this._tokenType;
                 }
             }

src/main/ts/text/StringBuilder.ts +1 -1

             export function format(format: string, ...args: any): string;
             export function format() {
                 sb.clear();
-                sb.write.apply(sb, arguments);
+                sb.write.apply<StringBuilder, any, void>(sb, arguments);
                 return sb.toString();
             }

src/main/ts/text/StringFormat.ts +15 -14

-            import { isPrimitive, isNull, each } from "../safe";
+            import { isPrimitive, isNull, isKeyof, get } from "../safe";
             import { MapOf } from "../interfaces";
             type SubstFn = (name: string, format?: string) => string;
-            type TemplateFn = (subst: SubstFn) => string;
+            type TemplateFn = (subst: SubstFn) => string | undefined;
             type ConvertFn = (value: any, format?: string) => string;
             const map = {
             function encode(s: string) {
                 if (!s)
                     return s;
-                return s.replace(/\\{|\\}|&|\\:|\n/g, m => map[m] || m);
+                return s.replace(/\\{|\\}|&|\\:|\n/g, m => isKeyof(m, map) ? map[m] : m);
             }
             function decode(s: string) {
                 if (!s)
                     return s;
-                return s.replace(/&(\w+);/g, (m, $1) => rev[$1] || m);
+                return s.replace(/&(\w+);/g, (m, $1) => isKeyof($1, rev) ? rev[$1] : m);
             }
             function subst(s: string) {
                 const i = s.indexOf(":");
                 let name: string;
-                let pattern: string;
+                let pattern: string | undefined;
                 if (i >= 0) {
                     name = s.substr(0, i);
                     pattern = s.substr(i + 1);
                 if (pattern)
                     return [
                         espaceString(decode(name)),
-                        espaceString(decode(pattern))];
+                        espaceString(decode(pattern))
+                    ];
                 else
                     return [espaceString(decode(name))];
             }
                 return compiled;
             }
-            function defaultConverter(value: any, pattern: string) {
+            function defaultConverter(value: any, pattern?: string) {
                 if (pattern && pattern.toLocaleLowerCase() === "json") {
-                    const seen = [];
+                    const seen: any = [];
                     return JSON.stringify(value, (k, v) => {
                         if (!isPrimitive(v)) {
                             const id = seen.indexOf(v);
                                 return "@ref-" + id;
                             else {
                                 seen.push(v);
-                                return v;
+                                return v.toString() as string;
                             }
                         } else {
-                            return v;
+                            return isNull(v) ? "" : v.toString();
                         }
                     }, 2);
                 } else if (isNull(value)) {
                 } else if (value instanceof Date) {
                     return value.toISOString();
                 } else {
-                    return value.toString();
+                    return value.toString() as string;
                 }
             }
                     this._converters.push(defaultConverter);
                 }
-                convert(value: any, pattern: string) {
+                convert(value: any, pattern?: string) {
                     for (const c of this._converters) {
                         const res = c(value, pattern);
                         if (!isNull(res))
                     const template = compile(msg);
                     return template((name, pattern) => {
-                        const value = args[name];
+                        const value = get(name, args);
                         return !isNull(value) ? this.convert(value, pattern) : "";
                     });
                     const template = compile(msg);
                     return (...args: any[]) => {
                         return template((name, pattern) => {
-                            const value = args[name];
+                            const value = get(name, args);
                             return !isNull(value) ? this.convert(value, pattern) : "";
                         });
                     };

src/main/ts/text/TextWriterBase.ts +4 -6

             import { isString, argumentNotNull } from "../safe";
             import { Converter } from "./Converter";
-            const compiler = new FormatCompiler();
             export abstract class TextWriterBase implements TextWriter {
                 private _converter: Converter;
                 write(format: string, ...args: any[]): void;
                 write(format: any, ...args: any[]): void {
                     if (args.length) {
-                        const compiled = compiler.compile(format);
+                        const compiled = FormatCompiler.compile(format);
                         compiled(this, args);
                     } else {
                         this.writeValue(format);
                 writeLine(format: string, ...args: any[]): void;
                 writeLine(): void {
                     if (arguments.length)
-                        this.write.apply(this, arguments);
+                        this.write.apply<this, any, void>(this, arguments);
                     this.writeNewLine();
                 }
-                writeValue(value: any, spec?: string): void {
+                writeValue(value: any, spec?: string) {
                     this.writeText(
                         isString(value) ?
                             value :
                     );
                 }
-                abstract writeText(text: string);
+                abstract writeText(text: string): void;
             }

src/test/ts/mock/Bar.ts +35 -4

@@ -1,12 +1,43
1	import { Foo } from "./Foo";	1	import { Foo } from "./Foo";
2		2
		3	/* export const service = annotate<Bar>();
		4
		5	@service.wire({
		6	foo: dependency("foo"),
		7	nested: {
		8	lazy: dependency("foo", { lazy: true })
		9	},
		10	host: dependency("host")
		11	}, "") */
3	export class Bar {	12	export class Bar {
4	name = "bar";	13	barName = "Twister";
		14
		15	_v: Foo \| undefined;
5		16
6	foo: Foo;	17	constructor(
		18	_opts: {
		19	foo?: Foo;
		20	nested?: {
		21	lazy: () => Foo
		22	},
		23	host: string
		24	},
		25	s: string
		26	) {
7		27
8	constructor(_opts) {
9	if (_opts && _opts.foo)	28	if (_opts && _opts.foo)
10	this.~~foo~~ = _opts.foo;	29	this._v = _opts.foo;
		30	if (s)
		31	this.barName = s;
		32	}
		33
		34	setName(name: string) {
		35
		36	}
		37
		38	getFoo() {
		39	if (this._v === undefined)
		40	throw new Error("The foo isn't set");
		41	return this._v;
11	}	42	}
12	}	43	}

src/test/ts/mock/Foo.ts +1 -1

             export class Foo {
-                name = "foo";
+                fooName = "foo";
             }

src/test/ts/mock/MockActivationController.ts +7 -1

             export class MockActivationController implements IActivationController {
-                _active: IActivatable = null;
+                _active: IActivatable | null = null;
+                hasActive() {
+                    return !!this._active;
+                }
                 getActive(): IActivatable {
+                    if (!this._active)
+                        throw new Error("No active component is set");
                     return this._active;
                 }

src/test/ts/tests/ActivatableTests.ts +14 -3

                 const c = new MockActivationController();
                 t.false(a.isActive(), "the component is not active by default");
-                t.assert(c.getActive() == null, "the activation controller doesn't have an active component by default");
+                t.false(c.hasActive(), "the activation controller doesn't have an active component by default");
-                t.assert(a.getActivationController() == null, "the component doesn't have an activation controller by default");
+                try {
+                    c.getActive();
+                    t.fail("Should fail when no active component is set");
+                } catch (e) {
+                }
+                t.false(a.hasActivationController(), "the component doesn't have an activation controller by default");
+                try {
+                    a.getActivationController();
+                    t.fail("Should fail when no activation controller is set");
+                } catch (e) {
+                }
                 t.comment("Active the component through the controller");
                 await c.activate(a);
                 await c.deactivate();
                 t.false(a.isActive(), "The component should successfully deactivate");
-                t.equal(c.getActive(), null, "The controller shouldn't point to any component");
+                t.false(c.hasActive(), "The controller shouldn't point to any component");
                 t.equal(a.getActivationController(), c, "The componet should point to it's controller");
             });

src/test/ts/tests/CancellationTests.ts +2 -2

             import { Cancellation } from "../Cancellation";
-            import { delay } from "../safe";
+            import { delay, notImplemented } from "../safe";
             import { test } from "./TestTraits";
             test("standalone cancellation", async t => {
-                let doCancel: (e) => void;
+                let doCancel: (e: any) => void = notImplemented;
                 const ct = new Cancellation(cancel => {
                     doCancel = cancel;

src/test/ts/tests/ContainerTests.ts +19 -6

             import { isNull } from "../safe";
             test("Container register/resolve tests", async t => {
-                const container = new Container();
+                const container = new Container<{
+                    "bla-bla": string;
+                    "connection": string;
+                    "dbParams": {
+                        timeout: number;
+                        connection: string;
+                    }
+                }>();
                 const connection1 = "db://localhost";
                 t.throws(
-                    () => container.register("bla-bla", "bla-bla"),
+                    () => container.register("bla-bla", "bla-bla" as any),
                     "Do not allow to register anything other than descriptors"
                 );
             test("Container configure/resolve tests", async t => {
-                const container = new Container();
+                const container = new Container<{
+                    foo: Foo;
+                    box: Bar;
+                    bar: Bar;
+                    db: any;
+                }>();
                 await container.configure({
                     foo: {
                     bar: {
                         $type: Bar,
-                        params: {
+                        params: [{
                             db: {
                                 provider: {
                                     $dependency: "db"
                                 }
                             }
+                        }]
                     }
                 });
                 t.pass("should configure from js object");
                 const b1 = container.resolve("bar") as Bar;
                 t.assert(!isNull(b1), "bar should not be null");
-                t.assert(!isNull(b1.foo), "bar.foo should not be null");
+                t.assert(!isNull(b1._v), "bar.foo should not be null");
             });

src/test/ts/tests/ObservableTests.ts +11 -6

             import { TraceSource } from "../log/TraceSource";
             import { Observable } from "../Observable";
             import { IObservable } from "../interfaces";
-            import { delay } from "../safe";
+            import { delay, fork } from "../safe";
             import { test } from "./TestTraits";
             const trace = TraceSource.get("ObservableTests");
             test("events sequence example", async t => {
-                let events: IObservable<number>;
+                let events: IObservable<number> | undefined;
                 const done = new Promise<void>(resolve => {
                     events = new Observable<number>(async (notify, fail, finish) => {
                         for (let i = 0; i < 10; i++) {
-                            await delay(0);
+                            await fork();
                             notify(i);
                         }
                         finish();
                 let count = 0;
                 let complete = false;
-                events.on(x => count = count + x, null, () => complete = true);
+                if (!events)
+                    throw new Error("events === undefined");
+                events.on(x => count = count + x, undefined, () => complete = true);
                 const first = await events.next();
             });
             test("event sequence termination", async t => {
-                let events: IObservable<number>;
+                let events: IObservable<number> | undefined;
                 const done = new Promise<void>(resolve => {
                     events = new Observable<number>(async (notify, fail, complete) => {
-                        await delay(0);
+                        await fork();
                         notify(1);
                         complete();
                         notify(2);
                     });
                 });
+                if (!events)
+                    throw new Error("events === undefined");
                 let count = 0;
                 events.on(() => {}, e => count++, () => count++);

src/test/ts/tests/SafeTests.ts +6 -6

             import { Cancellation } from "../Cancellation";
-            import { first, isPromise, firstWhere, delay, nowait } from "../safe";
+            import { first, isPromise, firstWhere, delay, nowait, notImplemented } from "../safe";
             import { test } from "./TestTraits";
             test("await delay test", async t => {
                 t.pass("await delay");
                 // create cancellation token
-                let cancel: (e?: any) => void;
+                let cancel: (e?: any) => void = notImplemented;
                 const ct = new Cancellation(c => cancel = c);
                 // schedule delay
             test("sequemce test", async t => {
                 const sequence = ["a", "b", "c"];
-                const empty = [];
+                const empty: string[] = [];
                 // synchronous tests
                 t.equals(first(sequence), "a", "Should return the first element");
                 t.equals(firstWhere(sequence, x => x === "b"), "b", "Should get the second element");
-                let v: string;
+                let v: string | undefined;
-                let e: Error;
+                let e: Error | undefined;
                 first(sequence, x => v = x);
                 t.equal(v, "a", "The callback should be called for the first element");
                 firstWhere(sequence, x => x === "b", x => v = x);
                     firstWhere(sequence, x => x === "z", x => v = x);
                 }, "Should throw when the element isn't found");
-                first(empty, null, x => e = x);
+                first(empty, undefined, x => e = x);
                 t.true(e, "The errorback should be called for the empty sequence");
                 // async tests

src/test/ts/tests/TestTraits.ts +4 -1

                 private readonly _tape: tape.Test;
                 private readonly _subscriptions = new Array<IDestroyable>();
-                private _destroyed;
+                private _destroyed = false;
                 constructor(t: tape.Test) {
                     argumentNotNull(t, "tape");
                 }
                 destroy() {
+                    if (this._destroyed)
+                        return;
+                    this._destroyed = true;
                     this._subscriptions.forEach(destroy);
                 }
             }

src/test/tsconfig.json 0 -2

             {
                 "extends": "../tsconfig",
                 "compilerOptions": {
-                    "rootDir": "ts",
-                    "baseUrl": ".",
                     "rootDirs": [
                         "ts",
                         "../main/ts"

src/testAmd/js/tests/plan.js +2 -1

                 "./ObservableTests",
                 "./ContainerTests",
                 "./SafeTests",
-                "./TextTests"
+                "./TextTests",
+                "./FluentContainerTests"
             ]);

src/testCjs/ts/tests/plan.ts +1 0

             import "./ContainerTests";
             import "./SafeTests";
             import "./TextTests";
+            import "./FluentContainerTests";

src/tsconfig.json +3 0

             {
                 "compilerOptions": {
                     "moduleResolution": "node",
+                    "experimentalDecorators": true,
                     "noEmitOnError": true,
                     "listFiles": true,
+                    "strict": true,
                     "types": [],
+                    "target": "ES5",
                     "lib": ["es5", "es2015.promise", "es2015.symbol", "es2015.iterable", "dom", "scripthost"]
                 }
             }

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