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

             <?xml version="1.0" encoding="UTF-8"?>
             <projectDescription>
             	<name>core</name>
             	<comment>Project implabjs-core created by Buildship.</comment>
             	<projects>
             	</projects>
             	<buildSpec>
             		<buildCommand>
             			<name>org.eclipse.buildship.core.gradleprojectbuilder</name>
             			<arguments>
             			</arguments>
             		</buildCommand>
             	</buildSpec>
             	<natures>
             		<nature>org.eclipse.buildship.core.gradleprojectnature</nature>
             	</natures>
+            	<filteredResources>
+            		<filter>
+            			<id>1599549685358</id>
+            			<name></name>
+            			<type>30</type>
+            			<matcher>
+            				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+            				<arguments>node_modules|.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+            			</matcher>
+            		</filter>
+            	</filteredResources>
             </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"
             }
             if (!symbols in ['local', 'pack', 'none'])
                 throw new Exception("The symbols property value is invalid: $symbols");
             if (!flavour in ['browser', 'node'])
                 throw new Exception("The flavour property value is invalid: $flavour");
             ext {
                 packageName = flavour == 'browser' ? "@$npmScope/$name-amd" : "@$npmScope/$name"
                 lint = project.hasProperty('lint') ? project.lint ?: true : false
             }
             sources {
                 amd {
                     typings {
                         srcDir main.output.typingsDir
                     }
                 }
                 cjs {
                     typings {
                         srcDir main.output.typingsDir
                     }
                 }
                 testAmd {
                     typings {
                         srcDir main.output.typingsDir
                         srcDir amd.output.typingsDir
                         srcDir test.output.typingsDir
                     }
                 }
                 testCjs {
                     typings {
                         srcDir main.output.typingsDir
                         srcDir cjs.output.typingsDir
                         srcDir test.output.typingsDir
                     }
                 }
             }
             typescript {
                 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') {
                         module = "commonjs"
                         target = "es2017"
                         lib = ["es2017", "dom", "scripthost"]
                     } else if (flavour == 'browser') {
                         module = "amd"
                         target = "es5"
                         lib = ["es5", "dom", "scripthost", "es2015.promise", "es2015.symbol", "es2015.iterable" ]
                     }
                 }
                 tscCmd = "$projectDir/node_modules/.bin/tsc"
                 tsLintCmd = "$projectDir/node_modules/.bin/tslint"
             	esLintCmd = "$projectDir/node_modules/.bin/eslint"
             }
             tasks.matching{ it.name =~ /^lint/ }.configureEach {
                 onlyIf { lint }
             }
             if (symbols == 'local') {
                 tasks.matching{ it.name =~ /^configureTs/ }.configureEach {
                     compilerOptions {
                         sourceRoot = "file://" + it.rootDir
                     }
                 }
             }
             task printVersion {
                 doLast {
                     println "packageName: $packageName";
                     println "version: $version";
                     println "flavour: $flavour";
                     println "target: $typescript.compilerOptions.target";
                     println "module: $typescript.compilerOptions.module";
                     println "lint: $lint";
                     println "symbols: $symbols";
                 }
             }
             npmPackMeta {
                 meta {
                     name = packageName
                 }
             }
             configureTsCjs {
                 dependsOn sources.main.output
                 compilerOptions {
                     types += [ "node" ]
                 }
             }
             configureTsAmd {
                 dependsOn sources.main.output
                 compilerOptions {
                     types += [ "requirejs", "dojo-typings" ]
                 }
             }
             test {
                 workingDir layout.buildDirectory.dir("test");
                 commandLine "node", "tests/index.js"
             }
             assemble {
                 if (flavour == 'browser') {
                     dependsOn sources.amd.output
                     from sources.amd.output.compiledDir
                     from sources.amd.resources
                 }
                 if (flavour == 'node') {
                     dependsOn sources.cjs.output
                     from sources.cjs.output.compiledDir
                     from sources.cjs.resources
                 }
             }
             assembleTest {
                 if (flavour == 'browser') {
                     dependsOn sources.amd.output, sources.testAmd.output
                     from sources.amd.output.compiledDir
                     from sources.testAmd.output.compiledDir
                     from sources.amd.resources
                     from sources.testAmd.resources
                 }
                 if (flavour == 'node') {
                     dependsOn sources.cjs.output, sources.testCjs.output
                     from sources.cjs.output.compiledDir
                     from sources.testCjs.output.compiledDir
                     from sources.cjs.resources
                     from sources.testCjs.resources
                 }
             }
             typings {
                 if (flavour == 'browser') {
                     dependsOn sources.amd.output
                     from sources.amd.output.typingsDir
                 }
                 if (flavour == 'node') {
                     dependsOn sources.cjs.output
                     from sources.cjs.output.typingsDir
                 }
             }
             task npmPackTypings(type: Copy) {
                 npmPackContents.dependsOn it
                 dependsOn sources.main.output
                 from sources.main.output.typingsDir
                 if (flavour == 'browser') {
                     dependsOn sources.amd.output
                     from sources.amd.output.typingsDir
                 }
                 if (flavour == 'node') {
                     dependsOn sources.cjs.output
                     from sources.cjs.output.typingsDir
                 }
                 into npm.packageDir
             }
             task npmPackSources(type: Copy) {
                 from sources.main.ts
                 if (symbols == 'pack') {
                    npmPackContents.dependsOn npmPackSources
                 }
                 if (flavour == 'browser') {
                     from sources.amd.ts
                 }
                 if (flavour == 'node') {
                     from sources.cjs.ts
                 }
                 into npm.packageDir.dir("_src")
             }
             task packJsTar(type: Tar) {
                 dependsOn assemble;
                 archiveBaseName = provider { packageName }
                 destinationDirectory = buildDir
                 archiveClassifier = provider { typescript.compilerOptions.module }
                 compression = Compression.GZIP
                 from(assemble.outputs)
                 doLast {
                     println archiveName;
                 }
             }
             task packTypingsTar(type: Tar) {
             }
             publishing {
                 publications {
                     local(IvyPublication) {
                         artifact(packJsTar) {
                             type = "js"
                         }
                     }
                 }
                 repositories {
                     ivy {
                         url "ivy-repo"
                     }
                 }
             }

docs/ru/observable.md +10 -10

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

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

             define([
                 "dojo/_base/declare",
                 "../safe",
                 "dojo/when",
                 "dojo/store/util/QueryResults" ],
             function(declare, safe, when, QueryResults) {
                 "use strict";
                 /**
                  * Обертка вокруг произвольного хранилища, только для чтения. Используется
                  * для преобразования данных, например, отображения в списках элементов
                  * пространственных данных.
                  */
                 return declare(null, {
                     /**
                      * @type{String} Свойство, хранящее идентификатор
                      */
                     idProperty : null,
                     _store : null,
                     /**
                      * @param{String} opts.idProperty Имя свойства, в которое будет записан
                      *                идентификатор, если не указан, то идентификатор будет
                      *                взят из родительского хранилища или использоваться
                      *                строка <code>id</code>
                      * @param{dojo.store} opts.store Родительское хранилище
                      */
                     constructor : function(opts) {
                         safe.argumentNotNull(opts, "opts");
                         safe.argumentNotNull(opts.store, "opts.store");
                         this._store = opts.store;
                         delete opts.store;
                         declare.safeMixin(this, opts);
                         this.idProperty = opts.idProperty || this._store.idProperty || "id";
                     },
                     getParentStore : function() {
                         return this._store;
                     },
                     get : function(id) {
                         var me = this;
                         return when(me._store.get(id), function(x) {
                             var m = me.mapItem(x);
                             if (!(me.idProperty in m))
                                 m[me.idProperty] = id;
                             return m;
                         });
                     },
                     /**
                      * Выполняет запрос в родительском хранилище, для этого используется
                      * <code>translateQuery</code> для подготовки запроса, затем,
                      * <code>mapItem</code> для преобразования результатов.
                      */
                     query : function(q, options) {
                         var me = this, store = this._store;
                         return when(store.query(me.translateQuery(q), me
                             .translateOptions(options)), function(res) {
                             var total = res.total;
                             var mapped = res.map(function(x) {
                                 var m = me.mapItem(x);
                                 if (!(me.idProperty in m))
                                     m[me.idProperty] = store.getIdentity &&
                                         store.getIdentity(x);
                                 return m;
                             });
                             mapped.total = total;
                             var results = new QueryResults(mapped);
-                            console.log(results);
                             return results;
                         });
                     },
                     getIdentity : function(obj) {
                         return obj && obj[this.idProperty];
                     },
                     /**
                      * Преобразование запроса в формат родительского хранилища.
                      *
                      * @param{Object} q Запрос в формате текущего хранилища
                      * @returns{Object} Запрос в формате родительского хранилища
                      */
                     translateQuery : function(q) {
                         return q;
                     },
                     translateOptions : function(options) {
                         return options;
                     },
                     /**
                      * Преобразование объекта из родительского хранилища. При преобразовании
                      * в объекте можно задать идентификатор, иначе идентификатор будет
                      * автоматически получен и присвоен из родительского хранилища
                      *
                      * @param{Object} item Объект из родительского хранилища
                      * @returns{Object} результат преобразования
                      */
                     mapItem : function(item) {
                         return item;
                     }
                 });
             });

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

             import { Uuid } from "../Uuid";
             import { argumentNotEmptyString, getGlobal } from "../safe";
             import { TraceSource } from "../log/TraceSource";
             import m = require("module");
             const sandboxId = Uuid();
             define(sandboxId, ["require"], (r: any) => r);
             const globalRequire = getGlobal().require as Require || requirejs;
             const trace = TraceSource.get(m.id);
             trace.debug("globalRequire = {0}", globalRequire);
             class ModuleResolver {
-                _base: string;
+                _base: string | undefined;
                 _require: Require;
                 constructor(req: Require, base?: string) {
                     this._base = base;
                     this._require = req;
                 }
                 resolve(moduleName: string) {
                     argumentNotEmptyString(moduleName, "moduleName");
                     const resolvedName = moduleName[0] === "." && this._base ? [this._base, moduleName].join("/") : moduleName;
                     trace.debug(`${moduleName} -> ${resolvedName}`);
                     const req = this._require;
                     return new Promise<any>((cb, eb) => {
                         req([resolvedName], cb, eb);
                     });
                 }
             }
             export function makeResolver(moduleName: string, contextRequire: Require) {
                 const base = moduleName && moduleName.split("/").slice(0, -1).join("/");
                 const req = contextRequire || globalRequire;
                 if (!req)
                     throw new Error("A global require isn't defined, the contextRequire parameter is mandatory");
                 const resolver = new ModuleResolver(req, base);
                 return (id: string) => resolver.resolve(id);
             }

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

             import { TraceSource } from "./TraceSource";
             import { Predicate } from "../interfaces";
             export = {
                 level: 0,
                 on(filter: any, cb: any) {
                     if (arguments.length === 1) {
                         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) {
                         test = filter;
                     } else if (filter) {
                         test = chId => chId === filter;
                     }
                     if (test) {
                         TraceSource.on(source => {
                             source.level = this.level;
-                            if (test(source.id))
+                            if (test && test(source.id))
                                 source.events.on(cb);
                         });
                     } else {
                         TraceSource.on(source => {
                             source.level = this.level;
                             source.events.on(cb);
                         });
                     }
                 },
                 load(id: string, require: any, cb: (trace: TraceSource) => void) {
                     if (id) {
                         cb(TraceSource.get(id));
                     } else if (require.module && require.module.mid) {
                         cb(TraceSource.get(require.module.mid));
                     } else {
                         require(["module"], (module: { id: any; }) => {
                             cb(TraceSource.get(module && module.id));
                         });
                     }
                 },
                 dynamic: true
             };

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

             import * as format from "./format";
             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);
             type TemplateFn = (obj: object) => string;
             const htmlEscapes = {
                 "&": "&amp;",
                 "<": "&lt;",
                 ">": "&gt;",
                 '"': "&quot;",
                 "'": "&#x27;",
                 "/": "&#x2F;"
             };
             // Regex containing the keys listed immediately above.
             const htmlEscaper = /[&<>"'\/]/g;
             // 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 {
                 _data: string[];
                 _code: string[];
                 _wrapWith = true;
                 constructor() {
                     this._code = [];
                     this._data = [];
                 }
                 compile(parser: ITemplateParser): TemplateFn {
                     this.preamble();
                     this.visitTemplate(parser);
                     this.postamble();
                     const text = this._code.join("\n");
                     try {
                         // tslint:disable-next-line:function-constructor
                         const compiled = new Function("obj, format, $data, escapeHtml", text);
                         /**
                          * Функция форматирования по шаблону
                          *
                          * @type{Function}
                          * @param{Object} obj объект с параметрами для подстановки
                          */
                         return (obj: object) => compiled(obj || {}, format, this._data, escapeHtml);
                     } catch (e) {
                         trace.traceEvent(DebugLevel, [e, text, this._data]);
                         throw e;
                     }
                 }
                 preamble() {
                     this._code.push(
                         "var $p = [];",
                         "var print = function(){",
                         "   $p.push(format.apply(null,arguments));",
                         "};"
                     );
                     if (this._wrapWith)
                         this._code.push("with(obj){");
                 }
                 postamble() {
                     if (this._wrapWith)
                         this._code.push("}");
                     this._code.push("return $p.join('');");
                 }
                 visitTemplate(parser: ITemplateParser) {
                     while (parser.next()) {
                         switch (parser.token()) {
                             case TokenType.OpenBlock:
                                 this.visitCode(parser);
                                 break;
                             case TokenType.OpenInlineBlock:
                                 this.visitInline(parser);
                                 break;
                             case TokenType.OpenFilterBlock:
                                 this.visitFilter(parser);
                                 break;
                             default:
                                 this.visitTextFragment(parser);
                                 break;
                         }
                     }
                 }
                 visitInline(parser: ITemplateParser) {
                     const code = ["$p.push("];
                     while (parser.next()) {
                         if (parser.token() === TokenType.CloseBlock)
                             break;
                         code.push(parser.value());
                     }
                     code.push(");");
                     this._code.push(code.join(""));
                 }
                 visitFilter(parser: ITemplateParser) {
                     const code = ["$p.push(escapeHtml("];
                     while (parser.next()) {
                         if (parser.token() === TokenType.CloseBlock)
                             break;
                         code.push(parser.value());
                     }
                     code.push("));");
                     this._code.push(code.join(""));
                 }
                 visitCode(parser: ITemplateParser) {
                     const code = [];
                     while (parser.next()) {
                         if (parser.token() === TokenType.CloseBlock)
                             break;
                         code.push(parser.value());
                     }
                     this._code.push(code.join(""));
                 }
                 visitTextFragment(parser: ITemplateParser) {
                     const i = this._data.push(parser.value()) - 1;
                     this._code.push("$p.push($data[" + i + "]);");
                 }
             }

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

             import { argumentNotEmptyString } from "../safe";
             import { MapOf } from "../interfaces";
             import { TraceSource, DebugLevel } from "../log/TraceSource";
             import m = require("module");
             const trace = TraceSource.get(m.id);
             const splitRx = /(<%=|<%~|\[%~|\[%=|<%|\[%|%\]|%>)/;
             export enum TokenType {
                 None,
                 Text,
                 OpenInlineBlock,
                 OpenFilterBlock,
                 OpenBlock,
                 CloseBlock
             }
             const tokenMap: MapOf<TokenType> = {
                 "<%": TokenType.OpenBlock,
                 "[%": TokenType.OpenBlock,
                 "<%=": TokenType.OpenInlineBlock,
                 "[%=": TokenType.OpenInlineBlock,
                 "<%~": TokenType.OpenFilterBlock,
                 "[%~": TokenType.OpenFilterBlock,
                 "%>": TokenType.CloseBlock,
                 "%]": TokenType.CloseBlock
             };
             export interface ITemplateParser {
                 next(): boolean;
                 token(): TokenType;
                 value(): string;
             }
             export class TemplateParser implements ITemplateParser {
                 _tokens: string[];
                 _pos = -1;
                 _type: TokenType;
-                _value: string;
+                _value: string | undefined;
                 constructor(text: string) {
                     argumentNotEmptyString(text, "text");
                     this._tokens = text.split(splitRx);
                     this._type = TokenType.None;
                 }
                 next() {
                     this._pos++;
                     if (this._pos < this._tokens.length) {
                         this._value = this._tokens[this._pos];
                         this._type = tokenMap[this._value] || TokenType.Text;
                         return true;
                     } else {
                         this._type = TokenType.None;
                         this._value = undefined;
                         return false;
                     }
                 }
                 token() {
                     return this._type;
                 }
                 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 dojoFormatNumber } from "dojo/number";
             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],
                             formatLength: m[1]
                         });
                     else if (pattern === "iso")
                         return value.toISOString();
                     else
                         return dojoFormatDate(value, {
                             selector: "date",
                             datePattern: pattern
                         });
+                } else {
+                    return "";
                 }
             }
             const _formatter = new Formatter([convertNumber, convertDate]);
             function format(msg: string, ...args: any[]) {
                 return _formatter.format(msg, ...args);
             }
-            function _convert(value: any, pattern: string) {
+            function _convert(value: any, pattern?: string) {
                 return _formatter.convert(value, pattern);
             }
             namespace format {
                 export const convert = _convert;
                 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) : "";
                         });
                     };
                 }
             }
             export = format;

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

             import request = require("dojo/request");
             import m = require("module");
             import { TraceSource } from "../log/TraceSource";
             import { TemplateCompiler } from "./TemplateCompiler";
             import { TemplateParser } from "./TemplateParser";
             import { isNullOrEmptyString } from "../safe";
             import { MapOf } from "../interfaces";
             type TemplateFn = (obj: object) => string;
             const trace = TraceSource.get(m.id);
             function compile(str: string) {
                 if (isNullOrEmptyString(str))
                     return () => "";
                 const parser = new TemplateParser(str);
                 const compiler = new TemplateCompiler();
                 return compiler.compile(parser);
             }
             const cache: MapOf<TemplateFn> = {};
             interface OnLoadFn<T> {
                 (res: T): void;
                 error(e: any): void;
             }
             compile.load = (id: string, require: Require, callback: OnLoadFn<TemplateFn>) => {
                 const url = require.toUrl(id);
                 if (url in cache) {
                     trace.debug("{0} -> {1}: cached", id, url);
                     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) => {
                         callback.error({
                             inner: err,
                             src: "@implab/core/text/template-compile"
                         });
                     });
                 }
             };
             export = compile;

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

             import { argumentNotEmptyString } from "../safe";
             import { TraceSource } from "../log/TraceSource";
             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) {
                     this._base = base;
                     this._require = (req || mainRequire).bind(null);
                 }
                 resolve(moduleName: string) {
                     argumentNotEmptyString(moduleName, "moduleName");
                     const resolvedName = moduleName[0] === "." && this._base ? [this._base, moduleName].join("/") : moduleName;
                     trace.debug(`${moduleName} -> ${resolvedName}`);
                     return this._require(resolvedName);
                 }
             }
             export function makeResolver(moduleName: string, contextRequire: NodeRequireFunction) {
                 const base = moduleName && moduleName.split("/").slice(0, -1).join("/");
                 const resolver = new ModuleResolver(contextRequire, base);
                 return (id: string) => resolver.resolve(id);
             }

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

             import { ICancellation, IDestroyable } from "./interfaces";
             import { argumentNotNull, destroyed } from "./safe";
             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");
                     action(this._cancel.bind(this));
                 }
                 isSupported(): boolean {
                     return true;
                 }
                 throwIfRequested(): void {
                     if (this._reason)
                         throw this._reason;
                 }
                 isRequested(): boolean {
                     return !!this._reason;
                 }
                 register(cb: (e: any) => void): IDestroyable {
                     argumentNotNull(cb, "cb");
                     if (this._reason) {
                         cb(this._reason);
                         return destroyed;
                     } else {
                         if (!this._cbs)
                             this._cbs = [cb];
                         else
                             this._cbs.push(cb);
                         const me = this;
                         return {
                             destroy() {
                                 me._unregister(cb);
                             }
                         };
                     }
                 }
-                private _unregister(cb) {
+                private _unregister(cb: any) {
                     if (this._cbs) {
                         const i = this._cbs.indexOf(cb);
                         if (i >= 0)
                             this._cbs.splice(i, 1);
                     }
                 }
-                private _cancel(reason) {
+                private _cancel(reason: any) {
                     if (this._reason)
                         return;
                     this._reason = (reason = reason || new Error("Operation cancelled"));
                     if (this._cbs) {
                         this._cbs.forEach(cb => cb(reason));
-                        this._cbs = null;
+                        this._cbs = undefined;
                     }
                 }
                 static readonly none: ICancellation = {
                     isSupported(): boolean {
                         return false;
                     },
                     throwIfRequested(): void {
                     },
                     isRequested(): boolean {
                         return false;
                     },
                     register(_cb: (e: any) => void): IDestroyable {
                         return destroyed;
                     }
                 };
             }

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

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

             import { Observable } from "./Observable";
             import { IDestroyable } from "./interfaces";
             import { argumentNotNull } from "./safe";
             type Handler<T> = (x: T) => void;
             export class ObservableValue<T> extends Observable<T> {
                 private _value: T;
                 constructor(initial: T) {
                     super();
                     this._value = initial;
                 }
                 getValue() {
                     return this._value;
                 }
                 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");
                     try {
                         next(this._value);
                     } catch {
                         // suppress error
                     }
                     return super.on(next, error, complete);
                 }
             }

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

             // Typescript port of the uuid.js
             //  Copyright (c) 2018 Sergey Smirnov
             //  BSD-2-Clause License https://opensource.org/licenses/BSD-2-Clause
             //
             // uuid.js
             //     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
                 const _crypto = _window.crypto || _window.msCrypto;
                 if (!_rng && _crypto && _crypto.getRandomValues) {
                     // WHATWG crypto-based RNG - http://wiki.whatwg.org/wiki/Crypto
                     //
                     // Moderately fast, high quality
                     try {
                         const _rnds8 = new Uint8Array(16);
                         _rng = function whatwgRNG() {
                             _crypto.getRandomValues(_rnds8);
                             return _rnds8;
                         };
                         _rng();
                     } catch (e) { /**/ }
                 }
                 if (!_rng) {
                     // Math.random()-based (RNG)
                     //
                     // 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;
                             }
                             _rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;
                         }
                         return _rnds;
                     };
                     // if ("undefined" !== typeof console && console.warn) {
                     //    console.warn("[SECURITY] node-uuid: crypto not usable, falling back to insecure Math.random()");
                     // }
                 }
             }
             function setupNode() {
                 // Node.js crypto-based RNG -
                 // http://nodejs.org/docs/v0.6.2/api/crypto.html
                 //
                 // Moderately fast, high quality
                 if ("function" === typeof require) {
                     try {
                         const _rb = require("crypto").randomBytes;
                         _rng = _rb && (() => _rb(16));
                         _rng();
                     } catch (e) { /**/ }
                 }
             }
             if (_window) {
                 setupBrowser();
             } else {
                 setupNode();
             }
             // Buffer class to use
             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
                 while (ii < 16) {
                     buf[i + ii++] = 0;
                 }
                 return buf;
             }
             // **`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++]] + "-" +
                     bth[buf[i++]] + bth[buf[i++]] + "-" + bth[buf[i++]] +
                     bth[buf[i++]] + "-" + bth[buf[i++]] + bth[buf[i++]] +
                     bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]];
             }
             // **`v1()` - Generate time-based UUID**
             //
             // Inspired by https://github.com/LiosK/UUID.js
             // and http://docs.python.org/library/uuid.html
             // random #'s we need to init node and clockseq
             const _seedBytes = _rng();
             // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit =
             // 1)
             const _nodeId = [
                 _seedBytes[0] | 0x01,
                 _seedBytes[1],
                 _seedBytes[2],
                 _seedBytes[3],
                 _seedBytes[4],
                 _seedBytes[5]
             ];
             // Per 4.2.2, randomize (14 bit) clockseq
             let _clockseq = (_seedBytes[6] << 8 | _seedBytes[7]) & 0x3fff;
             // 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
                 // epoch,
                 // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so
                 // time is handled internally as 'msecs' (integer milliseconds) and
                 // 'nsecs'
                 // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01
                 // 00:00.
                 let msecs = (options.msecs != null) ? options.msecs : new Date()
                     .getTime();
                 // Per 4.2.1.2, use count of uuid's generated during the current
                 // clock
                 // cycle to simulate higher resolution clock
                 let nsecs = (options.nsecs != null) ? options.nsecs : _lastNSecs + 1;
                 // Time since last uuid creation (in msecs)
                 const dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs) / 10000;
                 // Per 4.2.1.2, Bump clockseq on clock regression
                 if (dt < 0 && options.clockseq == null) {
                     clockseq = clockseq + 1 & 0x3fff;
                 }
                 // Reset nsecs if clock regresses (new clockseq) or we've moved onto
                 // a new
                 // time interval
                 if ((dt < 0 || msecs > _lastMSecs) && options.nsecs == null) {
                     nsecs = 0;
                 }
                 // Per 4.2.1.2 Throw error if too many uuids are requested
                 if (nsecs >= 10000) {
                     throw new Error(
                         "uuid.v1(): Can't create more than 10M uuids/sec");
                 }
                 _lastMSecs = msecs;
                 _lastNSecs = nsecs;
                 _clockseq = clockseq;
                 // Per 4.1.4 - Convert from unix epoch to Gregorian epoch
                 msecs += 12219292800000;
                 // `time_low`
                 const tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
                 b[i++] = tl >>> 24 & 0xff;
                 b[i++] = tl >>> 16 & 0xff;
                 b[i++] = tl >>> 8 & 0xff;
                 b[i++] = tl & 0xff;
                 // `time_mid`
                 const tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;
                 b[i++] = tmh >>> 8 & 0xff;
                 b[i++] = tmh & 0xff;
                 // `time_high_and_version`
                 b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
                 b[i++] = tmh >>> 16 & 0xff;
                 // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
                 b[i++] = clockseq >>> 8 | 0x80;
                 // `clock_seq_low`
                 b[i++] = clockseq & 0xff;
                 // `node`
                 const node = options.node || _nodeId;
                 for (let n = 0; n < 6; n++) {
                     b[i + n] = node[n];
                 }
                 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`
                 rnds[6] = (rnds[6] & 0x0f) | 0x40;
                 rnds[8] = (rnds[8] & 0x3f) | 0x80;
                 // Copy bytes to buffer, if provided
                 if (buf) {
                     for (let ii = 0; ii < 16; ii++) {
                         buf[i + ii] = rnds[ii];
                     }
                 }
                 return buf || _unparse(rnds);
             }
             function _Uuid() {
                 return _v4();
             }
             namespace _Uuid {
                 export const v4 = _v4;
                 export const v1 = _v1;
                 export const empty = "00000000-0000-0000-0000-000000000000";
                 export const parse = _parse;
                 export const Uuid = _v4;
             }
             export = _Uuid;

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

             import { IActivationController, IActivatable, ICancellation } from "../interfaces";
             import { AsyncComponent } from "./AsyncComponent";
             import { Cancellation } from "../Cancellation";
             import { TraceSource } from "../log/TraceSource";
             type Constructor<T = {}> = new (...args: any[]) => T;
             const log = TraceSource.get("@implab/core/components/ActivatableMixin");
             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;
                     }
                     setActivationController(controller: IActivationController) {
                         this._controller = controller;
                     }
                     async onActivating(ct: ICancellation) {
                         if (this._controller)
                             await this._controller.activating(this, ct);
                     }
                     async onActivated(ct: ICancellation) {
                         if (this._controller)
                             await this._controller.activated(this, ct);
                     }
                     activate(ct: ICancellation = Cancellation.none) {
                         return this.runOperation(this._activateAsync.bind(this), ct);
                     }
                     async _activateAsync(ct: ICancellation) {
                         if (this.isActive())
                             return;
                         await this.onActivating(ct);
                         this._active = true;
                         try {
                             await this.onActivated(ct);
                         } catch (e) {
                             log.error("Suppressed onActivated error: {0}", e);
                         }
                     }
                     async onDeactivating(ct: ICancellation) {
                         if (this._controller)
                             await this._controller.deactivating(this, ct);
                     }
                     async onDeactivated(ct: ICancellation) {
                         if (this._controller)
                             await this._controller.deactivated(this, ct);
                     }
                     deactivate(ct: ICancellation = Cancellation.none) {
                         return this.runOperation(this._deactivateAsync.bind(this), ct);
                     }
                     async _deactivateAsync(ct: ICancellation) {
                         if (!this.isActive())
                             return;
                         await this.onDeactivating(ct);
                         this._active = false;
                         try {
                             await this.onDeactivated(ct);
                         } catch (e) {
                             log.error("Suppressed onDeactivated error: {0}", e);
                         }
                     }
                 };
             }
             export const traceSource = log;

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

             import { Cancellation } from "../Cancellation";
             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();
                 getCompletion() { return this._completion; }
                 runOperation(op: (ct: ICancellation) => any, ct: ICancellation = Cancellation.none) {
                     // create inner cancellation bound to the passed cancellation token
                     let h: IDestroyable;
                     const inner = new Cancellation(cancel => {
                         this._cancel = cancel;
                         h = ct.register(cancel);
                     });
                     // TODO create cancellation source here
                     const guard = async () => {
                         try {
                             await op(inner);
                         } finally {
                             // after the operation is complete we need to cleanup the
                             // resources
                             destroy(h);
-                            this._cancel = null;
+                            this._cancel = noop;
                         }
                     };
                     return this._completion = guard();
                 }
                 cancel(reason: any) {
-                    if (this._cancel)
                     this._cancel(reason);
                 }
             }

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

@@ -1,132 +1,170
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
8	export interface ActivationContextInfo {	9	export interface ActivationContextInfo {
9	name: string;	10	name: string;
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	/**
60	* registers services local to the the activation context	96	* registers services local to the the activation context
61	*	97	*
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}`);
103		134
104	return v;	135	return v;
105	}	136	}
106		137
107	visit(id: string) {	138	visit(id: string) {
108	const count = this._visited[id] \|\| 0;	139	const count = this._visited[id] \|\| 0;
109	this._visited[id] = count + 1;	140	this._visited[id] = count + 1;
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;
                 innerException: any;
                 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;
                     this.innerException = innerException;
                 }
                 toString() {
                     const parts = [this.message];
                     if (this.service)
                         parts.push("when activating: " + this.service.toString());
                     if (this.innerException)
                         parts.push("caused by: " + this.innerException.toString());
                     if (this.activationStack) {
                         parts.push("at");
                         this.activationStack
                             .forEach(x => parts.push(`    ${x.name} ${x.service}`));
                     }
                     return parts.join("\n");
                 }
             }

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 { ReferenceDescriptor } from "./ReferenceDescriptor";
             import { TypeServiceDescriptor } from "./TypeServiceDescriptor";
             import { FactoryServiceDescriptor } from "./FactoryServiceDescriptor";
             import { TraceSource } from "../log/TraceSource";
             import { ConfigError } from "./ConfigError";
             import { Cancellation } from "../Cancellation";
             import { makeResolver } from "./ResolverHelper";
             import { ICancellation } from "../interfaces";
+            import { isDescriptor } from "./traits";
+            import { LazyReferenceDescriptor } from "./LazyReferenceDescriptor";
+            import { LifetimeManager } from "./LifetimeManager";
+            export interface RegistrationScope<S extends object> {
+                /** сервисы, которые регистрируются в контексте активации и таким образом
+                 * могут переопределять ранее зарегистрированные сервисы. за это свойство
+                 * нужно платить, кроме того порядок активации будет влиять на результат
+                 * разрешения зависимостей.
+                 */
+                services?: RegistrationMap<S>;
+            }
+            /**
+             * Базовый интерфейс конфигурации сервисов
+             */
+            export interface ServiceRegistration<T, S extends object> extends RegistrationScope<S> {
+                activation?: ActivationType;
+                params?: any;
+                /** Специальный идентификатор используется при активации singleton, если
+                 * не указан для TypeRegistration вычисляется как oid($type)
+                 */
+                typeId?: string;
+                inject?: object | object[];
+                cleanup?: ((instance: T) => void) | string;
+            }
+            export interface TypeRegistration<C extends new (...args: any[]) => any, S extends object> extends ServiceRegistration<InstanceType<C>, S> {
+                $type: string | C;
+                params?: Registration<ConstructorParameters<C>, S>;
+            }
+            export interface StrictTypeRegistration<C extends new (...args: any[]) => any, S extends object> extends ServiceRegistration<InstanceType<C>, S> {
+                $type: C;
+                params?: Registration<ConstructorParameters<C>, S>;
+            }
+            export interface FactoryRegistration<F extends (...args: any[]) => any, S extends object> extends ServiceRegistration<ReturnType<F>, S> {
+                $factory: string | F;
+            }
+            export interface ValueRegistration<T> {
+                $value: T;
+                parse?: boolean;
+            }
+            export interface DependencyRegistration<S extends object, K extends ContainerKeys<S> = ContainerKeys<S>> extends RegistrationScope<S> {
+                $dependency: K;
+                lazy?: boolean;
+                optional?: boolean;
+                default?: 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 {
                     const keys = Object.keys(data);
                     const o: any = {};
                     await Promise.all(keys.map(async k => {
                         const v = map ? map(data[k], k) : data[k];
                         o[k] = isPromise(v) ? await v : v;
                     }));
                     return o;
                 }
             }
             export type ModuleResolver = (moduleName: string, ct?: ICancellation) => any;
-            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 = [];
                 }
                 async loadConfiguration(moduleName: string, contextRequire?: any, ct = Cancellation.none) {
                     argumentNotEmptyString(moduleName, "moduleName");
                     trace.log(
                         "loadConfiguration moduleName={0}, contextRequire={1}",
                         moduleName,
                         contextRequire ? typeof (contextRequire) : "<nil>"
                     );
                     this._configName = moduleName;
-                    const r = await makeResolver(null, contextRequire);
+                    const r = await makeResolver(undefined, contextRequire);
                     const config = await r(moduleName, ct);
                     await this._applyConfiguration(
                         config,
                         await makeResolver(moduleName, contextRequire),
                         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, "$");
                     } catch (e) {
                         throw this._makeError(e);
                     }
                     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;
                 }
                 _makePath() {
                     return this._path
                         .reduce(
                             (prev, cur) => typeof cur === "number" ?
                                 `${prev}[${cur}]` :
                                 `${prev}.${cur}`
                         )
                         .toString();
                 }
                 async _resolveType(moduleName: string, localName: string) {
                     trace.log("resolveType moduleName={0}, localName={1}", moduleName, localName);
                     try {
                         const m = await this._loadModule(moduleName);
-                        return localName ? get(localName, m) : m;
+                        if (localName) {
+                            return get(localName, m);
+                        } else {
+                            if (m instanceof Function)
+                                return m;
+                            if ("default" in m)
+                                return m.default;
+                            return m;
+                        }
                     } catch (e) {
                         trace.error("Failed to resolve type moduleName={0}, localName={1}", moduleName, localName);
                         throw e;
                     }
                 }
                 _loadModule(moduleName: string) {
                     trace.debug("loadModule {0}", moduleName);
+                    if (!this._require)
+                        throw new Error("Module loader isn't specified");
                     return this._require(moduleName);
                 }
-                async _visitRegistrations(data, 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);
                 }
                 _leave() {
                     const name = this._path.pop();
                     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);
                     } else if (isTypeRegistration(data)) {
                         return this._visitTypeRegistration(data, name);
                     } else if (isFactoryRegistration(data)) {
                         return this._visitFactoryRegistration(data, name);
                     } else if (data instanceof Array) {
                         return this._visitArray(data, name);
                     }
                     return this._visitObject(data, name);
                 }
-                async _visitObject(data: object, name: _key) {
+                async _visitObject(data: any, name: string) {
                     if (data.constructor &&
                         data.constructor.prototype !== Object.prototype)
                         return new ValueDescriptor(data);
                     this._enter(name);
                     const v = await mapAll(data, delegate(this, "_visit"));
                     // TODO: handle inline descriptors properly
                     // const ex = {
                     //     activate(ctx) {
                     //         const value = ctx.activate(this.prop, "prop");
                     //         // some code
                     //     },
                     //     // will be turned to ReferenceDescriptor
                     //     prop: { $dependency: "depName" }
                     // };
                     this._leave();
                     return v;
                 }
-                async _visitArray(data: any[], name: _key) {
+                async _visitArray(data: any[], name: string) {
                     if (data.constructor &&
                         data.constructor.prototype !== Array.prototype)
                         return new ValueDescriptor(data);
                     this._enter(name);
                     const v = await mapAll(data, delegate(this, "_visit"));
                     this._leave();
                     return v;
                 }
-                _makeServiceParams(data: ServiceRegistration) {
+                _makeServiceParams(data: ServiceRegistration<any, S>) {
                     const opts: any = {
-                        owner: this._container
                     };
                     if (data.services)
                         opts.services = this._visitRegistrations(data.services, "services");
                     if (data.inject) {
                         this._enter("inject");
                         opts.inject = mapAll(
                             data.inject instanceof Array ?
                                 data.inject :
                                 [data.inject],
                             delegate(this, "_visitObject")
                         );
                         this._leave();
                     }
                     if ("params" in data)
                         opts.params = data.params instanceof Array ?
                             this._visitArray(data.params, "params") :
                             this._visit(data.params, "params");
                     if (data.activation) {
-                        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)
                         opts.cleanup = 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);
                     const opts = this._makeServiceParams(data);
                     if (data.$type instanceof Function) {
                         opts.type = data.$type;
                     } else {
                         const [moduleName, typeName] = data.$type.split(":", 2);
-                        opts.type = this._resolveType(moduleName, typeName);
+                        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)
                     );
                     this._leave();
                     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._root;
                 }
                 getParent() {
                     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,100 +1,88
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 "
84	];	72	];
85	if (opts.length) {	73	if (opts.length) {
86	parts.push("{");	74	parts.push("{");
87	parts.push(opts.join());	75	parts.push(opts.join());
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("");
99	}	87	}
100	}	88	}

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

@@ -1,234 +1,154
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)
17	return m.apply(target, _parse(args, context, "." + method));	18	return m.apply(target, _parse(args, context, "." + method));
18	else	19	else
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
41	if (isDescriptor(value))	42	if (isDescriptor(value))
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();
220	} else if (this._params instanceof Array) {	135	} else if (this._params instanceof Array) {
221	instance = this._factory.apply(this, _parse(this._params, context, "args"));	136	instance = this._factory.apply(this, _parse(this._params, context, "args"));
222	} else {	137	} else {
223	instance = this._factory(_parse(this._params, context, "args"));	138	instance = this._factory(_parse(this._params, context, "args"));
224	}	139	}
225		140
226	if (this._inject) {	141	if (this._inject) {
227	this._inject.forEach(spec => {	142	this._inject.forEach(spec => {
228	for (const m in spec)	143	for (const m in spec)
229	injectMethod(instance, m, context, spec[m]);	144	injectMethod(instance, m, context, spec[m]);
230	});	145	});
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");
                     const ctor = this._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 => {
                                 return new ctor(arg);
                             };
                         }
                     } else {
                         this._factory = () => {
                             return new ctor();
                         };
                     }
                 }
                 toString() {
                     // @constructor {singleton} foo/bar/Baz
                     return ``;
                 }
             }

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;
                 }
                 activate() {
                     return this._value;
                 }
                 toString() {
                     return `@type=${typeof this._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

             export interface Constructor<T = {}> {
                 new(...args: any[]): T;
                 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;
             }
             export interface IDestroyable {
                 destroy(): void;
             }
             export interface IRemovable {
                 remove(): void;
             }
             export interface ICancellation {
                 throwIfRequested(): void;
                 isRequested(): boolean;
                 isSupported(): boolean;
                 register(cb: (e: any) => void): IDestroyable;
             }
             /**
              * Интерфейс поддерживающий асинхронную активацию
              */
             export interface IActivatable {
                 /**
                  * @returns Boolean indicates the current state
                  */
                 isActive(): boolean;
                 /**
                  * Starts the component activation
                  * @param ct cancellation token for this operation
                  */
                 activate(ct?: ICancellation): Promise<void>;
                 /**
                  * Starts the component deactivation
                  * @param ct cancellation token for this operation
                  */
                 deactivate(ct?: ICancellation): Promise<void>;
                 /**
                  * Sets the activation controller for this component
                  * @param controller The activation controller
                  *
                  * Activation controller checks whether this component
                  * 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
                  */
                 getActivationController(): IActivationController;
             }
             export interface IActivationController {
                 activating(component: IActivatable, ct?: ICancellation): Promise<void>;
                 activated(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivating(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivated(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivate(ct?: ICancellation): Promise<void>;
                 activate(component: IActivatable, ct?: ICancellation): Promise<void>;
+                hasActive(): boolean;
                 getActive(): IActivatable;
             }
             export interface IAsyncComponent {
                 getCompletion(): Promise<void>;
             }
             export interface ICancellable {
                 cancel(reason?: any): void;
             }
             export interface IObservable<T> {
                 on(next: (x: T) => void, error?: (e: any) => void, complete?: () => void): IDestroyable;
                 next(ct?: ICancellation): Promise<T>;
             }
             export interface IObserver<T> {
                 next(event: T): void;
                 error(e: any): void;
                 complete(): void;
             }
             export interface TextWriter {
                 write(obj: any): void;
                 write(format: string, ...args: any[]): void;
                 writeLine(obj?: any): void;
                 writeLine(format: string, ...args: any[]): void;
                 writeValue(value: any, spec?: string): void;
             }

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])
                         return this._registry[id];
                     const source = new TraceSource(id);
                     this._registry[id] = source;
                     this._onNewSource(source);
                     return source;
                 }
                 add(id: any, source: TraceSource) {
                     argumentNotNull(id, "id");
                     argumentNotNull(source, "source");
                     this._registry[id] = source;
                     this._onNewSource(source);
                 }
                 _onNewSource(source: TraceSource) {
                     for (const i in this._listeners)
                         this._listeners[i].call(null, source);
                 }
                 on(handler: (source: TraceSource) => void): IDestroyable {
                     argumentNotNull(handler, "handler");
                     const me = this;
                     const cookie = this._nextCookie++;
                     this._listeners[cookie] = handler;
                     for (const i in this._registry)
                         handler(this._registry[i]);
                     return {
                         destroy() {
                             delete me._listeners[cookie];
                         }
                     };
                 }
             }

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

             import { TraceEvent, TraceSource } from "./TraceSource";
             import { format } from "../text/StringBuilder";
             export class TraceEventData implements TraceEvent {
                 source: TraceSource;
                 level: number;
                 message: any;
-                args?: any[];
+                args: any[];
                 constructor(source: TraceSource, level: number, message: any, args: any[]) {
                     this.source = source;
                     this.level = level;
                     this.message = message;
                     this.args = args;
                 }
                 toString() {
                     return format(this.message, ...this.args);
                 }
             }

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 const LogLevel = 300;
             export const WarnLevel = 200;
             export const ErrorLevel = 100;
             export const SilentLevel = 0;
             export interface TraceEvent {
                 readonly source: TraceSource;
                 readonly level: number;
                 readonly message: any;
                 readonly args?: any[];
             }
             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() {
                     return this.level >= DebugLevel;
                 }
                 debug(data: any): void;
                 debug(msg: string, ...args: any[]): void;
                 debug(msg: string, ...args: any[]) {
                     if (this.isEnabled(DebugLevel))
                         this.emit(DebugLevel, msg, args);
                 }
                 isLogEnabled() {
                     return this.level >= LogLevel;
                 }
                 log(data: any): void;
                 log(msg: string, ...args: any[]): void;
                 log(msg: string, ...args: any[]) {
                     if (this.isEnabled(LogLevel))
                         this.emit(LogLevel, msg, args);
                 }
                 isWarnEnabled() {
                     return this.level >= WarnLevel;
                 }
                 warn(data: any): void;
                 warn(msg: string, ...args: any[]): void;
                 warn(msg: string, ...args: any[]) {
                     if (this.isEnabled(WarnLevel))
                         this.emit(WarnLevel, msg, args);
                 }
                 /**
                  * returns true if errors will be recorded.
                  */
                 isErrorEnabled() {
                     return this.level >= ErrorLevel;
                 }
                 /** Traces a error
                  * @param data The object which will be passed to the underlying listeners
                  */
                 error(data: any): void;
                 /**
                  * Traces a error.
                  *
                  * @param msg the message.
                  * @param args parameters which will be substituted in the message.
                  */
                 error(msg: string, ...args: any[]): void;
                 error(msg: string, ...args: any[]) {
                     if (this.isEnabled(ErrorLevel))
                         this.emit(ErrorLevel, msg, args);
                 }
                 /**
                  * Checks whether the specified level is enabled for this
                  * trace source.
                  *
                  * @param level the trace level which should be checked.
                  */
                 isEnabled(level: number) {
                     return (this.level >= level);
                 }
                 /**
                  * Traces a raw event, passing data as it is to the underlying listeners
                  *
                  * @param level the level of the event
                  * @param msg the data of the event, can be a simple string or any object.
                  */
                 traceEvent(level: number, msg: any, ...args: any[]) {
                     if (this.isEnabled(level))
                         this.emit(level, msg, args);
                 }
                 /**
                  * Register the specified handler to be called for every new and already
                  * created trace source.
                  *
                  * @param handler the handler which will be called for each trace source
                  */
                 static on(handler: (source: TraceSource) => void) {
                     return Registry.instance.on(handler);
                 }
                 /**
                  * Creates or returns already created trace source for the specified id.
                  *
                  * @param id the id for the trace source
                  */
                 static get(id: any) {
                     return Registry.instance.get(id);
                 }
             }

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

             import { IObservable, IDestroyable, ICancellation } from "../../interfaces";
             import { TraceEvent, LogLevel, WarnLevel, DebugLevel } from "../TraceSource";
             import { Cancellation } from "../../Cancellation";
             import { destroy, argumentNotNull } from "../../safe";
             import { ConsoleWriter } from "../ConsoleWriter";
             export class ConsoleLogger implements IDestroyable {
                 private readonly _subscriptions = new Array<IDestroyable>();
                 private readonly _writer: ConsoleWriter;
                 constructor(writer = ConsoleWriter.default) {
                     argumentNotNull(writer, "writer");
                     this._writer = writer;
                 }
                 writeEvents(source: IObservable<TraceEvent>, ct: ICancellation = Cancellation.none) {
                     const subscription = source.on(this.writeEvent.bind(this));
                     if (ct.isSupported()) {
                         ct.register(subscription.destroy.bind(subscription));
                     }
                     this._subscriptions.push(subscription);
                 }
                 writeEvent(next: TraceEvent) {
                     if (next.level >= DebugLevel) {
                         this._writer.setLogLevel("debug");
                     } else if (next.level >= LogLevel) {
                         this._writer.setLogLevel("log");
                     } else if (next.level >= WarnLevel) {
                         this._writer.setLogLevel("warn");
                     } else {
                         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() {
                     this._subscriptions.forEach(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;
             const _oid = typeof Symbol === "function" ?
                 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];
                 else
                     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");
             }
             export function argumentNotEmptyString(arg: any, name: string) {
                 if (typeof (arg) !== "string" || !arg.length)
                     throw new Error("The argument '" + name + "' must be a not empty string");
             }
             export function argumentNotEmptyArray(arg: any, name: string) {
                 if (!(arg instanceof Array) || !arg.length)
                     throw new Error("The argument '" + name + "' must be a not empty array");
             }
             export function argumentOfType(arg: any, type: Constructor<{}>, name: string) {
                 if (!(arg instanceof type))
                     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");
             }
             export function isInteger(val: any): val is number {
                 return parseInt(val, 10) === val;
             }
             export function isNumber(val: any): val is number {
                 return parseFloat(val) === val;
             }
             export function isString(val: any): val is string {
                 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";
             }
             export function isCancellable(val: any): val is ICancellable {
                 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;
             }
             export function getGlobal() {
                 // in es3 we can't use indirect call to eval, since it will
                 // be executed in the current call context.
                 if (!_isStrictMode()) {
                     return _getNonStrictGlobal();
                 } else {
                     // tslint:disable-next-line:no-eval
                     return eval.call(null, "this");
                 }
             }
             export function get(member: string, context?: object) {
                 argumentNotEmptyString(member, "member");
                 let that = context || getGlobal();
                 const parts = member.split(".");
                 for (const m of parts) {
                     if (!m)
                         continue;
                     if (isNull(that = that[m]))
                         break;
                 }
                 return that;
             }
             /**
              * Выполняет метод для каждого элемента массива, останавливается, когда
              * либо достигнут конец массива, либо функция <c>cb</c> вернула
              * значение.
              *
              * @param {Array | Object} obj массив элементов для просмотра
              * @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;
                 }
             }
             /** Copies property values from a source object to the destination and returns
              * the destination onject.
              *
              * @param dest The destination object into which properties from the source
              *  object will be copied.
              * @param source The source of values which will be copied to the destination
              *  object.
              * @param template An optional parameter specifies which properties should be
              *  copied from the source and how to map them to the destination. If the
              *  template is an array it contains the list of property names to copy from the
              *  source to the destination. In case of object the templates contains the map
              *  where keys are property names in the source and the values are property
              *  names in the destination object. If the template isn't specified then the
              *  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;
             }
             /** Wraps the specified function to emulate an asynchronous execution.
              * @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))
                     fn = thisArg[fn];
                 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) {
                                 try {
                                     return eb ? wrapresult(eb(e)) : this;
                                 } catch (e2) {
                                     return wrapresult(null, e2);
                                 }
                             }
                         };
                     } else {
                         if (x && x.then)
                             return x;
                         return {
                             then(cb) {
                                 try {
                                     return cb ? wrapresult(cb(x)) : this;
                                 } catch (e2) {
                                     return wrapresult(e2);
                                 }
                             }
                         };
                     }
                 }
                 return (...args) => {
                     try {
                         return wrapresult(fn.apply(thisArg, args));
                     } catch (e) {
                         return wrapresult(null, e);
                     }
                 };
             }
-            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];
                     if (!(method instanceof Function))
                         throw new Error("'method' argument must be a Function or a method name");
                 } else {
                     method = _method;
                 }
                 return (...args) => {
                     return method.apply(target, args);
                 };
             }
             export function delay(timeMs: number, ct = Cancellation.none) {
                 ct.throwIfRequested();
                 return new Promise((resolve, reject) => {
                     const h = ct.register(e => {
                         clearTimeout(id);
                         reject(e);
                         // we don't nedd to unregister h, since ct is already disposed
                     });
                     const id = setTimeout(() => {
                         h.destroy();
                         resolve();
                     }, timeMs);
                 });
             }
+            /** 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
              * proceeded after the promise is resolved.
              *
              */
             export function pmap<T, T2>(
                 items: ArrayLike<T> | PromiseLike<ArrayLike<T>>,
                 cb: (item: T, i: number) => T2 | PromiseLike<T2>
             ): T2[] | PromiseLike<T2[]> {
                 argumentNotNull(cb, "cb");
                 if (isPromise(items)) {
                     return items.then(data => pmap(data, cb));
                 } else {
                     if (isNull(items) || !items.length)
                         return [];
                     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;
                             i++;
                             if (isPromise(r)) {
                                 return r.then(x => {
                                     result[ri] = x;
                                     return next();
                                 });
                             } else {
                                 result[ri] = r;
                             }
                         }
                         return result;
                     };
                     return next();
                 }
             }
             export function pfor<T>(
                 items: ArrayLike<T> | PromiseLike<ArrayLike<T>>,
                 cb: (item: T, i: number) => any
             ): void | PromiseLike<void> {
                 argumentNotNull(cb, "cb");
                 if (isPromise(items)) {
                     return items.then(data => pfor(data, cb));
                 } else {
                     if (isNull(items) || !items.length)
                         return;
                     let i = 0;
-                    const next = () => {
+                    const next = (): any => {
                         while (i < items.length) {
                             const r = cb(items[i], i);
                             i++;
                             if (isPromise(r))
                                 return r.then(next);
                         }
                     };
                     return next();
                 }
             }
             export function first<T>(sequence: ArrayLike<T>): T;
             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;
             /**
              * Выбирает первый элемент из последовательности, или обещания, если в
              * качестве параметра используется обещание, оно должно вернуть массив.
              *
              * @param {Function} cb обработчик результата, ему будет передан первый
              *                  элемент последовательности в случае успеха
              * @param {Function} err обработчик исключения, если массив пустой, либо
              *                  не массив
              *
              * @remarks Если не указаны ни cb ни err, тогда функция вернет либо
              *          обещание, либо первый элемент.
              * @async
              */
             export function first<T>(
                 sequence: ArrayLike<T> | PromiseLike<ArrayLike<T>>,
                 cb?: (x: T) => 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)
                             return err(new Error("The sequence is empty"));
                         else
                             throw new Error("The sequence is empty");
                     } else if (cb) {
                         return cb(sequence[0]);
                     } else {
                         return sequence[0];
                     }
                 } else {
                     if (err)
                         return err(new Error("The sequence is required"));
                     else
                         throw new Error("The sequence is required");
                 }
             }
             export function firstWhere<T>(
                 sequence: ArrayLike<T>,
                 predicate: (x: T) => boolean
             ): T;
             export function firstWhere<T>(
                 sequence: PromiseLike<ArrayLike<T>>,
                 predicate: (x: T) => boolean
             ): PromiseLike<T>;
             export function firstWhere<T>(
                 sequence: ArrayLike<T> | PromiseLike<ArrayLike<T>>,
                 predicate: (x: T) => boolean,
                 cb: (x: T) => void,
                 err?: (x: Error) => void
             ): void;
             export function firstWhere<T>(
                 sequence: ArrayLike<T> | PromiseLike<ArrayLike<T>>,
                 predicate?: (x: T) => boolean,
                 cb?: (x: T) => any,
                 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)
                             err(new Error("The sequence is empty"));
                         else
                             throw new Error("The sequence is empty");
                     } else {
                         if (!predicate) {
                             return cb ? cb(sequence[0]) && void (0) : sequence[0];
                         } else {
                             for (let i = 0; i < sequence.length; i++) {
                                 const v = sequence[i];
                                 if (predicate(v))
                                     return cb ? cb(v) : v;
                             }
                             if (err)
                                 err(new Error("The sequence doesn't contain matching items"));
                             else
                                 throw new Error("The sequence doesn't contain matching items");
                         }
                     }
                 } else {
                     if (err)
                         err(new Error("The sequence is required"));
                     else
                         throw new Error("The sequence is required");
                 }
             }
+            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();
             }
             /**
              * Used to mark that the async operation isn't awaited intentionally.
              * @param p The promise which represents the async operation.
              */
             export function nowait(p: Promise<any>) {
             }
             /** represents already destroyed object.
              */
             export const destroyed = {
                 /** Calling to this method doesn't affect anything, noop.
                  */
                 destroy() {
                 }
             };

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

             import { isPrimitive, isNull } from "../safe";
             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);
                                 if (id >= 0)
                                     return "@ref-" + id;
                                 else {
                                     seen.push(v);
                                     return v;
                                 }
                             } else {
                                 return v;
                             }
                         }, 2);
                     } else if (isNull(value)) {
                         return "";
                     } else if (value instanceof Date) {
                         return value.toISOString();
                     } else {
                         return value.toString();
                     }
                 }
             }

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

             import { FormatScanner, TokeType } from "./FormatScanner";
             import { isNullOrEmptyString, isPrimitive, get } from "../safe";
             import { TextWriter, MapOf } from "../interfaces";
             type CompiledPattern = (writer: TextWriter, args: any) => void;
             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);
                             else
                                 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;
                 }
                 visitText() {
                     while (this._scanner.next()) {
                         // console.log(this._scanner.getTokenType(), this._scanner.getTokenValue());
                         switch (this._scanner.getTokenType()) {
                             case TokeType.CurlOpen:
                                 this.visitCurlOpen();
                                 break;
                             case TokeType.CurlClose:
                                 this.visitCurlClose();
                                 break;
                             default:
                                 this.pushText(this._scanner.getTokenValue());
                         }
                     }
                 }
                 visitCurlClose() {
                     if (!this._scanner.next())
                         this.dieUnexpectedEnd("}");
                     if (this._scanner.getTokenType() !== TokeType.CurlClose)
                         this.dieUnexpectedToken("}");
                     this.pushText("}");
                 }
                 visitCurlOpen() {
                     if (!this._scanner.next())
                         this.dieUnexpectedEnd("{ | TEXT");
                     if (this._scanner.getTokenType() === TokeType.CurlOpen)
                         this.pushText("{");
                     else
                         this.visitTemplateSubst();
                 }
                 visitTemplateSubst() {
                     if (this._scanner.getTokenType() !== TokeType.Text)
                         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("}");
                     this.pushSubst(fieldName, filedFormat);
                 }
                 readFieldFormat() {
                     const parts = new Array<string>();
                     do {
                         if (this._scanner.getTokenType() === TokeType.CurlClose) {
                             return parts.join("");
                         } else {
                             parts.push(this._scanner.getTokenValue());
                         }
                     } while (this._scanner.next());
                     this.dieUnexpectedEnd("}");
                 }
                 readColon() {
                     if (!this._scanner.next())
                         this.dieUnexpectedEnd();
                     if (this._scanner.getTokenType() !== TokeType.Colon)
                         return false;
                     if (!this._scanner.next())
                         this.dieUnexpectedEnd();
                     return true;
                 }
-                pushSubst(fieldName: string, filedFormat: string) {
+                pushSubst(fieldName: string, filedFormat?: string) {
                     // console.log("pushSubst ", fieldName, filedFormat);
                     this._parts.push({ name: fieldName, format: filedFormat });
                 }
                 pushText(text: string) {
                     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

             import { argumentNotEmptyString } from "../safe";
             import { MapOf } from "../interfaces";
             export const enum TokeType {
                 CurlOpen = 1,
                 CurlClose = 2,
                 Colon = 3,
                 Text = 4
             }
             const typeMap = {
                 "{": TokeType.CurlOpen,
                 "}": TokeType.CurlClose,
                 ":": TokeType.Colon
             } as MapOf<TokeType>;
             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) {
                     argumentNotEmptyString(text, text);
                     this._text = text;
                 }
                 next() {
                     if (this._rx.lastIndex >= this._text.length)
                         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];
                     return true;
                 }
                 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

             import { TextWriterBase } from "./TextWriterBase";
             import { Converter } from "./Converter";
             export class StringBuilder extends TextWriterBase {
                 private _data = new Array<string>();
                 constructor(converter = Converter.default) {
                     super(converter);
                 }
                 writeText(text: string) {
                     this._data.push(text);
                 }
                 toString() {
                     return this._data.join("");
                 }
                 clear() {
                     this._data.length = 0;
                 }
             }
             const sb = new StringBuilder();
             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 = {
                 "\\{": "&curlopen;",
                 "\\}": "&curlclose;",
                 "&": "&amp;",
                 "\\:": "&colon;"
             };
             const rev = {
                 curlopen: "{",
                 curlclose: "}",
                 amp: "&",
                 colon: ":"
             };
             function espaceString(s: string) {
                 if (!s)
                     return s;
                 return "'" + s.replace(/('|\\)/g, "\\$1").replace("\n", "\\n") + "'";
             }
             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);
                 } else {
                     name = s;
                 }
                 if (pattern)
                     return [
                         espaceString(decode(name)),
-                        espaceString(decode(pattern))];
+                        espaceString(decode(pattern))
+                    ];
                 else
                     return [espaceString(decode(name))];
             }
             function _compile(str: string) {
                 if (!str)
                     return () => void 0;
                 const chunks = encode(str).split("{");
                 let chunk: string;
                 const code = ["var result=[];"];
                 for (let i = 0; i < chunks.length; i++) {
                     chunk = chunks[i];
                     if (i === 0) {
                         if (chunk)
                             code.push("result.push(" + espaceString(decode(chunk)) +
                                 ");");
                     } else {
                         const len = chunk.indexOf("}");
                         if (len < 0)
                             throw new Error("Unbalanced substitution #" + i);
                         code.push("result.push(subst(" +
                             subst(chunk.substr(0, len)).join(",") + "));");
                         if (chunk.length > len + 1)
                             code.push("result.push(" +
                                 espaceString(decode(chunk.substr(len + 1))) + ");");
                     }
                 }
                 code.push("return result.join('');");
                 // the code for this function is generated from the template
                 // tslint:disable-next-line:function-constructor
                 return new Function("subst", code.join("\n")) as TemplateFn;
             }
             const cache: MapOf<TemplateFn> = {};
             export function compile(template: string) {
                 let compiled = cache[template];
                 if (!compiled) {
                     compiled = _compile(template);
                     cache[template] = compiled;
                 }
                 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);
                             if (id >= 0)
                                 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)) {
                     return "";
                 } else if (value instanceof Date) {
                     return value.toISOString();
                 } else {
-                    return value.toString();
+                    return value.toString() as string;
                 }
             }
             export class Formatter {
                 _converters: ConvertFn[];
                 constructor(converters?: ConvertFn[]) {
                     this._converters = converters || [];
                     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))
                             return res;
                     }
                     return "";
                 }
                 format(msg: string, ...args: any[]) {
                     const template = compile(msg);
                     return template((name, pattern) => {
-                        const value = args[name];
+                        const value = get(name, args);
                         return !isNull(value) ? this.convert(value, pattern) : "";
                     });
                 }
                 compile(msg: string) {
                     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) : "";
                         });
                     };
                 }
             }
             const _default = new Formatter();
             export function format(msg: string, ...args: any[]) {
                 return _default.format(msg, ...args);
             }
             export function convert(value: any, pattern: string) {
                 return _default.format(value, pattern);
             }

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

             import { TextWriter } from "../interfaces";
             import { FormatCompiler } from "./FormatCompiler";
             import { isString, argumentNotNull } from "../safe";
             import { Converter } from "./Converter";
-            const compiler = new FormatCompiler();
             export abstract class TextWriterBase implements TextWriter {
                 private _converter: Converter;
                 constructor(converter = Converter.default) {
                     argumentNotNull(converter, "converter");
                     this._converter = converter;
                 }
                 writeNewLine() {
                     this.writeValue("\n");
                 }
                 write(obj: any): void;
                 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(obj?: any): void;
                 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 :
                             this._converter.convert(value, spec)
                     );
                 }
-                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

             import { IActivatable, ICancellation, IActivationController } from "../interfaces";
             import { Cancellation } from "../Cancellation";
             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;
                 }
                 async deactivate() {
                     if (this._active)
                         await this._active.deactivate();
                     this._active = null;
                 }
                 async activate(component: IActivatable) {
                     if (!component || component.isActive())
                         return;
                     component.setActivationController(this);
                     await component.activate();
                 }
                 async activating(component: IActivatable, ct: ICancellation = Cancellation.none) {
                     if (component !== this._active)
                         await this.deactivate();
                 }
                 async activated(component: IActivatable, ct: ICancellation = Cancellation.none) {
                     this._active = component;
                 }
                 async deactivating(component: IActivatable, ct: ICancellation = Cancellation.none) {
                 }
                 async deactivated(component: IActivatable, ct: ICancellation = Cancellation.none) {
                     if (this._active === component)
                         this._active = null;
                 }
             }

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

             import { MockActivationController } from "../mock/MockActivationController";
             import { SimpleActivatable } from "../mock/SimpleActivatable";
             import { test } from "./TestTraits";
             test("simple activation", async t => {
                 const a = new SimpleActivatable();
                 t.false(a.isActive());
                 await a.activate();
                 t.true(a.isActive());
                 await a.deactivate();
                 t.false(a.isActive());
             });
             test("controller activation", async t => {
                 const a = new SimpleActivatable();
                 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);
                 t.true(a.isActive(), "The component should successfully activate");
                 t.equal(c.getActive(), a, "The controller should point to the activated component");
                 t.equal(a.getActivationController(), c, "The component should point to the controller");
                 t.comment("Deactive the component throug the controller");
                 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");
             });
             test("handle error in onActivating", async t => {
                 const a = new SimpleActivatable();
                 a.onActivating = async () => {
                     throw new Error("Should fail");
                 };
                 try {
                     await a.activate();
                     t.fail("activation should fail");
                 } catch {
                 }
                 t.false(a.isActive(), "the component should remain inactive");
             });

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;
                 });
                 let counter = 0;
                 const reason = "BILL";
                 t.true(ct.isSupported(), "Cancellation must be supported");
                 t.false(ct.isRequested(), "Cancellation shouldn't be requested");
                 ct.throwIfRequested();
                 t.pass("The exception shouldn't be thrown unless the cancellation is requested");
                 ct.register(() => counter++);
                 t.equals(counter, 0, "counter should be zero");
                 ct.register(() => counter++).destroy();
                 doCancel(reason);
                 t.true(ct.isRequested(), "Cancellation should be requested");
                 t.equals(counter, 1, "The registered callback should be triggered");
                 ct.register(() => counter++);
                 t.equals(counter, 2, "The callback should be triggered immediately");
                 let msg;
                 ct.register(e => msg = e);
                 t.equals(msg, reason, "The cancellation reason should be passed to callback");
                 try {
                     msg = null;
                     ct.throwIfRequested();
                     t.fail("The exception should be thrown");
                 } catch (e) {
                     msg = e;
                 }
                 t.equals(msg, reason, "The cancellation reason should be catched");
             });
             test("async cancellation", async t => {
                 const ct = new Cancellation(cancel => {
                     cancel("STOP!");
                 });
                 try {
                     await delay(0, ct);
                     t.fail("Should thow the exception");
                 } catch (e) {
                     t.equals(e, "STOP!", "Should throw the cancellation reason");
                 }
             });
             test("cancel with external event", async t => {
                 const ct = new Cancellation(cancel => {
                     setTimeout(x => cancel("STOP!"), 0);
                 });
                 try {
                     await delay(10000, ct);
                     t.fail("Should thow the exception");
                 } catch (e) {
                     t.equals(e, "STOP!", "Should throw the cancellation reason");
                 }
             });
             test("operation normal flow", async t => {
                 let htimeout;
                 const ct = new Cancellation(cancel => {
                     htimeout = setTimeout(() => cancel("STOP!"), 1000);
                 });
                 try {
                     await delay(0, ct);
                     t.pass("Should pass");
                 } finally {
                     clearTimeout(htimeout);
                 }
             });

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

             import { test } from "./TestTraits";
             import { Container } from "../di/Container";
             import { ReferenceDescriptor } from "../di/ReferenceDescriptor";
             import { AggregateDescriptor } from "../di/AggregateDescriptor";
             import { ValueDescriptor } from "../di/ValueDescriptor";
             import { Foo } from "../mock/Foo";
             import { Bar } from "../mock/Bar";
             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"
                 );
                 t.doesNotThrow(
                     () => container.register("connection", new ValueDescriptor(connection1)),
                     "register ValueDescriptor"
                 );
                 t.equals(container.resolve("connection"), connection1, "resolve string value");
                 t.doesNotThrow(
                     () => container.register(
                         "dbParams",
                         new AggregateDescriptor({
                             timeout: 10,
                             connection: new ReferenceDescriptor({ name: "connection" })
                         })
                     ),
                     "register AggregateDescriptor"
                 );
                 const dbParams = container.resolve("dbParams");
                 t.equals(dbParams.connection, connection1, "should get string value 'dbParams.connection'");
             });
             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: {
                         $type: Foo
                     },
                     box: {
                         $type: Bar,
                         params: {
                             $dependency: "foo"
                         }
                     },
                     bar: {
                         $type: Bar,
-                        params: {
+                        params: [{
                             db: {
                                 provider: {
                                     $dependency: "db"
                                 }
                             }
+                        }]
                     }
                 });
                 t.pass("should configure from js object");
                 const f1 = container.resolve("foo");
                 t.assert(!isNull(f1), "foo should be not null");
                 t.throws(() => container.resolve("bar"), "should not resolve dependency 'db'");
             });
             test("Load configuration from module", async t => {
                 const container = new Container();
                 await container.configure("../mock/config1", { contextRequire: require });
                 t.pass("The configuration should load");
                 const f1 = container.resolve("foo");
                 t.assert(!isNull(f1), "foo should be not null");
                 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();
                         resolve();
                     });
                 });
                 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();
                 t.equals(first, 0, "the first event");
                 t.false(complete, "the sequence is not complete");
                 await done;
                 t.equals(count, 45, "the summ of the evetns");
                 t.true(complete, "the sequence is complete");
             });
             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);
                         complete();
                         fail("Sequence terminated");
                         resolve();
                     });
                 });
+                if (!events)
+                    throw new Error("events === undefined");
                 let count = 0;
                 events.on(() => {}, e => count++, () => count++);
                 const first = await events.next();
                 t.equals(first, 1, "the first message");
                 try {
                     await events.next();
                     t.fail("shoud throw an exception");
                 } catch (e) {
                     t.pass("the sequence is terminated");
                 }
                 await done;
                 t.equals(count, 1, "the sequence must be terminated once");
             });

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 => {
                 // schedule delay
                 let resolved = false;
                 let res = delay(0).then(() => resolved = true);
                 t.false(resolved, "the delay should be async");
                 await res;
                 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
                 resolved = false;
                 res = delay(0, ct).then(() => resolved = true);
                 t.false(resolved, "created delay with ct");
                 // cancel
                 cancel();
                 try {
                     await res;
                     t.fail("the delay should fail when it is cancelled");
                 } catch {
                     t.pass("the delay is cancelled");
                 }
                 t.throws(() => {
                     // try schedule delay after the cancellation is requested
                     nowait(delay(0, ct));
                 }, "Should throw if cancelled before start");
             });
             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);
                 t.equal(v, "b", "The callback should be called for the second element");
                 t.throws(() => {
                     first(empty);
                 }, "Should throw when the sequence is empty");
                 t.throws(() => {
                     firstWhere(empty, x => x === "b");
                 }, "Should throw when the sequence is empty");
                 t.throws(() => {
                     first(empty, x => v = x);
                 }, "Should throw when the sequence is empty");
                 t.throws(() => {
                     firstWhere(empty, x => x === "b", x => v = x);
                 }, "Should throw when the sequence is empty");
                 t.throws(() => {
                     firstWhere(sequence, x => x === "z");
                 }, "Should throw when the element isn't found");
                 t.throws(() => {
                     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
                 const asyncSequence = Promise.resolve(sequence);
                 const asyncEmptySequence = Promise.resolve(empty);
                 const promise = first(asyncSequence);
                 t.true(isPromise(promise), "Should return promise");
                 v = await promise;
                 t.equal(v, "a", "Should return the first element");
                 v = await new Promise(resolve => first(asyncSequence, resolve));
                 t.equal(v, "a", "The callback should be called for the first element");
             });

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

             import { IObservable, ICancellation, IDestroyable } from "../interfaces";
             import { Cancellation } from "../Cancellation";
             import { TraceEvent, LogLevel, WarnLevel, DebugLevel, TraceSource } from "../log/TraceSource";
             import * as tape from "tape";
             import { argumentNotNull, destroy } from "../safe";
             export class TapeWriter implements IDestroyable {
                 private readonly _tape: tape.Test;
                 private readonly _subscriptions = new Array<IDestroyable>();
-                private _destroyed;
+                private _destroyed = false;
                 constructor(t: tape.Test) {
                     argumentNotNull(t, "tape");
                     this._tape = t;
                 }
                 writeEvents(source: IObservable<TraceEvent>, ct: ICancellation = Cancellation.none) {
                     if (!this._destroyed) {
                         const subscription = source.on(this.writeEvent.bind(this));
                         if (ct.isSupported()) {
                             ct.register(subscription.destroy.bind(subscription));
                         }
                         this._subscriptions.push(subscription);
                     }
                 }
                 writeEvent(next: TraceEvent) {
                     if (next.level >= DebugLevel) {
                         this._tape.comment(`DEBUG ${next.source.id} ${next}`);
                     } else if (next.level >= LogLevel) {
                         this._tape.comment(`LOG   ${next.source.id} ${next}`);
                     } else if (next.level >= WarnLevel) {
                         this._tape.comment(`WARN  ${next.source.id} ${next}`);
                     } else {
                         this._tape.comment(`ERROR ${next.source.id} ${next}`);
                     }
                 }
                 destroy() {
+                    if (this._destroyed)
+                        return;
+                    this._destroyed = true;
                     this._subscriptions.forEach(destroy);
                 }
             }
             export function test(name: string, cb: (t: tape.Test, trace: TraceSource) => any) {
                 tape(name, async t => {
                     const writer = new TapeWriter(t);
                     // this trace is not announced through the TraceSource global registry
                     const trace = new TraceSource(name);
                     trace.level = DebugLevel;
                     writer.writeEvents(trace.events);
                     const h = TraceSource.on(ts => {
                         ts.level = DebugLevel;
                         writer.writeEvents(ts.events);
                     });
                     try {
                         await cb(t, trace);
                     } catch (e) {
                         // verbose error information
                         // tslint:disable-next-line
                         console.error(e);
                         t.fail(e);
                     } finally {
                         t.end();
                         destroy(writer);
                         destroy(h);
                     }
                 });
             }

src/test/tsconfig.json 0 -2

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

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

             define([
                 "./ActivatableTests",
                 "./trace-test",
                 "./TraceSourceTests",
                 "./CancellationTests",
                 "./ObservableTests",
                 "./ContainerTests",
                 "./SafeTests",
-                "./TextTests"
+                "./TextTests",
+                "./FluentContainerTests"
             ]);

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

             import "./ActivatableTests";
             import "./TraceSourceTests";
             import "./CancellationTests";
             import "./ObservableTests";
             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