implab/implabjs-core Commit - r115:691199f665e0

corrected code to support ts strict mode...

cin -

r115:691199f665e0 ioc ts support

parent child

Context file:

r115:691199f665e0

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	}

build.gradle +3 -1

             plugins {
               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
+                    strict = true
+                    // dojo-typings are sick
+                    skipLibCheck = true
                     if(symbols != 'none') {
                         sourceMap = true
                         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"
                     }
                 }
             }

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 +20 -23

             import { IObservable, IDestroyable, ICancellation, IObserver } from "./interfaces";
             import { Cancellation } from "./Cancellation";
             import { argumentNotNull, destroyed } 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 = () => { };
+            const nulObserver: IObserver<any> = Object.freeze({
+                next: noop,
+                error: noop,
+                complete: noop
+            });
             function isObserver(val: any): val is IObserver<any> {
                 return val && (typeof val.next === "function");
             }
             export class Observable<T> implements IObservable<T> {
                 private _once = new Array<IObserver<T>>();
                 private _observers = new Array<IObserver<T>>();
-                private _complete: 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 +4 -2

             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) {
-                    this._value = value;
+                    if (this._value !== value) {
-                    this._notifyNext(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 +2 -2

             import { Cancellation } from "../Cancellation";
             import { IAsyncComponent, ICancellation, ICancellable, IDestroyable } from "../interfaces";
             import { destroy } from "../safe";
             export class AsyncComponent implements IAsyncComponent, ICancellable {
-                _cancel: (e: any) => void;
+                _cancel: ((e: any) => void) | undefined;
                 _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 = undefined;
                         }
                     };
                     return this._completion = guard();
                 }
                 cancel(reason: any) {
                     if (this._cancel)
                         this._cancel(reason);
                 }
             }

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

             import { TraceSource } from "../log/TraceSource";
             import { argumentNotNull, argumentNotEmptyString, isPrimitive, each, isNull } from "../safe";
-            import { Descriptor, ServiceMap } from "./interfaces";
+            import { Descriptor, ServiceMap, PartialServiceMap } from "./interfaces";
             import { Container } from "./Container";
             import { MapOf } from "../interfaces";
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
             export interface ActivationContextInfo<S> {
                 name: string;
                 service: string;
-                scope: ServiceMap<S>;
+                scope: PartialServiceMap<S>;
             }
             export class ActivationContext<S> {
                 _cache: MapOf<any>;
-                _services: ServiceMap<S>;
+                _services: PartialServiceMap<S>;
                 _stack: ActivationContextInfo<S>[];
                 _visited: MapOf<any>;
                 _name: string;
                 _localized: boolean = false;
                 container: Container<S>;
-                constructor(container: Container<S>, services: ServiceMap<S>, name?: string, cache?: object, visited?: MapOf<any>) {
+                constructor(container: Container<S>, services: PartialServiceMap<S>, name?: string, cache?: object, visited?: MapOf<any>) {
                     argumentNotNull(container, "container");
                     argumentNotNull(services, "services");
                     this._name = name || "<unnamed>";
                     this._visited = visited || {};
                     this._stack = [];
                     this._cache = cache || {};
                     this._services = services;
                     this.container = container;
                 }
                 getName() {
                     return this._name;
                 }
-                resolve<K extends keyof S, T extends S[K]>(name: K, def?: T) {
+                resolve<K extends keyof S, T extends S[K]>(name: K, def?: T): T {
                     const d = this._services[name];
                     if (d !== undefined) {
-                        return this.activate(d as Descriptor<T>, name.toString());
+                        return this.activate(d as Descriptor<S, T>, name.toString());
                     } else {
                         if (def !== undefined && def !== null)
                             return def;
                         else
                             throw new Error(`Service ${name} not found`);
                     }
                 }
                 /**
                  * registers services local to the the activation context
                  *
                  * @name{string} the name of the service
                  * @service{string} the service descriptor to register
                  */
-                register<K extends keyof S>(name: K, service: Descriptor<S[K]>) {
+                register<K extends keyof S>(name: K, service: Descriptor<S, S[K]>) {
                     argumentNotEmptyString(name, "name");
                     this._services[name] = service;
                 }
                 clone() {
-                    return new ActivationContext(
+                    return new ActivationContext<S>(
                         this.container,
                         this._services,
                         this._name,
                         this._cache,
                         this._visited
                     );
                 }
                 has(id: string) {
                     return id in this._cache;
                 }
                 get<T>(id: string) {
                     return this._cache[id];
                 }
                 store(id: string, value: any) {
                     return (this._cache[id] = value);
                 }
-                activate<T>(d: Descriptor<T>, name: string) {
+                activate<T>(d: Descriptor<S, T>, name: string) {
                     if (trace.isLogEnabled())
                         trace.log(`enter ${name} ${d}`);
                     this.enter(name, d.toString());
-                    const v = d.activate<S>(this);
+                    const v = d.activate(this);
                     this.leave();
                     if (trace.isLogEnabled())
                         trace.log(`leave ${name}`);
                     return v;
                 }
                 visit(id: string) {
                     const count = this._visited[id] || 0;
                     this._visited[id] = count + 1;
                     return count;
                 }
                 getStack() {
                     return this._stack.slice().reverse();
                 }
                 private enter(name: string, service: string) {
                     this._stack.push({
                         name,
                         service,
                         scope: this._services
                     });
                     this._name = name;
                     this._services = Object.create(this._services);
                 }
                 private leave() {
                     const ctx = this._stack.pop();
                     if (ctx) {
                         this._services = ctx.scope;
                         this._name = ctx.name;
                     } else {
                         trace.error("Trying to leave the last activation scope");
                     }
                 }
             }

src/main/ts/di/AggregateDescriptor.ts +1 -5

-            import { Descriptor, isDescriptor } from "./interfaces";
+            import { Descriptor, isDescriptor, Parse } from "./interfaces";
             import { ActivationContext } from "./ActivationContext";
             import { isPrimitive } from "../safe";
-            type Parse<T> = T extends Descriptor<infer V> ? V :
-                    T extends {} ? { [K in keyof T]: Parse<T[K]> } :
-                    T;
             export class AggregateDescriptor<T> implements Descriptor<Parse<T>> {
                 _value: T;
                 constructor(value: T) {
                     this._value = value;
                 }
                 activate<S>(context: ActivationContext<S>) {
                     return this._parse(this._value, context, "$value");
                 }
                 _parse<S, V>(value: V, context: ActivationContext<S>, path: string): Parse<V> {
                     if (isPrimitive(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}]`)) as any;
                     const t: any = {};
                     for (const p in value)
                         t[p] = this._parse(value[p], context, `${path}.${p}`);
                     return t;
                 }
                 toString() {
                     return "@walk";
                 }
             }

src/main/ts/di/Annotations.ts 0 -3

             import { Constructor } from "../interfaces";
             export interface InjectOptions {
                 lazy?: boolean;
             }
             interface Dependency<K extends keyof any> {
                 $dependency: K;
                 lazy?: boolean;
             }
             interface Lazy<K extends keyof any> extends Dependency<K> {
                 lazy: true;
             }
             type Setter<T = any> = (v: T) => void;
             type Compatible<T1, T2> = T1 extends T2 ? any : never;
             type ExtractService<K, S> = K extends keyof S ? S[K] : K;
             type ExtractDependency<D, S> = D extends { $dependency: infer K } ? D extends { lazy: true } ? () => ExtractService<K, S> : ExtractService<K, S> : VisitDependency<D, S>;
             type VisitDependency<D, S> = D extends {} ? { [K in keyof D]: ExtractDependency<D[K], S> } : D;
             interface Config<S> {
                 dependency<K extends keyof S>(name: K): Dependency<K>;
                 lazy<K extends keyof S>(name: K): Lazy<K>;
                 build<T>(): Builder<T, S>;
             }
             export declare function services<S extends object>(): Config<S>;
             export class Builder<T, S> {
                 consume<P extends any[]>(...args: P) {
                     return <C extends new (...args: ExtractDependency<P, S>) => T>(constructor: C) => {
-                        return constructor;
                     };
                 }
                 inject<K extends keyof S>(dependency: K) {
                     // K = "bar"
                     // M = "setValue"
                     // S[K] = Bar
                     // T[M] = (value: string) => void
                     // P[m] = (value: V) => void
                     return <P, M extends keyof (T | P)>(target: P, memberName: M, descriptor: TypedPropertyDescriptor<Compatible<T[M], Setter<S[K]>>>) => {
                     };
                 }
                 cast<T2 extends T>(): Builder<T2, S> {
                     return this as Builder<T2, S>;
                 }
             }

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

             import {
                 ServiceRegistration,
                 TypeRegistration,
                 FactoryRegistration,
                 ServiceMap,
                 isDescriptor,
                 isDependencyRegistration,
                 DependencyRegistration,
                 ValueRegistration,
                 ActivationType,
                 isValueRegistration,
                 isTypeRegistration,
-                isFactoryRegistration
+                isFactoryRegistration,
+                PartialServiceMap
             } from "./interfaces";
             import { argumentNotEmptyString, isPrimitive, isPromise, delegate, argumentOfType, argumentNotNull, get } 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";
             const trace = TraceSource.get("@implab/core/di/Configuration");
+            async function mapAll(data: any[], map?: (v: any, k: number) => any): Promise<any[]>;
-            async function mapAll(data: any | any[], map?: (v: any, k: number | string) => any): Promise<any> {
+            async function mapAll(data: any, map?: (v: any, k: string) => any): Promise<any>;
+            async function mapAll(data: any, map?: (v: any, k: any) => any): Promise<any> {
                 if (data instanceof Array) {
                     return Promise.all(map ? data.map(map) : data);
                 } else {
                     const keys = Object.keys(data);
                     const o: any = {};
                     await Promise.all(keys.map(async k => {
                         const v = map ? map(data[k], k) : data[k];
                         o[k] = isPromise(v) ? await v : v;
                     }));
                     return o;
                 }
             }
             export type ModuleResolver = (moduleName: string, ct?: ICancellation) => any;
             export class Configuration<S> {
                 _hasInnerDescriptors = false;
                 _container: Container<S>;
                 _path: Array<string>;
                 _configName: string | undefined;
                 _require: ModuleResolver | undefined;
                 constructor(container: Container<S>) {
                     argumentNotNull(container, "container");
                     this._container = container;
                     this._path = [];
                 }
                 async loadConfiguration(moduleName: string, contextRequire?: any, ct = Cancellation.none) {
                     argumentNotEmptyString(moduleName, "moduleName");
                     trace.log(
                         "loadConfiguration moduleName={0}, contextRequire={1}",
                         moduleName,
                         contextRequire ? typeof (contextRequire) : "<nil>"
                     );
                     this._configName = moduleName;
                     const r = await makeResolver(undefined, contextRequire);
                     const config = await r(moduleName, ct);
                     await this._applyConfiguration(
                         config,
                         await makeResolver(moduleName, contextRequire),
                         ct
                     );
                 }
                 async applyConfiguration(data: object, contextRequire?: any, ct = Cancellation.none) {
                     argumentNotNull(data, "data");
                     await this._applyConfiguration(data, await makeResolver(void (0), contextRequire), ct);
                 }
                 async _applyConfiguration(data: object, 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: any) {
                     const e = new ConfigError("Failed to load configuration", inner);
                     e.configName = this._configName || "<inline>";
                     e.path = this._makePath();
                     return e;
                 }
                 _makePath() {
                     return this._path
                         .reduce(
                             (prev, cur) => typeof cur === "number" ?
                                 `${prev}[${cur}]` :
                                 `${prev}.${cur}`
                         )
                         .toString();
                 }
                 async _resolveType(moduleName: string, localName: string) {
                     trace.log("resolveType moduleName={0}, localName={1}", moduleName, localName);
                     try {
                         const m = await this._loadModule(moduleName);
                         return localName ? get(localName, m) : m;
                     } 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: any, 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 o: PartialServiceMap<S> = {};
                     const keys = Object.keys(data);
                     const services = await mapAll(data, async (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: keyof any) {
+                _enter(name: string) {
                     this._path.push(name.toString());
                     trace.debug(">{0}", name);
                 }
                 _leave() {
                     const name = this._path.pop();
                     trace.debug("<{0}", name);
                 }
-                async _visit<T>(data: T, name: string) {
+                async _visit<T>(data: T, name: string): Promise<any> {
                     if (isPrimitive(data) || isDescriptor(data))
                         return data;
                     if (isDependencyRegistration<S>(data)) {
                         return this._visitDependencyRegistration(data, name);
                     } else if (isValueRegistration(data)) {
                         return this._visitValueRegistration(data, name);
                     } else if (isTypeRegistration(data)) {
                         return this._visitTypeRegistration(data, name);
                     } else if (isFactoryRegistration(data)) {
                         return this._visitFactoryRegistration(data, name);
                     } else if (data instanceof Array) {
                         return this._visitArray(data, name);
                     }
                     return this._visitObject(data as T & object, name);
                 }
                 async _visitObject<T extends object>(data: T, name: string) {
                     if (data.constructor &&
                         data.constructor.prototype !== Object.prototype)
                         return new ValueDescriptor(data);
                     this._enter(name);
                     const v = await mapAll(data, delegate(this, "_visit"));
                     // TODO: handle inline descriptors properly
                     // const ex = {
                     //     activate(ctx) {
                     //         const value = ctx.activate(this.prop, "prop");
                     //         // some code
                     //     },
                     //     // will be turned to ReferenceDescriptor
                     //     prop: { $dependency: "depName" }
                     // };
                     this._leave();
                     return v;
                 }
                 async _visitArray(data: any[], name: string) {
                     if (data.constructor &&
                         data.constructor.prototype !== Array.prototype)
                         return new ValueDescriptor(data);
                     this._enter(name);
                     const v = await mapAll(data, delegate(this, "_visit"));
                     this._leave();
                     return v;
                 }
                 _makeServiceParams<T, P>(data: ServiceRegistration<T, P, 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") {
                             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<T>(data: ValueRegistration<T>, name: string) {
                     this._enter(name);
                     const d = data.parse ? new AggregateDescriptor(data.$value) : new ValueDescriptor(data.$value);
                     this._leave();
                     return d;
                 }
                 async _visitDependencyRegistration<K extends keyof S>(data: DependencyRegistration<S, K>, name: string) {
                     argumentNotEmptyString(data && data.$dependency, "data.$dependency");
                     this._enter(name);
                     const d = new ReferenceDescriptor<S, K>({
                         name: data.$dependency,
                         lazy: data.lazy,
                         optional: data.optional,
                         default: data.default,
                         services: data.services && await this._visitRegistrations(data.services, "services")
                     });
                     this._leave();
                     return d;
                 }
                 async _visitTypeRegistration<T, P>(data: TypeRegistration<T, P, S>, name: string) {
                     argumentNotNull(data.$type, "data.$type");
                     this._enter(name);
                     const opts = this._makeServiceParams(data);
                     if (data.$type instanceof Function) {
                         opts.type = data.$type;
                     } else {
                         const [moduleName, typeName] = data.$type.split(":", 2);
                         opts.type = this._resolveType(moduleName, typeName);
                     }
                     const d = new TypeServiceDescriptor(
                         await mapAll(opts)
                     );
                     this._leave();
                     return d;
                 }
                 async _visitFactoryRegistration<T, P>(data: FactoryRegistration<T, P, 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(
                         await mapAll(opts)
                     );
                     this._leave();
                     return d;
                 }
             }

src/main/ts/di/Container.ts +14 -13

             import { ActivationContext } from "./ActivationContext";
             import { ValueDescriptor } from "./ValueDescriptor";
             import { ActivationError } from "./ActivationError";
-            import { isDescriptor, ServiceMap, Descriptor } from "./interfaces";
+            import { isDescriptor, ServiceMap, Descriptor, PartialServiceMap, ContainerServices, Resolver } from "./interfaces";
             import { TraceSource } from "../log/TraceSource";
             import { Configuration } from "./Configuration";
             import { Cancellation } from "../Cancellation";
             import { MapOf } from "../interfaces";
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
-            export class Container<S extends { container?: Container<S> }> {
+            export class Container<S = any> implements Resolver<S> {
-                readonly _services: ServiceMap<S>;
+                readonly _services: PartialServiceMap<S, ContainerServices<S>>;
                 readonly _cache: MapOf<any>;
                 readonly _cleanup: (() => void)[];
                 readonly _root: Container<S>;
                 readonly _parent?: Container<S>;
                 _disposed: boolean;
                 constructor(parent?: Container<S>) {
                     this._parent = parent;
                     this._services = parent ? Object.create(parent._services) : {};
                     this._cache = {};
                     this._cleanup = [];
                     this._root = parent ? parent.getRootContainer() : this;
-                    this._services.container = new ValueDescriptor(this);
+                    this._services.container = new ValueDescriptor(this) as any;
                     this._disposed = false;
                 }
                 getRootContainer() {
                     return this._root;
                 }
                 getParent() {
                     return this._parent;
                 }
-                resolve<K extends keyof S, T extends S[K] = S[K]>(name: K, def?: T) {
+                resolve<K extends keyof ContainerServices<S>, T extends ContainerServices<S>[K] = ContainerServices<S>[K]>(name: K, def?: T): T {
                     trace.debug("resolve {0}", name);
                     const d = this._services[name];
                     if (d === undefined) {
                         if (def !== undefined)
                             return def;
                         else
                             throw new Error("Service '" + name + "' isn't found");
                     } else {
                         const context = new ActivationContext<S>(this, this._services);
                         try {
-                            return context.activate(d as Descriptor<T>, name.toString());
+                            return context.activate(d as Descriptor<S, T>, name.toString());
                         } catch (error) {
                             throw new ActivationError(name.toString(), context.getStack(), error);
                         }
                     }
                 }
                 /**
                  * @deprecated use resolve() method
                  */
-                getService<K extends keyof S>(name: K, def?: S[K]) {
+                getService<K extends keyof S, T extends ContainerServices<S>[K] = ContainerServices<S>[K]>(name: K, def?: T) {
                     return this.resolve(name, def);
                 }
-                register<K extends keyof S>(name: K, service: Descriptor<S[K]>): this;
+                register<K extends keyof S>(name: K, service: Descriptor<S, S[K]>): this;
-                register(services: ServiceMap<S>): this;
+                register(services: PartialServiceMap<S>): this;
-                register<K extends keyof S>(nameOrCollection: K | ServiceMap<S>, service?: Descriptor<S[K]>) {
+                register<K extends keyof S>(nameOrCollection: K | ServiceMap<S>, service?: Descriptor<S, S[K]>) {
                     if (arguments.length === 1) {
                         const data = nameOrCollection as ServiceMap<S>;
                         for (const name in data) {
                             if (Object.prototype.hasOwnProperty.call(data, name)) {
-                                this.register(name, data[name] as Descriptor<S[keyof S]>);
+                                this.register(name, data[name] as Descriptor<S, S[keyof S]>);
                             }
                         }
                     } else {
                         if (!isDescriptor(service))
                             throw new Error("The service parameter must be a descriptor");
-                        this._services[nameOrCollection as K] = service;
+                        this._services[nameOrCollection as K] = service as any;
                     }
                     return this;
                 }
                 onDispose(callback: () => void) {
                     if (!(callback instanceof Function))
                         throw new Error("The callback must be a function");
                     this._cleanup.push(callback);
                 }
                 dispose() {
                     if (this._disposed)
                         return;
                     this._disposed = true;
                     for (const f of this._cleanup)
                         f();
                 }
                 /**
                  * @param{String|Object} config
                  *  The configuration of the contaier. Can be either a string or an object,
                  *  if the configuration is an object it's treated as a collection of
                  *  services which will be registed in the contaier.
                  *
                  * @param{Function} opts.contextRequire
                  *  The function which will be used to load a configuration or types for services.
                  *
                  */
                 async configure(config: string | object, opts?: any, ct = Cancellation.none) {
-                    const c = new Configuration(this);
+                    const c = new Configuration<S>(this);
                     if (typeof (config) === "string") {
                         return c.loadConfiguration(config, opts && opts.contextRequire, ct);
                     } else {
                         return c.applyConfiguration(config, opts && opts.contextRequire, ct);
                     }
                 }
                 createChildContainer<S2 extends { container?: Container<S & S2> } = S>(): Container<S & S2> {
                     return new Container<S & S2>(this as any);
                 }
                 has(id: string | number) {
                     return id in this._cache;
                 }
                 get(id: string | number) {
                     return this._cache[id];
                 }
                 store(id: string | number, value: any) {
                     return (this._cache[id] = value);
                 }
             }

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

             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, T, P extends any[]> extends ServiceDescriptorParams<S, T, P> {
-                factory: Factory;
+                factory: (...args: P) => T;
             }
-            export class FactoryServiceDescriptor extends ServiceDescriptor {
+            export class FactoryServiceDescriptor<S, 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 +11 -11

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

src/main/ts/di/ServiceDescriptor.ts +43 -39

             import { ActivationContext } from "./ActivationContext";
-            import { Descriptor, ActivationType, ServiceMap, isDescriptor } from "./interfaces";
+            import { Descriptor, ActivationType, ServiceMap, isDescriptor, Parse, PartialServiceMap } from "./interfaces";
             import { Container } from "./Container";
-            import { argumentNotNull, isPrimitive } from "../safe";
+            import { argumentNotNull, isPrimitive, each, keys, isNull } from "../safe";
             import { TraceSource } from "../log/TraceSource";
             let cacheId = 0;
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
-            function injectMethod(target, method, context, args) {
+            function injectMethod<T, M extends keyof T, S, A>(target: T, method: M, context: ActivationContext<S>, args: A) {
                 const m = target[method];
-                if (!m)
+                if (!m || typeof m !== "function")
                     throw new Error("Method '" + method + "' not found");
                 if (args instanceof Array)
                     return m.apply(target, _parse(args, context, "." + method));
                 else
                     return m.call(target, _parse(args, context, "." + method));
             }
-            function makeClenupCallback(target, method: ((instance) => void) | string) {
+            function makeClenupCallback<T>(target: T, method: Cleaner<T>): () => void;
+            function makeClenupCallback(target: any, method: any) {
                 if (typeof (method) === "string") {
                     return () => {
                         target[method]();
                     };
                 } else {
                     return () => {
                         method(target);
                     };
                 }
             }
-            // TODO: make async
+            function _parse<T, S>(value: T, context: ActivationContext<S>, path: string): Parse<T> {
-            function _parse(value, context: ActivationContext, path: string) {
                 if (isPrimitive(value))
-                    return value;
+                    return value as any;
                 trace.debug("parse {0}", path);
                 if (isDescriptor(value))
                     return context.activate(value, path);
                 if (value instanceof Array)
-                    return value.map((x, i) => _parse(x, context, `${path}[${i}]`));
+                    return value.map((x, i) => _parse(x, context, `${path}[${i}]`)) as any;
-                const t = {};
+                const t: any = {};
-                for (const p of Object.keys(value))
-                    t[p] = _parse(value[p], context, `${path}.${p}`);
+                keys(value).forEach(p => t[p] = _parse(value[p], context, `${path}.${p}`));
                 return t;
             }
-            export interface ServiceDescriptorParams {
+            export type Cleaner<T> = ((x: T) => void) | keyof Extract<T, { [M in keyof T]: () => void }>;
+            export type InjectionSpec<T> = {
+                [m in keyof T]?: any;
+            };
+            export interface ServiceDescriptorParams<S, T, P extends any[]> {
                 activation?: ActivationType;
-                owner: Container;
+                owner: Container<S>;
-                params?;
+                params?: P;
-                inject?: object[];
+                inject?: InjectionSpec<T>[];
-                services?: ServiceMap;
+                services?: PartialServiceMap<S>;
-                cleanup?: ((x) => void) | string;
+                cleanup?: Cleaner<T>;
             }
-            export class ServiceDescriptor implements Descriptor {
+            export class ServiceDescriptor<S, T, P extends any[]> implements Descriptor<S, T> {
-                _instance;
+                _instance: T | undefined;
                 _hasInstance = false;
                 _activationType = ActivationType.Call;
-                _services: ServiceMap;
+                _services: ServiceMap<S>;
-                _params;
+                _params: P | undefined;
-                _inject: object[];
+                _inject: InjectionSpec<T>[];
-                _cleanup: ((x) => void) | string;
+                _cleanup: Cleaner<T> | undefined;
                 _cacheId: any;
-                _owner: Container;
+                _owner: Container<S>;
-                constructor(opts: ServiceDescriptorParams) {
+                constructor(opts: ServiceDescriptorParams<S, T, P>) {
                     argumentNotNull(opts, "opts");
                     argumentNotNull(opts.owner, "owner");
                     this._owner = opts.owner;
-                    if ("activation" in opts)
+                    if (!isNull(opts.activation))
                         this._activationType = opts.activation;
-                    if ("params" in opts)
+                    if (!isNull(opts.params))
                         this._params = opts.params;
-                    if (opts.inject)
+                    this._inject = opts.inject || [];
-                        this._inject = opts.inject;
-                    if (opts.services)
+                    this._services = (opts.services || {}) as ServiceMap<S>;
-                        this._services = opts.services;
                     if (opts.cleanup) {
                         if (!(typeof (opts.cleanup) === "string" || opts.cleanup instanceof Function))
                             throw new Error(
                                 "The cleanup parameter must be either a function or a function name");
                         this._cleanup = opts.cleanup;
                     }
                 }
-                activate(context: ActivationContext) {
+                activate(context: ActivationContext<S>) {
                     // if we have a local service records, register them first
-                    let instance;
+                    let instance: T;
                     // ensure we have a cache id
                     if (!this._cacheId)
                         this._cacheId = ++cacheId;
                     switch (this._activationType) {
                         case ActivationType.Singleton: // SINGLETON
                             // if the value is cached return it
                             if (this._hasInstance)
                                 return this._instance;
                             // singletons are bound to the root container
                             const container = context.container.getRootContainer();
                             if (container.has(this._cacheId)) {
                                 instance = container.get(this._cacheId);
                             } else {
                                 instance = this._create(context);
                                 container.store(this._cacheId, instance);
                                 if (this._cleanup)
                                     container.onDispose(
                                         makeClenupCallback(instance, this._cleanup));
                             }
                             this._hasInstance = true;
                             return (this._instance = instance);
                         case ActivationType.Container: // CONTAINER
                             // return a cached value
                             if (this._hasInstance)
                                 return this._instance;
                             // create an instance
                             instance = this._create(context);
                             // the instance is bound to the container
                             if (this._cleanup)
                                 this._owner.onDispose(
                                     makeClenupCallback(instance, this._cleanup));
                             // cache and return the instance
                             this._hasInstance = true;
                             return (this._instance = instance);
                         case ActivationType.Context: // CONTEXT
                             // return a cached value if one exists
                             if (context.has(this._cacheId))
                                 return context.get(this._cacheId);
                             // context context activated instances are controlled by callers
                             return context.store(this._cacheId, this._create(context));
                         case ActivationType.Call: // CALL
                             // per-call created instances are controlled by callers
                             return this._create(context);
                         case ActivationType.Hierarchy: // HIERARCHY
                             // hierarchy activated instances are behave much like container activated
                             // except they are created and bound to the child container
                             // return a cached value
                             if (context.container.has(this._cacheId))
                                 return context.container.get(this._cacheId);
                             instance = this._create(context);
                             if (this._cleanup)
                                 context.container.onDispose(makeClenupCallback(
                                     instance,
                                     this._cleanup));
                             return context.container.store(this._cacheId, instance);
                         default:
                             throw new Error("Invalid activation type: " + this._activationType);
                     }
                 }
                 isInstanceCreated() {
                     return this._hasInstance;
                 }
                 getInstance() {
                     return this._instance;
                 }
-                _factory(...params: any[]): any {
+                _factory(...params: any[]): T {
                     throw Error("Not implemented");
                 }
-                _create(context: ActivationContext) {
+                _create(context: ActivationContext<S>) {
                     trace.debug(`constructing ${context._name}`);
                     if (this._activationType !== ActivationType.Call &&
                         context.visit(this._cacheId) > 0)
                         throw new Error("Recursion detected");
                     if (this._services) {
-                        for (const p in this._services)
+                        keys(this._services).forEach(p => context.register(p, this._services[p]));
-                            context.register(p, this._services[p]);
                     }
-                    let instance;
+                    let instance: T;
                     if (this._params === undefined) {
                         instance = this._factory();
                     } else if (this._params instanceof Array) {
                         instance = this._factory.apply(this, _parse(this._params, context, "args"));
                     } else {
                         instance = this._factory(_parse(this._params, context, "args"));
                     }
                     if (this._inject) {
                         this._inject.forEach(spec => {
                             for (const m in spec)
                                 injectMethod(instance, m, context, spec[m]);
                         });
                     }
                     return instance;
                 }
             }

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

             import { ServiceDescriptor, ServiceDescriptorParams } from "./ServiceDescriptor";
             import { Constructor, Factory } from "../interfaces";
             import { argumentNotNull, isPrimitive } from "../safe";
-            export interface TypeServiceDescriptorParams extends ServiceDescriptorParams {
+            export interface TypeServiceDescriptorParams<S, T extends object, P extends any[]> extends ServiceDescriptorParams<S, T, P> {
-                type: Constructor;
+                type: Constructor<T>;
             }
-            export class TypeServiceDescriptor extends ServiceDescriptor {
+            export class TypeServiceDescriptor<S, T extends object, P extends any[]> extends ServiceDescriptor<S, T, P> {
                 _type: Constructor;
-                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 inst = ctor.apply(t, args);
                                 return isPrimitive(inst) ? t : inst;
                             };
                         } 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 +1 -1

             import { Descriptor } from "./interfaces";
-            export class ValueDescriptor<T> implements Descriptor<T> {
+            export class ValueDescriptor<T> implements Descriptor<any, T> {
                 _value: T;
                 constructor(value: T) {
                     this._value = value;
                 }
                 activate() {
                     return this._value;
                 }
                 toString() {
                     return `@type=${typeof this._value}`;
                 }
             }

src/main/ts/di/interfaces.ts +19 -6

-            import { isPrimitive } from "../safe";
+            import { isPrimitive, primitive } from "../safe";
             import { ActivationContext } from "./ActivationContext";
             import { Constructor, Factory } from "../interfaces";
-            export interface Descriptor<T = any> {
+            export interface Descriptor<S = any, T = any> {
-                activate<S>(context: ActivationContext<S>): T;
+                activate(context: ActivationContext<S>): T;
             }
             export function isDescriptor(x: any): x is Descriptor {
                 return (!isPrimitive(x)) &&
                     (x.activate instanceof Function);
             }
-            export type ServiceMap<S = any> = {
+            export type ServiceMap<S, S2 extends S = S> = {
-                [k in keyof S]: Descriptor<S[k]>;
+                [k in keyof S2]: Descriptor<S, S2[k]>;
+            };
+            export type PartialServiceMap<S, S2 extends S = S> = Partial<ServiceMap<S, S2>>;
             export enum ActivationType {
                 Singleton = 1,
                 Container,
                 Hierarchy,
                 Context,
                 Call
             }
             export interface RegistrationWithServices<S> {
                 services?: ServiceMap<S>;
             }
             export interface ServiceRegistration<T, P, S> extends RegistrationWithServices<S> {
                 activation?: "singleton" | "container" | "hierarchy" | "context" | "call";
                 params?: P;
                 inject?: object | object[];
                 cleanup?: ((instance: T) => void) | string;
             }
             export interface TypeRegistration<T, P, S> extends ServiceRegistration<T, P, S> {
                 $type: string | Constructor<T>;
             }
             export interface FactoryRegistration<T, P, S> extends ServiceRegistration<T, P, S> {
                 $factory: string | Factory<T>;
             }
             export interface ValueRegistration<T> {
                 $value: T;
                 parse?: boolean;
             }
             export interface DependencyRegistration<S, K extends keyof S> extends RegistrationWithServices<S> {
                 $dependency: K;
                 lazy?: boolean;
                 optional?: boolean;
                 default?: S[K];
             }
+            export type Parse<T> = T extends primitive ? T:
+                    T extends Descriptor<infer V> ? V :
+                    { [K in keyof T]: Parse<T[K]> };
+            export interface Resolver<S> {
+                resolve<K extends keyof ContainerServices<S>, T extends ContainerServices<S>[K] = ContainerServices<S>[K]>(name: K, def?: T): T;
+            }
+            export type ContainerServices<S> = S & {
+                container: Resolver<S>;
+            };
             export function isTypeRegistration(x: any): x is TypeRegistration<any, any, any> {
                 return (!isPrimitive(x)) && ("$type" in x);
             }
             export function isFactoryRegistration(x: any): x is FactoryRegistration<any, 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>(x: any): x is DependencyRegistration<S, keyof S> {
                 return (!isPrimitive(x)) && ("$dependency" in x);
             }

src/main/ts/interfaces.ts +5 0

             export interface Constructor<T = {}> {
                 new(...args: any[]): T;
                 prototype: T;
             }
             export type Factory<T = {}> = (...args: any[]) => T;
             export type Predicate<T = any> = (x: T) => boolean;
             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): 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 +5 -1

             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);
-                    this._writer.writeLine(next.message, ...next.args);
+                    if (next.args)
+                        this._writer.writeLine(next.message, ...next.args);
+                    else
+                    this._writer.writeLine(next.message);
                 }
                 destroy() {
                     this._subscriptions.forEach(destroy);
                 }
             }

src/main/ts/safe.ts +67 -29

             import { ICancellable, Constructor } from "./interfaces";
             import { Cancellation } from "./Cancellation";
             let _nextOid = 0;
             const _oid = typeof Symbol === "function" ?
                 Symbol("__implab__oid__") :
                 "__implab__oid__";
             export function oid(instance: any): string | undefined {
                 if (isNull(instance))
                     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 isObject(val: any): val is object {
                 return typeof val === "object";
             }
-            export function isNull(val: any) {
+            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) {
                 return (val === null || val === undefined ||
-                    ((typeof (val) === "string" || val instanceof String) && val.length === 0))
+                    ((typeof (val) === "string" || val instanceof String) && val.length === 0));
             }
-            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(this: any) {
                 return !this;
             }
             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>
              *          если достигнут конец массива.
              */
-            export function each<T>(obj: T, cb: (v: T[keyof T], k: keyof T) => void): void;
+            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) {
                     for (let i = 0; i < obj.length; i++) {
                         const x = cb.call(thisArg, obj[i], i);
                         if (x !== undefined)
                             return x;
                     }
                 } else {
                     const _keys = Object.keys(obj);
                     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: any): (...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 = (): 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 = (): 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 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 +30 -22

             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; }>;
+                constructor(scanner: FormatScanner) {
+                    this._scanner = scanner;
+                    this._parts = [];
+                }
-                _parts: Array<string | { name: string; format: string; }>;
+                compile() {
+                    this.visitText();
+                    const parts = this._parts;
-                compile(pattern: string) {
+                    return (writer: TextWriter, args: any) => {
+                        parts.forEach(x => {
+                            if (isPrimitive(x))
+                                writer.writeValue(x);
+                            else
+                                writer.writeValue(get(x.name, args), x.format);
+                        });
+                    };
+                }
+                static compile(pattern: string) {
                     let compiledPattern = this._cache && this._cache[pattern];
                     if (!compiledPattern) {
-                        this._scanner = new FormatScanner(pattern);
+                        const compiler = new this(new FormatScanner(pattern));
-                        this._parts = [];
-                        this.visitText();
-                        const parts = this._parts;
-                        compiledPattern = (writer: TextWriter, args: any) => {
+                        compiledPattern = compiler.compile();
-                            parts.forEach(x => {
-                                if (isPrimitive(x))
+                        this._cache[pattern] = compiledPattern;
-                                    writer.writeValue(x);
-                                else
-                                    writer.writeValue(get(x.name, args), x.format);
-                            });
-                        };
-                        if (this._cache)
-                            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, each, 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 +11 -11

             import { Foo } from "./Foo";
-            import { config } from "./config";
+            // import { config } from "./config";
-            const service = config.build("bar");
+            // const service = config.build("bar");
-            @service.consume({
+            // @service.consume({
-                f: config.dependency("foo"),
+            //     f: config.dependency("foo"),
-                nested: {
+            //     nested: {
-                    lazy: config.lazy("foo")
+            //         lazy: config.lazy("foo")
+            //     }
-            })
+            // })
             export class Bar {
                 barName = "bar";
                 _v: Foo | undefined;
                 constructor(_opts: {
-                    f: Foo;
+                    foo: Foo;
                     nested: {
                         lazy: () => Foo
                     }
                 }) {
-                    if (_opts && _opts.f)
+                    if (_opts && _opts.foo)
-                        this._v = _opts.f;
+                        this._v = _opts.foo;
                 }
                 getFoo() {
                     if (this._v === undefined)
                         throw new Error("The foo isn't set");
                     return this._v;
                 }
             }

src/test/ts/mock/Box.ts +8 -8

-            import { services } from "../di/Annotations";
+            // import { services } from "../di/Annotations";
-            import { Bar } from "./Bar";
+            // import { Bar } from "./Bar";
             // declare required dependencies
-            const config = services<{
+            // const config = services<{
-                bar: Bar;
+            //     bar: Bar;
-            }>();
+            // }>();
             // export service descriptor
-            export const service = config.build<Box<Bar>>();
+            // export const service = config.build<Box<Bar>>();
-            @service.consume(config.dependency("bar"))
+            // @service.consume(config.dependency("bar"))
             export class Box<T> {
                 private _value: T | undefined;
                 constructor(value: T) {
                     this._value = value;
                 }
-                @service.inject("bar")
+                // @service.inject("bar")
                 setValue(value: T) {
                     this._value = value;
                 }
                 setObj(value: object) {
                 }
                 getValue() {
                     if (this._value === undefined)
                         throw new Error("Trying to get a value from the empty box");
                     return this._value;
                 }
             }

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/mock/config.ts 0 -4

             import { Foo } from "./Foo";
             import { Bar } from "./Bar";
             import { ActivationType } from "../di/interfaces";
             import { Builder } from "../di/Annotations";
             import { Box } from "./Box";
             interface RegistrationOptions {
                 activation?: ActivationType;
             }
             interface Dependency<K extends keyof any> {
                 $dependency: K;
                 lazy?: boolean;
             }
             interface Lazy<K extends keyof any> extends Dependency<K> {
                 lazy: true;
             }
             type PromiseOrValue<T> = T | PromiseLike<T>;
             interface ConfigBuilder<S> {
                 build<K extends keyof S, T = S[K]>(name: K): Builder<T, S>;
                 dependency<K extends keyof S>(name: K): Dependency<K>;
                 lazy<K extends keyof S>(name: K): Lazy<K>;
                 mapTo<K extends keyof S>(name: K, ctor: () => PromiseOrValue<new (...args: any[]) => S[K]>): ConfigBuilder<S>;
             }
             interface ContainerServices {
                 barBox: Box<Bar>;
                 foo: Foo;
                 bar: Bar;
                 password: string;
                 user: string;
                 timeout: number;
             }
             declare function load<M, C extends keyof M>(m: PromiseLike<M>, name: C): () => PromiseLike<M[C]>;
             const t = {
                 barBox: load(import("./Box"), "Box"),
                 foo: async () => (await import("./Bar")).Bar,
                 bar: Bar,
                 password: String,
                 user: String,
                 timeout: Number
             };
-            declare const bc: typeof Box;
-            const x = new bc();
             export declare const config: ConfigBuilder<ContainerServices>;

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 +2 -1

             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";
+            import { Descriptor } from "../di/interfaces";
             test("Container register/resolve tests", async t => {
                 const container = new Container();
                 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();
                 await container.configure({
                     foo: {
                         $type: Foo
                     },
                     box: {
                         $type: Bar,
                         params: {
                             $dependency: "foo"
                         }
                     },
                     bar: {
                         $type: Bar,
                         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._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);
                     }
                 });
             }

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