implab/implabjs-core Commit - r59:ba3ff79c2832

working on support commonjs modules format

cin -

r59:ba3ff79c2832 default

parent child

Context file:

r59:ba3ff79c2832

Expand all files

docs/ru/build.md created 644 +13 0

@@ -0,0 +1,13
	1	# Сборка проекта
	2
	3	Проект представляет собой сложную структуру, которая делится на несколько наборов, которые используются при условной сборке.
	4	Каждый набор сожержит в себе множество артефактов, которые класифицируются по способу сборки, например, исходные тексты js и ts и набор файлов, которые будут просто скопированы без изменений.
	5
	6	Такая структура позволяет сочитать в проекте несколько языков, а также делать сборки с разными параметрами для разных платформ.
	7
	8	## NPM
	9
	10	Довольно ограниченная среда, поскольку может быть опубликован только один вариант библиотеки, можно конечно использовать разные версии, чтобы публиковать разные сборки, но это приведет к определенным сложностям, по крайней мере при использовании зависимостей, уже не говоря о том, что это будет путать разработчиков.
	11	Использование суффиксов в имени пакета только частично решает задачу, поскольку не все системы могут использовать указание путей при настройке загрузчиков. RequireJS позволяет указывать месторасположение пакета, commonJs не позволяет это сделать без использования специальных средств.
	12
	13	npm позволяет устанавливать библиотеку используя ссылку, что дает возможность ее устанавки из произвольных мест. например, можно установить нужный вариант библиотеки по ссылке <https://implab.org/pub/js/implab/core-es2017-commonjs-1.2.0-rc1.tgz> . No newline at end of file

docs/ru/messaging.md created 644 +56 0

@@ -0,0 +1,56
	1	# Обмен сообщениями
	2
	3	## Session
	4
	5	Контекст обмена сообщениями, отвечает за создание конечных точек для получения и отправки сообщений, а также инкапсулирует в себе работу с провайдером системы обмена сообщениями.
	6
	7	Сессия позволяет выполнить конфигурацию компонент обработки сообщений, до начала реального обмена и после окончания конфигурации выполнить метод `start` после которого начнется реальная обработка. Такой способ позволяет избежать ошибки и потерю сообщений по причине того, что часть компонент готова к работе и уже получает и отправляет сообщения, а часть еще не настроена.
	8
	9	```ts
	10
	11	// some provider related code
	12	const connection = new StompService("ws://broker.329broker.com:15674/ws", { user: "user", pass: "secret" });
	13	const session = connection.createSession();
	14
	15	// create and configure consumers and producers
	16	const consumer = session.createConsumer("topic://notify");
	17
	18	// make event driven consumer
	19	consumer.observe().on(msg => {
	20	// do something
	21
	22	// mark the message as processed
	23	msg.ack();
	24	});
	25
	26	const producer = session.createProducer("queue://requests");
	27
	28	// signal the session to start
	29	session.start();
	30
	31	// await the session is started
	32	await session.getCompletion();
	33
	34	```
	35
	36	### start
	37
	38	Начинает сессию
	39
	40	### createConsumer
	41
	42	### createProducer
	43
	44	## Consumer
	45
	46	### Push-consumer
	47
	48	#### messages
	49
	50	### Pull-consumer
	51
	52	#### read
	53
	54	## Producer
	55
	56	### post No newline at end of file

src/amd/ts/di/ResolverHelper.ts created 644 +66 0

@@ -0,0 +1,66
	1	import { Uuid } from "../Uuid";
	2	import { argumentNotEmptyString, getGlobal } from "../safe";
	3	import { TraceSource, DebugLevel } from "../log/TraceSource";
	4	import m = require("module");
	5
	6	const sandboxId = Uuid();
	7	define(sandboxId, ["require"], r => r);
	8
	9	// tslint:disable-next-line:no-var-requires
	10	const globalRequire = require(sandboxId);
	11
	12	const trace = TraceSource.get(m.id);
	13
	14	export async function createContextRequire(moduleName: string): Promise<Require> {
	15	argumentNotEmptyString(moduleName, "moduleName");
	16
	17	const parts = moduleName.split("/");
	18	if (parts[0] === ".")
	19	throw new Error("An absolute module path is required");
	20
	21	if (parts.length > 1)
	22	parts.splice(-1, 1, Uuid());
	23	else
	24	parts.push(Uuid());
	25
	26	const shim = parts.join("/");
	27
	28	trace.debug(`define shim ${shim}`);
	29
	30	return new Promise<Require>(cb => {
	31	define(shim, ["require"], r => {
	32	trace.debug("shim resolved");
	33	return r;
	34	});
	35	require([shim], cb);
	36	});
	37	}
	38
	39	class ModuleResolver {
	40	_base: string;
	41	_require: Require;
	42
	43	constructor(req: Require, base?: string) {
	44	this._base = base;
	45	this._require = req \|\| globalRequire;
	46	}
	47
	48	resolve(moduleName: string) {
	49	argumentNotEmptyString(moduleName, "moduleName");
	50	const resolvedName = moduleName[0] === "." && this._base ? [this._base, moduleName].join("/") : moduleName;
	51	trace.debug(`${moduleName} -> ${resolvedName}`);
	52
	53	const req = this._require;
	54
	55	return new Promise<any>((cb, eb) => {
	56	req([resolvedName], cb, eb);
	57	});
	58	}
	59	}
	60
	61	export function makeResolver(moduleName: string, contextRequire: Require) {
	62	const base = moduleName && moduleName.split("/").slice(0, -1).join("/");
	63
	64	const resolver = new ModuleResolver(contextRequire, base);
	65	return (id: string) => resolver.resolve(id);
	66	}

src/amd/ts/log/trace.ts created 644 +44 0

@@ -0,0 +1,44
	1	import { TraceSource } from "./TraceSource";
	2	import { Predicate } from "../interfaces";
	3
	4	export = {
	5	on(filter: any , cb: any) {
	6	if (arguments.length === 1) {
	7	cb = filter;
	8	filter = undefined;
	9	}
	10	let test: Predicate<string>;
	11	if (filter instanceof RegExp) {
	12	test = chId => filter.test(chId);
	13	} else if (filter instanceof Function) {
	14	test = filter;
	15	} else if (filter) {
	16	test = chId => chId === filter;
	17	}
	18
	19	if (test) {
	20	TraceSource.on(source => {
	21	if (test(source.id))
	22	source.events.on(cb);
	23	});
	24	} else {
	25	TraceSource.on(source => {
	26	source.events.on(cb);
	27	});
	28	}
	29	},
	30
	31	load(id: string, require: any, cb: (trace: TraceSource) => void) {
	32	if (id) {
	33	cb(TraceSource.get(id));
	34	} else if (require.module && require.module.mid) {
	35	cb(TraceSource.get(require.module.mid));
	36	} else {
	37	require(["module"], (module: { id: any; }) => {
	38	cb(TraceSource.get(module && module.id));
	39	});
	40	}
	41	},
	42
	43	dynamic: true
	44	};

src/amd/ts/text/TemplateCompiler.ts created 644 +104 0

@@ -0,0 +1,104
	1	import { format } from "./StringFormat";
	2	import { TraceSource, DebugLevel } from "../log/TraceSource";
	3	import { ITemplateParser, TokenType } from "./TemplateParser";
	4	import m = require("module");
	5
	6	const trace = TraceSource.get(m.id);
	7
	8	type TemplateFn = (obj: object) => string;
	9
	10	export class TemplateCompiler {
	11
	12	_data: string[];
	13	_code: string[];
	14	_wrapWith = true;
	15
	16	constructor() {
	17	this._code = [];
	18	this._data = [];
	19	}
	20
	21	compile(parser: ITemplateParser): TemplateFn {
	22	this.preamble();
	23	this.visitTemplate(parser);
	24	this.postamble();
	25
	26	const text = this._code.join("\n");
	27
	28	try {
	29	// tslint:disable-next-line:function-constructor
	30	const compiled = new Function("obj, format, $data", text);
	31	/**
	32	* Функция форматирования по шаблону
	33	*
	34	* @type{Function}
	35	* @param{Object} obj объект с параметрами для подстановки
	36	*/
	37	return (obj: object) => compiled(obj \|\| {}, format, this._data);
	38	} catch (e) {
	39	trace.traceEvent(DebugLevel, [e, text, this._data]);
	40	throw e;
	41	}
	42	}
	43
	44	preamble() {
	45	this._code.push(
	46	"var $p = [];",
	47	"var print = function(){",
	48	" $p.push(format.apply(null,arguments));",
	49	"};"
	50	);
	51
	52	if (this._wrapWith)
	53	this._code.push("with(obj){");
	54	}
	55
	56	postamble() {
	57	if (this._wrapWith)
	58	this._code.push("}");
	59
	60	this._code.push("return $p.join('');");
	61	}
	62
	63	visitTemplate(parser: ITemplateParser) {
	64	while (parser.next()) {
	65	switch (parser.token()) {
	66	case TokenType.OpenBlock:
	67	this.visitCode(parser);
	68	break;
	69	case TokenType.OpenInlineBlock:
	70	this.visitInline(parser);
	71	break;
	72	default:
	73	this.visitTextFragment(parser);
	74	break;
	75	}
	76	}
	77	}
	78
	79	visitInline(parser: ITemplateParser) {
	80	const code = ["$p.push("];
	81	while (parser.next()) {
	82	if (parser.token() === TokenType.CloseBlock)
	83	break;
	84	code.push(parser.value());
	85	}
	86	code.push(");");
	87	this._code.push(code.join(""));
	88	}
	89
	90	visitCode(parser: ITemplateParser) {
	91	const code = [];
	92	while (parser.next()) {
	93	if (parser.token() === TokenType.CloseBlock)
	94	break;
	95	code.push(parser.value());
	96	}
	97	this._code.push(code.join(""));
	98	}
	99
	100	visitTextFragment(parser: ITemplateParser) {
	101	const i = this._data.push(parser.value());
	102	this._code.push("$p.push($data[" + i + "]);");
	103	}
	104	}

src/amd/ts/text/TemplateParser.ts created 644 +64 0

@@ -0,0 +1,64
	1	import { argumentNotEmptyString } from "../safe";
	2	import { MapOf } from "../interfaces";
	3
	4	const splitRx = /(<%=\|\[%=\|<%\|\[%\|%\]\|%>)/;
	5
	6	export enum TokenType {
	7	None,
	8	Text,
	9	OpenInlineBlock,
	10	OpenBlock,
	11	CloseBlock
	12	}
	13
	14	const tokenMap: MapOf<TokenType> = {
	15	"<%": TokenType.OpenBlock,
	16	"[%": TokenType.OpenBlock,
	17	"<%=": TokenType.OpenInlineBlock,
	18	"[%=": TokenType.OpenInlineBlock,
	19	"%>": TokenType.CloseBlock,
	20	"%]": TokenType.CloseBlock
	21	};
	22
	23	export interface ITemplateParser {
	24	next(): boolean;
	25	token(): TokenType;
	26	value(): string;
	27	}
	28
	29	export class TemplateParser implements ITemplateParser {
	30
	31	_tokens: string[];
	32	_pos = -1;
	33	_type: TokenType;
	34	_value: string;
	35
	36	constructor(text: string) {
	37	argumentNotEmptyString(text, "text");
	38
	39	this._tokens = text.split(splitRx);
	40	this._type = TokenType.None;
	41	}
	42
	43	next() {
	44	this._pos++;
	45	if (this._pos < this._tokens.length) {
	46	this._value = this._tokens[this._pos];
	47	this._type = tokenMap[this._value] \|\| TokenType.Text;
	48	return true;
	49	} else {
	50	this._type = TokenType.None;
	51	this._value = undefined;
	52	return false;
	53	}
	54	}
	55
	56	token() {
	57	return this._type;
	58	}
	59
	60	value() {
	61	return this._value;
	62	}
	63
	64	}

src/cjs/ts/di/ResolverHelper.ts created 644 +33 0

@@ -0,0 +1,33
	1	import { argumentNotEmptyString } from "../safe";
	2	import { TraceSource } from "../log/TraceSource";
	3
	4	const trace = TraceSource.get(module.id);
	5
	6	const mainModule = require.main;
	7	const mainRequire = (id: string) => mainModule.require(id);
	8
	9	class ModuleResolver {
	10	_base: string;
	11	_require: NodeRequireFunction;
	12
	13	constructor(req: NodeRequireFunction, base?: string) {
	14	this._base = base;
	15	this._require = (req \|\| mainRequire).bind(null);
	16	}
	17
	18	resolve(moduleName: string) {
	19	argumentNotEmptyString(moduleName, "moduleName");
	20	const resolvedName = moduleName[0] === "." && this._base ? [this._base, moduleName].join("/") : moduleName;
	21
	22	trace.debug(`${moduleName} -> ${resolvedName}`);
	23
	24	return this._require(resolvedName);
	25	}
	26	}
	27
	28	export function makeResolver(moduleName: string, contextRequire: NodeRequireFunction) {
	29	const base = moduleName && moduleName.split("/").slice(0, -1).join("/");
	30
	31	const resolver = new ModuleResolver(contextRequire, base);
	32	return (id: string) => resolver.resolve(id);
	33	}

src/main/ts/di/ResolverHelper.d.ts created 644 +3 0

@@ -0,0 +1,3
	1	import { ModuleResolver } from "./Configuration";
	2
	3	export declare function makeResolver(moduleName?: string, contextRequire?: any): ModuleResolver; No newline at end of file

src/main/ts/messaging/interfaces.ts created 644 +33 0

@@ -0,0 +1,33
	1	import { ICancellation } from "../interfaces";
	2
	3	/** interface for message consumers, used to recieve messages from a single endpoint.
	4	*/
	5	export interface IConsumer<T> {
	6	/** Reads the next message from the destination for which the consumer was created.
	7	* @param options A provider specific options.
	8	* @param ct The cancellation token for this operation.
	9	* @returns A recieved message or a promise. If message is prefetched it will
	10	* be returned immediately, otherwise a promise is returned.
	11	*/
	12	read(options?: object, ct?: ICancellation): T \| Promise<T>;
	13	}
	14
	15	/** Interface for message produsers, used to send messages to the endpoints.
	16	* The producer can be bound to the particular destination or a destination
	17	* can be specified as an additional option during post if supported.
	18	*/
	19	export interface IProducer<T> {
	20	/** Sends a message
	21	* @param msg The message to send.
	22	* @param options A provider specific options
	23	* @param ct The cancellation token for this operation
	24	*/
	25	post(msg: T, options?: object, ct?: ICancellation): void \| Promise<void>;
	26	}
	27
	28	export interface ISession {
	29	start(ct: ICancellation): void;
	30
	31	createConsumer<T = any>(destination: string, options?: object): IConsumer<T>;
	32	createProducer<T = any>(destination: string, options?: object): IProducer<T>;
	33	}

src/package.amd.tmpl.json created 644 +24 0

@@ -0,0 +1,24
	1	{
	2	"name": "${packageName}",
	3	"version": "${version}",
	4	"description": "${description}",
	5	"main": "main.js",
	6	"keywords": [
	7	"di",
	8	"ioc",
	9	"logging",
	10	"template engine",
	11	"dependency injection"
	12	],
	13	"author": "${author}",
	14	"license": "${license}",
	15	"repository": "$repository",
	16	"publishConfig": {
	17	"access": "public"
	18	},
	19	"peerDependencies": {
	20	"dojo": "^1.10.0"
	21	},
	22	"module": "${jsmodule}",
	23	"target": "${target}"
	24	} No newline at end of file

src/package.commonjs.tmpl.json created 644 +21 0

@@ -0,0 +1,21
	1	{
	2	"name": "${packageName}",
	3	"version": "${version}",
	4	"description": "${description}",
	5	"main": "main.js",
	6	"keywords": [
	7	"di",
	8	"ioc",
	9	"logging",
	10	"template engine",
	11	"dependency injection"
	12	],
	13	"author": "${author}",
	14	"license": "${license}",
	15	"repository": "$repository",
	16	"publishConfig": {
	17	"access": "public"
	18	},
	19	"module": "${jsmodule}",
	20	"target": "${target}"
	21	} No newline at end of file

src/testAmd/js/example.js created 644 +7 0

@@ -0,0 +1,7
	1	define(["tape", "core/Uuid"], function(tape, Uuid) {
	2	"use strict";
	3	tape('uuid', function(t) {
	4	t.notEqual(Uuid(),Uuid());
	5	t.end();
	6	});
	7	}); No newline at end of file

src/testAmd/js/mock/config1.js created 644 +20 0

@@ -0,0 +1,20
	1	define({
	2	foo: {
	3	$type: "./Foo:Foo"
	4	},
	5
	6	bar: {
	7	$type: "./Bar:Bar",
	8	params: {
	9	db: {
	10	provider: {
	11	$dependency: "db"
	12	}
	13	},
	14	foo: {
	15	$type: "./Foo:Foo"
	16	}
	17	}
	18	},
	19	db: "db://localhost"
	20	}); No newline at end of file

src/testAmd/js/plan.js created 644 +8 0

@@ -0,0 +1,8
	1	define([
	2	"./ActivatableTests",
	3	"./trace-test",
	4	"./TraceSourceTests",
	5	"./CancellationTests",
	6	"./ObservableTests",
	7	"./ContainerTests"
	8	]); No newline at end of file

src/testAmd/js/run-amd-tests.js created 644 +22 0

@@ -0,0 +1,22
	1	var rjs = require('requirejs');
	2
	3	rjs.config({
	4	baseUrl: '.',
	5	packages: [{
	6	name: "@implab/core",
	7	location: "build/dist"
	8	},
	9	{
	10	name: "test",
	11	location: "build/test"
	12	},
	13	{
	14	name: "dojo",
	15	location: "node_modules/dojo"
	16	}
	17	],
	18	nodeRequire: require
	19	});
	20
	21
	22	rjs(['test/plan']); No newline at end of file

src/testAmd/js/trace-test.js created 644 +30 0

@@ -0,0 +1,30
	1	define(["tape"], function(tape) {
	2	"use strict";
	3	var sourceId = '73a633f3-eab8-49b0-8601-07cae710f234';
	4	var sourceId2 = '3ba9c7cd-ed77-437b-9a2f-1cbeb1226b5b';
	5	tape('Load TraceSource for the module', function(t) {
	6	require(["@implab/core/log/trace!" + sourceId, "@implab/core/log/TraceSource"], function(trace, TraceSource_1) {
	7	var TraceSource = TraceSource_1.TraceSource;
	8	t.equal(trace && trace.id, sourceId, "trace should be taken from the loader plugin parameter");
	9
	10	var count = 0;
	11
	12	var h = TraceSource.on(function(x) {
	13	if(x.id == sourceId \|\| x.id == sourceId2)
	14	count++;
	15	});
	16
	17	t.equal(count, 1, "should see created channel immediatelly");
	18	t.equal(trace, TraceSource.get(sourceId), "should get same TraceSource from registry");
	19	t.equal(count, 1);
	20
	21	TraceSource.get(sourceId2);
	22
	23	t.equal(count, 2);
	24
	25	h.destroy();
	26
	27	t.end();
	28	});
	29	});
	30	}); No newline at end of file

src/testAmd/tsconfig.json created 644 +22 0

@@ -0,0 +1,22
	1	{
	2	"extends": "../tsconfig",
	3	"compilerOptions": {
	4	"rootDir": "ts",
	5	"baseUrl": ".",
	6	"paths": {
	7	"@implab/core/*": [
	8	"../../build/dist/*"
	9	]
	10	},
	11	"types": [
	12	"requirejs"
	13	],
	14	"rootDirs": [
	15	"ts",
	16	"../typings/test"
	17	]
	18	},
	19	"include" : [
	20	"ts/*/.ts"
	21	]
	22	} No newline at end of file

build.gradle +128 -64

@@ -1,134 +1,198
1	if (release != 'rtm') {	1	if (release != 'rtm') {
2	version += "-$release"	2	version += "-$release"
3	}	3	}
4		4
5	if(!npmName)	5	if(!npmName)
6	npmName = name;	6	npmName = name;
7		7
8	if(!["amd", "cjs"].contains(platform))	8	if(!["amd", "commonjs", "system", "umd", "es6", "esnext"].contains(jsmodule))
9	throw new Exception("Invalid ~~platform~~ specified: $~~platform~~");	9	throw new Exception("Invalid jsmodule specified: $jsmodule");
		10	if(!["es3", "es5", "es6", "es2016", "es2017", "esnext"].contains(target))
		11	throw new Exception("Invalid target specified: $target")
10		12
11	def moduleTypes = [	13	def targetLibs = [
12	"amd": "amd",	14	"es3" : "es5,es2015.promise,es2015.symbol,dom,scripthost",
13	"cjs": "commonjs"	15	"es5" : "es5,es2015.promise,es2015.symbol,dom,scripthost"
14	]	16	];
15		17
16	ext.packageName="$npmScope/$npmName~~-$platform~~";	18	ext.packageName="$npmScope/$npmName";
17		19
18	def srcDir = "$projectDir/src"	20	def srcDir = "$projectDir/src"
19	def typingsDir = "$srcDir/typings"	21	def typingsDir = "$srcDir/typings"
20	def distDir = "$buildDir/dist~~/$platform~~"	22	def distDir = "$buildDir/dist"
21	def testDir = "$buildDir/test~~/$platform~~"	23	def testDir = "$buildDir/test"
22	def moduleType = moduleTypes[platform]	24	def lib = targetLibs[target] ?: "${target},dom";
		25
		26	println "lib: $lib";
		27
		28	def sourceSets = ["main", "amd", "cjs"];
		29	def testSets = ["test", "testAmd", "testCjs"];
		30
		31	task beforeBuild {
		32	}
		33
		34	def createSoursetTasks = { String name, String outDir ->
		35	def setName = name.capitalize();
		36
		37	def destDir = "$buildDir/compile/$name"
		38	def declDir = "$typingsDir/$name"
		39	def setDir = "$projectDir/src/$name"
		40
		41	def beforeBuildTask = task "beforeBuild$setName"(dependsOn: beforeBuild) {
		42	}
		43
		44	def copyJsTask = task "copyJs$setName"(dependsOn: beforeBuildTask, type: Copy) {
		45	from "$setDir/js"
		46	into outDir
		47	}
		48
		49	def compileTypingsTask = task "compileTypings$setName"(dependsOn: beforeBuildTask, type: Exec) {
		50	inputs.dir("$setDir/ts")
		51	inputs.file("$srcDir/tsconfig.json")
		52	inputs.file("$setDir/tsconfig.json")
		53	outputs.dir(declDir)
23		54
24	def sourceSets = ["main", "amd", "cjs", "test"];	55	commandLine 'node_modules/.bin/tsc',
		56	'-p', "$setDir/tsconfig.json",
		57	'-t', target,
		58	'-m', jsmodule,
		59	'-d',
		60	'--emitDeclarationOnly',
		61	'--declarationDir', declDir
		62
		63	if (lib)
		64	args '--lib', lib
		65	}
		66
		67	def compileTsTask = task "compileTs$setName"(dependsOn: beforeBuildTask, type: Exec) {
		68	inputs.dir("$setDir/ts")
		69	inputs.file("$srcDir/tsconfig.json")
		70	inputs.file("$setDir/tsconfig.json")
		71	outputs.dir(destDir)
		72
		73	commandLine 'node_modules/.bin/tsc',
		74	'-p', "$setDir/tsconfig.json",
		75	'-t', target,
		76	'-m', jsmodule,
		77	'--outDir', destDir
		78
		79	if (lib)
		80	args '--lib', lib
		81	}
		82
		83	def copyTsOutputTask = task "copyTsOutput$setName"(dependsOn: compileTsTask, type: Copy) {
		84	from compileTsTask
		85	into outDir
		86	}
		87
		88	def copyTypingsTask = task "copyTypings$setName"(dependsOn: compileTypingsTask, type: Copy) {
		89	from compileTypingsTask
		90	into outDir
		91	}
		92
		93	task "build$setName"(dependsOn: [copyTypingsTask, copyTsOutputTask, copyJsTask]) {
		94	}
		95	}
25		96
26	task printVersion {	97	task printVersion {
27	doLast {	98	doLast {
28	println "version: $version"	99	println "version: $version"
29	println "packageName: $packageName"	100	println "packageName: $packageName"
30	println "~~platform: $platform~~"	101	println "target: $target"
31	println "module: $modul~~eTyp~~e"	102	println "module: $jsmodule"
32	}	103	}
33	}	104	}
34		105
35	task clean {	106	task clean {
36	doLast {	107	doLast {
37	delete buildDir	108	delete buildDir
38	delete "node_modules/$packageName"
39	delete typingsDir	109	delete typingsDir
40	}	110	}
41	}	111	}
42		112
		113	task _initBuild {
		114	mustRunAfter clean
		115
		116	def buildInfoFile = "$buildDir/platform";
		117	inputs.property('target',target);
		118	inputs.property('jsmodule',jsmodule);
		119	outputs.file(buildInfoFile);
		120
		121	doLast {
		122	delete buildDir
		123	mkdir buildDir
		124
		125	def f = new File(buildInfoFile);
		126	f << "$target-$jsmodule";
		127	}
		128	}
		129
43	task cleanNpm {	130	task cleanNpm {
44	doLast {	131	doLast {
45	delete 'node_modules'	132	delete 'node_modules'
46	}	133	}
47	}	134	}
48		135
49	task _npmInstall() {	136	task _npmInstall() {
50	inputs.file("package.json")	137	inputs.file("package.json")
51	outputs.dir("node_modules")	138	outputs.dir("node_modules")
52	doLast {	139	doLast {
53	exec {	140	exec {
54	commandLine 'npm', 'install'	141	commandLine 'npm', 'install'
55	}	142	}
56	}	143	}
57	}	144	}
58		145
59	sourceSets.each {	146	beforeBuild {
60	def setName = it.capitalize();	147	dependsOn _initBuild
61		148	dependsOn _npmInstall
62	def destDir = "$buildDir/compile/$it"	149	}
63	def declDir = "$typingsDir/$it"
64	def setDir = "$projectDir/src/$it"
65
66	task "_copyJs$setName"(type:Copy) {
67	from "$setDir/js"
68	into distDir
69	}
70		150
71	task "_compileTs$setName"(dependsOn: _npmInstall, type:Exec) {	151	sourceSets.each { createSoursetTasks(it, distDir) }
72	inputs.dir("$setDir/ts")
73	inputs.file("$srcDir/tsconfig.json")
74	inputs.file("$setDir/tsconfig.json")
75	outputs.dir(destDir)
76	outputs.dir(declDir)
77		152
78	commandLine 'node_modules/.bin/tsc',	153	testSets.each { createSoursetTasks(it, testDir) }
79	'-p', "$setDir/tsconfig.json",
80	'-m', moduleType,
81	'--outDir', destDir,
82	'--declarationDir', declDir
83	}
84		154
85	task "_buildTs$setName"(dependsOn: "_compileTs$setName", type:Copy) {	155	compileTsAmd {
86	from tasks.getByPath("_compileTs$setName");	156	dependsOn compileTypingsMain
87	into distDir
88	}
89	}	157	}
90		158
91	_compileTsAmd {	159	compileTypingsAmd {
92	dependsOn ~~_buildT~~sMain	160	dependsOn compileTypingsMain
		161	}
		162
		163	task build(dependsOn: buildMain) {
		164	if (jsmodule == "amd")
		165	dependsOn buildAmd
93	}	166	}
94		167
95	~~_build~~TsTest {	168	compileTsTest {
96	into testDir	169	dependsOn build
97	}	170	}
98		171
99	~~_copyJsTest~~ {	172	compileTsTestAmd {
100	into testDir	173	dependsOn compileTypingsTestAmd
		174	}
		175
		176	task test(dependsOn: [buildTest, buildTestAmd], type: Exec) {
		177	commandLine 'node', "$testDir/run-amd-tests.js"
101	}	178	}
102		179
103	task _packageMeta(type: Copy) {	180	task _packageMeta(type: Copy) {
		181	mustRunAfter build
		182
104	inputs.property("version", version)	183	inputs.property("version", version)
105	from('.') {	184	from('.') {
106	include '.npmignore', 'readme.md', 'license', 'history.md'	185	include '.npmignore', 'readme.md', 'license', 'history.md'
107	}	186	}
108	from("$srcDir/package.~~template~~.json") {	187	from("$srcDir/package.${jsmodule}.tmpl.json") {
109	expand project.properties	188	expand project.properties
110	rename { "package.json" }	189	rename { "package.json" }
111	}	190	}
112	into distDir	191	into distDir
113	}	192	}
114		193
115	task build(dependsOn: [_copyJsMain, _copyJsAmd, _npmInstall, _buildTsMain, _buildTsAmd, _packageMeta]) {	194	task pack(dependsOn: [build, _packageMeta], type: Exec) {
116
117	}
118
119	_compileTsTest {
120	dependsOn build
121	}
122
123	task buildTests(dependsOn: [_copyJsTest, _buildTsTest]) {
124	}
125
126	task test(dependsOn: buildTests, type: Exec) {
127	commandLine 'node', "$testDir/run-amd-tests.js"
128	}
129
130	task pack(dependsOn: build, type: Exec) {
131	workingDir distDir	195	workingDir distDir
132		196
133	commandLine 'npm', 'pack'	197	commandLine 'npm', 'pack'
134	} No newline at end of file	198	}

docs/ru/observable.md +1 -5

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

gradle.properties +2 -1

             version=1.2.0
             release=rc
             author=Implab team
-            platform=amd
+            jsmodule=amd
+            target=es5
             description=Dependency injection, logging, simple and fast text template engine
             license=BSD-2-Clause
             repository=https://bitbucket.org/implab/implabjs
             npmScope=@implab
             npmName=core

history.md +10 -2

             HISTORY
             =======
+.2.0
+            -----
+            Major rafactoring, moving to support browser (rjs) and server (cjs) environments.
+            - dependency injection container ported to typescript
+            - sources are split to several sets to provide the ability for the conditional build of the project.
 .0.1
             -----
-            First release, intorduces the followinf features
+            First release, intorduces the following features
-            - `di` - dependency injection conyainer
+            - `di` - dependency injection container
             - `log` - log4 style logging system
             - `text` - simple and fast text templating and formatting
             - `Uuid` - uuid generation traits

package-lock.json +25 -16

             {
               "name": "@implab/core",
               "version": "0.0.1-dev",
               "lockfileVersion": 1,
               "requires": true,
               "dependencies": {
                 "@types/node": {
-                  "version": "10.12.15",
+                  "version": "10.12.18",
-                  "resolved": "https://registry.npmjs.org/@types/node/-/node-10.12.15.tgz",
+                  "resolved": "https://registry.npmjs.org/@types/node/-/node-10.12.18.tgz",
-                  "integrity": "sha512-9kROxduaN98QghwwHmxXO2Xz3MaWf+I1sLVAA6KJDF5xix+IyXVhds0MAfdNwtcpSrzhaTsNB0/jnL86fgUhqA==",
+                  "integrity": "sha512-fh+pAqt4xRzPfqA6eh3Z2y6fyZavRIumvjhaCL753+TVkGKGhpPeyrJG2JftD0T9q4GF00KjefsQ+PQNDdWQaQ==",
                   "dev": true
                 },
                 "@types/requirejs": {
                   "version": "2.1.31",
                   "resolved": "https://registry.npmjs.org/@types/requirejs/-/requirejs-2.1.31.tgz",
                   "integrity": "sha512-b2soeyuU76rMbcRJ4e0hEl0tbMhFwZeTC0VZnfuWlfGlk6BwWNsev6kFu/twKABPX29wkX84wU2o+cEJoXsiTw==",
                   "dev": true
                 },
                 "@types/tape": {
-                  "version": "4.2.32",
+                  "version": "4.2.33",
-                  "resolved": "http://registry.npmjs.org/@types/tape/-/tape-4.2.32.tgz",
+                  "resolved": "https://registry.npmjs.org/@types/tape/-/tape-4.2.33.tgz",
-                  "integrity": "sha512-xil0KO5wkPoixdBWGIGolPv9dekf6dVkjjJLAFYchfKcd4DICou67rgGCIO7wAh3i5Ff/6j9IDgZz+GU9cMaqQ==",
+                  "integrity": "sha512-ltfyuY5BIkYlGuQfwqzTDT8f0q8Z5DGppvUnWGs39oqDmMd6/UWhNpX3ZMh/VYvfxs3rFGHMrLC/eGRdLiDGuw==",
                   "dev": true,
                   "requires": {
                     "@types/node": "*"
                   }
                 },
                 "balanced-match": {
                   "version": "1.0.0",
                   "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz",
                   "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=",
                   "dev": true
                 },
                 "brace-expansion": {
                   "version": "1.1.11",
                   "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
                   "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
                   "dev": true,
                   "requires": {
                     "balanced-match": "^1.0.0",
                     "concat-map": "0.0.1"
                   }
                 },
                 "concat-map": {
                   "version": "0.0.1",
                   "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
                   "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=",
                   "dev": true
                 },
                 "core-util-is": {
                   "version": "1.0.2",
                   "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz",
                   "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=",
                   "dev": true
                 },
                 "deep-equal": {
                   "version": "0.1.2",
                   "resolved": "https://registry.npmjs.org/deep-equal/-/deep-equal-0.1.2.tgz",
                   "integrity": "sha1-skbCuApXCkfBG+HZvRBw7IeLh84=",
                   "dev": true
                 },
                 "define-properties": {
                   "version": "1.1.3",
                   "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.3.tgz",
                   "integrity": "sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==",
                   "dev": true,
                   "requires": {
                     "object-keys": "^1.0.12"
                   },
                   "dependencies": {
                     "object-keys": {
                       "version": "1.0.12",
                       "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.0.12.tgz",
                       "integrity": "sha512-FTMyFUm2wBcGHnH2eXmz7tC6IwlqQZ6mVZ+6dm6vZ4IQIHjs6FdNsQBuKGPuUUUY6NfJw2PshC08Tn6LzLDOag==",
                       "dev": true
                     }
                   }
                 },
                 "defined": {
                   "version": "0.0.0",
                   "resolved": "https://registry.npmjs.org/defined/-/defined-0.0.0.tgz",
                   "integrity": "sha1-817qfXBekzuvE7LwOz+D2SFAOz4=",
                   "dev": true
                 },
                 "dojo": {
                   "version": "1.14.2",
                   "resolved": "https://registry.npmjs.org/dojo/-/dojo-1.14.2.tgz",
                   "integrity": "sha512-TI+Ytgfh/VfmHWERp45Jte6NFMdoJTPsvUP/uzJUvAXET8FP2h442LePWWJ/q/xZ4V0V8OtdJhx8It/GB+Zbxg==",
                   "dev": true
                 },
                 "duplexer": {
                   "version": "0.1.1",
                   "resolved": "http://registry.npmjs.org/duplexer/-/duplexer-0.1.1.tgz",
                   "integrity": "sha1-rOb/gIwc5mtX0ev5eXessCM0z8E=",
                   "dev": true
                 },
                 "es-abstract": {
-                  "version": "1.12.0",
+                  "version": "1.13.0",
-                  "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.12.0.tgz",
+                  "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.13.0.tgz",
-                  "integrity": "sha512-C8Fx/0jFmV5IPoMOFPA9P9G5NtqW+4cOPit3MIuvR2t7Ag2K15EJTpxnHAYTzL+aYQJIESYeXZmDBfOBE1HcpA==",
+                  "integrity": "sha512-vDZfg/ykNxQVwup/8E1BZhVzFfBxs9NqMzGcvIJrqg5k2/5Za2bWo40dK2J1pgLngZ7c+Shh8lwYtLGyrwPutg==",
                   "dev": true,
                   "requires": {
-                    "es-to-primitive": "^1.1.1",
+                    "es-to-primitive": "^1.2.0",
                     "function-bind": "^1.1.1",
-                    "has": "^1.0.1",
+                    "has": "^1.0.3",
-                    "is-callable": "^1.1.3",
+                    "is-callable": "^1.1.4",
-                    "is-regex": "^1.0.4"
+                    "is-regex": "^1.0.4",
+                    "object-keys": "^1.0.12"
+                  },
+                  "dependencies": {
+                    "object-keys": {
+                      "version": "1.0.12",
+                      "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.0.12.tgz",
+                      "integrity": "sha512-FTMyFUm2wBcGHnH2eXmz7tC6IwlqQZ6mVZ+6dm6vZ4IQIHjs6FdNsQBuKGPuUUUY6NfJw2PshC08Tn6LzLDOag==",
+                      "dev": true
+                    }
                   }
                 },
                 "es-to-primitive": {
                   "version": "1.2.0",
                   "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.0.tgz",
                   "integrity": "sha512-qZryBOJjV//LaxLTV6UC//WewneB3LcXOL9NP++ozKVXsIIIpm/2c13UDiD9Jp2eThsecw9m3jPqDwTyobcdbg==",
                   "dev": true,
                   "requires": {
                     "is-callable": "^1.1.4",
                     "is-date-object": "^1.0.1",
                     "is-symbol": "^1.0.2"
                   }
                 },
                 "faucet": {
                   "version": "0.0.1",
                   "resolved": "https://registry.npmjs.org/faucet/-/faucet-0.0.1.tgz",
                   "integrity": "sha1-WX3PHSGJosBiMhtZHo8VHtIDnZw=",
                   "dev": true,
                   "requires": {
                     "defined": "0.0.0",
                     "duplexer": "~0.1.1",
                     "minimist": "0.0.5",
                     "sprintf": "~0.1.3",
                     "tap-parser": "~0.4.0",
                     "tape": "~2.3.2",
                     "through2": "~0.2.3"
                   },
                   "dependencies": {
                     "tape": {
                       "version": "2.3.3",
                       "resolved": "http://registry.npmjs.org/tape/-/tape-2.3.3.tgz",
                       "integrity": "sha1-Lnzgox3wn41oUWZKcYQuDKUFevc=",
                       "dev": true,
                       "requires": {
                         "deep-equal": "~0.1.0",
                         "defined": "~0.0.0",
                         "inherits": "~2.0.1",
                         "jsonify": "~0.0.0",
                         "resumer": "~0.0.0",
                         "through": "~2.3.4"
                       }
                     }
                   }
                 },
                 "for-each": {
                   "version": "0.3.3",
                   "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz",
                   "integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==",
                   "dev": true,
                   "requires": {
                     "is-callable": "^1.1.3"
                   }
                 },
                 "fs.realpath": {
                   "version": "1.0.0",
                   "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
                   "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=",
                   "dev": true
                 },
                 "function-bind": {
                   "version": "1.1.1",
                   "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz",
                   "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==",
                   "dev": true
                 },
                 "glob": {
                   "version": "7.1.3",
                   "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.3.tgz",
                   "integrity": "sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==",
                   "dev": true,
                   "requires": {
                     "fs.realpath": "^1.0.0",
                     "inflight": "^1.0.4",
                     "inherits": "2",
                     "minimatch": "^3.0.4",
                     "once": "^1.3.0",
                     "path-is-absolute": "^1.0.0"
                   }
                 },
                 "has": {
                   "version": "1.0.3",
                   "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
                   "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
                   "dev": true,
                   "requires": {
                     "function-bind": "^1.1.1"
                   }
                 },
                 "has-symbols": {
                   "version": "1.0.0",
                   "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.0.tgz",
                   "integrity": "sha1-uhqPGvKg/DllD1yFA2dwQSIGO0Q=",
                   "dev": true
                 },
                 "inflight": {
                   "version": "1.0.6",
                   "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
                   "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
                   "dev": true,
                   "requires": {
                     "once": "^1.3.0",
                     "wrappy": "1"
                   }
                 },
                 "inherits": {
                   "version": "2.0.3",
                   "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
                   "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=",
                   "dev": true
                 },
                 "is-callable": {
                   "version": "1.1.4",
                   "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.1.4.tgz",
                   "integrity": "sha512-r5p9sxJjYnArLjObpjA4xu5EKI3CuKHkJXMhT7kwbpUyIFD1n5PMAsoPvWnvtZiNz7LjkYDRZhd7FlI0eMijEA==",
                   "dev": true
                 },
                 "is-date-object": {
                   "version": "1.0.1",
                   "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.1.tgz",
                   "integrity": "sha1-mqIOtq7rv/d/vTPnTKAbM1gdOhY=",
                   "dev": true
                 },
                 "is-regex": {
                   "version": "1.0.4",
                   "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.0.4.tgz",
                   "integrity": "sha1-VRdIm1RwkbCTDglWVM7SXul+lJE=",
                   "dev": true,
                   "requires": {
                     "has": "^1.0.1"
                   }
                 },
                 "is-symbol": {
                   "version": "1.0.2",
                   "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.2.tgz",
                   "integrity": "sha512-HS8bZ9ox60yCJLH9snBpIwv9pYUAkcuLhSA1oero1UB5y9aiQpRA8y2ex945AOtCZL1lJDeIk3G5LthswI46Lw==",
                   "dev": true,
                   "requires": {
                     "has-symbols": "^1.0.0"
                   }
                 },
                 "isarray": {
                   "version": "0.0.1",
                   "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz",
                   "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=",
                   "dev": true
                 },
                 "jsonify": {
                   "version": "0.0.0",
                   "resolved": "https://registry.npmjs.org/jsonify/-/jsonify-0.0.0.tgz",
                   "integrity": "sha1-LHS27kHZPKUbe1qu6PUDYx0lKnM=",
                   "dev": true
                 },
                 "minimatch": {
                   "version": "3.0.4",
                   "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
                   "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
                   "dev": true,
                   "requires": {
                     "brace-expansion": "^1.1.7"
                   }
                 },
                 "minimist": {
                   "version": "0.0.5",
                   "resolved": "http://registry.npmjs.org/minimist/-/minimist-0.0.5.tgz",
                   "integrity": "sha1-16oye87PUY+RBqxrjwA/o7zqhWY=",
                   "dev": true
                 },
                 "object-inspect": {
                   "version": "1.6.0",
                   "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.6.0.tgz",
                   "integrity": "sha512-GJzfBZ6DgDAmnuaM3104jR4s1Myxr3Y3zfIyN4z3UdqN69oSRacNK8UhnobDdC+7J2AHCjGwxQubNJfE70SXXQ==",
                   "dev": true
                 },
                 "object-keys": {
                   "version": "0.4.0",
                   "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-0.4.0.tgz",
                   "integrity": "sha1-KKaq50KN0sOpLz2V8hM13SBOAzY=",
                   "dev": true
                 },
                 "once": {
                   "version": "1.4.0",
                   "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
                   "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
                   "dev": true,
                   "requires": {
                     "wrappy": "1"
                   }
                 },
                 "path-is-absolute": {
                   "version": "1.0.1",
                   "resolved": "http://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
                   "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=",
                   "dev": true
                 },
                 "path-parse": {
                   "version": "1.0.6",
                   "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz",
                   "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==",
                   "dev": true
                 },
                 "readable-stream": {
                   "version": "1.1.14",
                   "resolved": "http://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz",
                   "integrity": "sha1-fPTFTvZI44EwhMY23SB54WbAgdk=",
                   "dev": true,
                   "requires": {
                     "core-util-is": "~1.0.0",
                     "inherits": "~2.0.1",
                     "isarray": "0.0.1",
                     "string_decoder": "~0.10.x"
                   }
                 },
                 "requirejs": {
                   "version": "2.3.6",
                   "resolved": "https://registry.npmjs.org/requirejs/-/requirejs-2.3.6.tgz",
                   "integrity": "sha512-ipEzlWQe6RK3jkzikgCupiTbTvm4S0/CAU5GlgptkN5SO6F3u0UD0K18wy6ErDqiCyP4J4YYe1HuAShvsxePLg==",
                   "dev": true
                 },
                 "resolve": {
                   "version": "1.7.1",
                   "resolved": "http://registry.npmjs.org/resolve/-/resolve-1.7.1.tgz",
                   "integrity": "sha512-c7rwLofp8g1U+h1KNyHL/jicrKg1Ek4q+Lr33AL65uZTinUZHe30D5HlyN5V9NW0JX1D5dXQ4jqW5l7Sy/kGfw==",
                   "dev": true,
                   "requires": {
                     "path-parse": "^1.0.5"
                   }
                 },
                 "resumer": {
                   "version": "0.0.0",
                   "resolved": "https://registry.npmjs.org/resumer/-/resumer-0.0.0.tgz",
                   "integrity": "sha1-8ej0YeQGS6Oegq883CqMiT0HZ1k=",
                   "dev": true,
                   "requires": {
                     "through": "~2.3.4"
                   }
                 },
                 "sprintf": {
                   "version": "0.1.5",
                   "resolved": "https://registry.npmjs.org/sprintf/-/sprintf-0.1.5.tgz",
                   "integrity": "sha1-j4PjmpMXwaUCy324BQ5Rxnn27c8=",
                   "dev": true
                 },
                 "string.prototype.trim": {
                   "version": "1.1.2",
                   "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.1.2.tgz",
                   "integrity": "sha1-0E3iyJ4Tf019IG8Ia17S+ua+jOo=",
                   "dev": true,
                   "requires": {
                     "define-properties": "^1.1.2",
                     "es-abstract": "^1.5.0",
                     "function-bind": "^1.0.2"
                   }
                 },
                 "string_decoder": {
                   "version": "0.10.31",
                   "resolved": "http://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz",
                   "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=",
                   "dev": true
                 },
                 "tap-parser": {
                   "version": "0.4.3",
                   "resolved": "https://registry.npmjs.org/tap-parser/-/tap-parser-0.4.3.tgz",
                   "integrity": "sha1-pOrhkMENdsehEZIf84u+TVjwnuo=",
                   "dev": true,
                   "requires": {
                     "inherits": "~2.0.1",
                     "readable-stream": "~1.1.11"
                   }
                 },
                 "tape": {
-                  "version": "4.9.1",
+                  "version": "4.9.2",
-                  "resolved": "https://registry.npmjs.org/tape/-/tape-4.9.1.tgz",
+                  "resolved": "https://registry.npmjs.org/tape/-/tape-4.9.2.tgz",
-                  "integrity": "sha512-6fKIXknLpoe/Jp4rzHKFPpJUHDHDqn8jus99IfPnHIjyz78HYlefTGD3b5EkbQzuLfaEvmfPK3IolLgq2xT3kw==",
+                  "integrity": "sha512-lPXKRKILZ1kZaUy5ynWKs8ATGSUO7HAFHCFnBam6FaGSqPdOwMWbxXHq4EXFLE8WRTleo/YOMXkaUTRmTB1Fiw==",
                   "dev": true,
                   "requires": {
                     "deep-equal": "~1.0.1",
                     "defined": "~1.0.0",
                     "for-each": "~0.3.3",
                     "function-bind": "~1.1.1",
                     "glob": "~7.1.2",
                     "has": "~1.0.3",
                     "inherits": "~2.0.3",
                     "minimist": "~1.2.0",
                     "object-inspect": "~1.6.0",
                     "resolve": "~1.7.1",
                     "resumer": "~0.0.0",
                     "string.prototype.trim": "~1.1.2",
                     "through": "~2.3.8"
                   },
                   "dependencies": {
                     "deep-equal": {
                       "version": "1.0.1",
                       "resolved": "https://registry.npmjs.org/deep-equal/-/deep-equal-1.0.1.tgz",
                       "integrity": "sha1-9dJgKStmDghO/0zbyfCK0yR0SLU=",
                       "dev": true
                     },
                     "defined": {
                       "version": "1.0.0",
                       "resolved": "https://registry.npmjs.org/defined/-/defined-1.0.0.tgz",
                       "integrity": "sha1-yY2bzvdWdBiOEQlpFRGZ45sfppM=",
                       "dev": true
                     },
                     "minimist": {
                       "version": "1.2.0",
                       "resolved": "http://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
                       "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=",
                       "dev": true
                     }
                   }
                 },
                 "through": {
                   "version": "2.3.8",
                   "resolved": "http://registry.npmjs.org/through/-/through-2.3.8.tgz",
                   "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=",
                   "dev": true
                 },
                 "through2": {
                   "version": "0.2.3",
                   "resolved": "http://registry.npmjs.org/through2/-/through2-0.2.3.tgz",
                   "integrity": "sha1-6zKE2k6jEbbMis42U3SKUqvyWj8=",
                   "dev": true,
                   "requires": {
                     "readable-stream": "~1.1.9",
                     "xtend": "~2.1.1"
                   }
                 },
                 "tslib": {
                   "version": "1.9.3",
                   "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.9.3.tgz",
                   "integrity": "sha512-4krF8scpejhaOgqzBEcGM7yDIEfi0/8+8zDRZhNZZ2kjmHJ4hv3zCbQWxoJGz1iw5U0Jl0nma13xzHXcncMavQ==",
                   "dev": true
                 },
                 "typescript": {
                   "version": "3.2.2",
                   "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.2.2.tgz",
                   "integrity": "sha512-VCj5UiSyHBjwfYacmDuc/NOk4QQixbE+Wn7MFJuS0nRuPQbof132Pw4u53dm264O8LPc2MVsc7RJNml5szurkg==",
                   "dev": true
                 },
                 "wrappy": {
                   "version": "1.0.2",
                   "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
                   "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=",
                   "dev": true
                 },
                 "xtend": {
                   "version": "2.1.2",
                   "resolved": "https://registry.npmjs.org/xtend/-/xtend-2.1.2.tgz",
                   "integrity": "sha1-bv7MKk2tjmlixJAbM3znuoe10os=",
                   "dev": true,
                   "requires": {
                     "object-keys": "~0.4.0"
                   }
                 }
               }
             }

package.json +7 -7

             {
               "name": "@implab/core",
               "version": "0.0.1-dev",
               "description": "Dependency injection, logging, simple and fast text template engine",
               "main": "main.js",
               "keywords": [
                 "di",
                 "ioc",
                 "logging",
                 "template engine",
                 "dependency injection"
               ],
               "author": "Implab team",
               "license": "BSD-2-Clause",
               "repository": "https://bitbucket.org/implab/implabjs",
               "publishConfig": {
                 "access": "public"
               },
               "peerDependencies": {
                 "dojo": "^1.10.0",
                 "tslib": "latest"
               },
               "devDependencies": {
-                "typescript": "latest",
+                "@types/node": "latest",
-                "tape": "latest",
-                "@types/tape": "latest",
                 "@types/requirejs": "latest",
-                "@types/node": "latest",
+                "@types/tape": "latest",
-                "requirejs": "latest",
+                "dojo": "^1.10.0",
                 "faucet": "latest",
-                "dojo": "^1.10.0",
+                "requirejs": "latest",
-                "tslib": "latest"
+                "tape": "^4.9.2",
+                "tslib": "latest",
+                "typescript": "latest"
               },
               "types": "main.d.ts"
             }

src/amd/js/Uri.js +180 -176

@@ -1,232 +1,236
1	define(	1	define(["./declare", "./log/trace!"], function (declare, trace) {
2	[ "./declare" ],	2	trace.warn("THIS MODULE IS DEPRECATED! use uri-js or similar alternatives.");
3	function(declare) {	3
4	function parseURI(uri) {	4	function parseURI(uri) {
5	var schema, host, port, path, query, hash, i;	5	var schema, host, port, path, query, hash, i;
6	if (typeof (uri) == "string") {	6	if (typeof (uri) == "string") {
7	if ((i = uri.indexOf(":")) >= 0 &&	7	if ((i = uri.indexOf(":")) >= 0 &&
8	uri.substr(0, i).match(/^\w+$/)) {	8	uri.substr(0, i).match(/^\w+$/)) {
9	schema = uri.substr(0, i);	9	schema = uri.substr(0, i);
10	uri = uri.substr(i + 1);	10	uri = uri.substr(i + 1);
11	}	11	}
12		12
13	if (uri.indexOf("//") === 0) {	13	if (uri.indexOf("//") === 0) {
14	uri = uri.substr(2);	14	uri = uri.substr(2);
15	if ((i = uri.indexOf("/")) >= 0) {	15	if ((i = uri.indexOf("/")) >= 0) {
16	host = uri.substr(0, i);	16	host = uri.substr(0, i);
17	uri = uri.substr(i);	17	uri = uri.substr(i);
18	} else {	18	} else {
19	host = uri;	19	host = uri;
20	uri = "";	20	uri = "";
21	}
22	}	21	}
23		22	}
24	if ((i = uri.indexOf("?")) >= 0) {
25	path = uri.substr(0, i);
26	uri = uri.substr(i + 1);
27		23
28	} else {	24	if ((i = uri.indexOf("?")) >= 0) {
29	path = uri;	25	path = uri.substr(0, i);
30	uri = "";	26	uri = uri.substr(i + 1);
31		27
32	if ((i = path.indexOf("#")) >= 0) {	28	} else {
33	~~has~~h = ~~path~~.su~~bst~~r(i + 1);	29	path = uri;
34	path = path.substr(0, i);	30	uri = "";
35	}
36	}
37		31
38	if ((i = ~~uri~~.indexOf("#")) >= 0) {	32	if ((i = path.indexOf("#")) >= 0) {
39	~~query~~ = ~~uri~~.substr(0, i);	33	hash = path.substr(i + 1);
40	~~has~~h = ~~uri~~.substr(i + 1);	34	path = path.substr(0, i);
41	} else {
42	query = uri;
43	}	35	}
44	}	36	}
45		37
46	if (~~host~~ && (i = ~~host~~.~~lastI~~ndexOf(":")) >= 0) {	38	if ((i = uri.indexOf("#")) >= 0) {
47	~~port~~ = ~~host~~.substr(i + 1);	39	query = uri.substr(0, i);
48	h~~ost~~ = ~~host~~.substr(0, i);	40	hash = uri.substr(i + 1);
		41	} else {
		42	query = uri;
49	}	43	}
		44	}
50		45
51	return {	46	if (host && (i = host.lastIndexOf(":")) >= 0) {
52	schema : schema,	47	port = host.substr(i + 1);
53	host : host,	48	host = host.substr(0, i);
54	port : port,
55	path : path,
56	query : query,
57	hash : hash
58	};
59	}	49	}
60		50
61	function makeURI(options) {	51	return {
62	var uri = [];	52	schema: schema,
		53	host: host,
		54	port: port,
		55	path: path,
		56	query: query,
		57	hash: hash
		58	};
		59	}
63		60
64	if (options.schema)	61	function makeURI(options) {
65	uri.push(options.schema, ":");	62	var uri = [];
66	if (options.host)
67	uri.push("//", options.host);
68	if (options.host && options.port)
69	uri.push(":", options.port);
70		63
71	if (options.~~path~~) {	64	if (options.schema)
72	if (options.host && options.path[0] != "/")	65	uri.push(options.schema, ":");
73	uri.push("/");	66	if (options.host)
74	uri.push(options.~~pat~~h);	67	uri.push("//", options.host);
75	} ~~else~~ if (options.host) {	68	if (options.host && options.port)
		69	uri.push(":", options.port);
		70
		71	if (options.path) {
		72	if (options.host && options.path[0] != "/")
76	uri.push("/");	73	uri.push("/");
77	}	74	uri.push(options.path);
78		75	} else if (options.host) {
79	if (options.query)	76	uri.push("/");
80	uri.push("?", options.query);
81	if (options.hash)
82	uri.push("#", options.hash);
83
84	return uri.join("");
85	}	77	}
86		78
87	function reducePath(parts) {	79	if (options.query)
88	var balance = 0, result = [], isRoot;	80	uri.push("?", options.query);
		81	if (options.hash)
		82	uri.push("#", options.hash);
		83
		84	return uri.join("");
		85	}
89		86
90	for (var i = 0; i < parts.length; i++) {	87	function reducePath(parts) {
91	var part = parts[i];	88	var balance = 0,
92	switch (part) {	89	result = [],
		90	isRoot;
		91
		92	for (var i = 0; i < parts.length; i++) {
		93	var part = parts[i];
		94	switch (part) {
93	case "..":	95	case "..":
94	if (balance > 0) {	96	if (balance > 0) {
95	result.pop();	97	result.pop();
96	} else {	98	} else {
97	if (isRoot)	99	if (isRoot)
98	throw new Error("Unbalanced path: " + parts);	100	throw new Error("Unbalanced path: " + parts);
99		101
100	result.push(part);	102	result.push(part);
101	}	103	}
102	balance--;	104	balance--;
103	break;	105	break;
104	case ".":	106	case ".":
105	break;	107	break;
106	case "":	108	case "":
107	if (i === 0) {	109	if (i === 0) {
108	isRoot = true;	110	isRoot = true;
109	result.push(part);	111	result.push(part);
110	}	112	}
111	break;	113	break;
112	default:	114	default:
113	result.push(part);	115	result.push(part);
114	balance++;	116	balance++;
115	break;	117	break;
116	}
117	}	118	}
118
119	return result.join("/");
120	}	119	}
121		120
122	var meta = {	121	return result.join("/");
123	schema : null,	122	}
124	host : null,
125	port : null,
126	path : null,
127	query : null,
128	hash : null
129	};
130
131	var URI = declare(null, {
132	constructor : function(opts) {
133	if (typeof (opts) == "string")
134	opts = parseURI(opts);
135	for ( var p in meta)
136	if (p in opts)
137	this[p] = opts[p];
138	},
139
140	clone : function() {
141	return new URI(this);
142	},
143		123
144	combine : function(rel) {	124	var meta = {
145	var me = this;	125	schema: null,
146		126	host: null,
147	if (typeof (rel) === "string")	127	port: null,
148	rel = new URI(rel);	128	path: null,
149	else	129	query: null,
150	rel = rel.clone();	130	hash: null
151		131	};
152	// //some.host:123/path?q=a#123
153	if (rel.host)
154	return rel;
155		132
156	// /abs/path?q=a#123	133	var URI = declare(null, {
157	if (rel.path && rel.path[0] == "/") {	134	constructor: function (opts) {
158	if (me.host) {	135	trace.warn("This class is deprecated use uri-js or similar");
159	rel.schema = me.schema;	136	if (typeof (opts) == "string")
160	~~rel~~.~~host~~ = me.~~host~~;	137	opts = parseURI(opts);
161	rel.port = me.port;	138	for (var p in meta)
162	}	139	if (p in opts)
163	~~return~~ ~~rel~~;	140	this[p] = opts[p];
164	}	141	},
165
166	var base = me.clone();
167		142
168	// rel/path?a=b#cd	143	clone: function () {
169	if (rel.path) {	144	return new URI(this);
170	var segments = base.getSegments();	145	},
171	segments.pop();
172	segments.push.apply(segments, rel.getSegments());
173
174	base.path = reducePath(segments);
175	}
176		146
177	// ?q=a#123	147	combine: function (rel) {
178	if (rel.query)	148	var me = this;
179	base.query = rel.query;
180	if (rel.hash)
181	base.hase = rel.hash;
182		149
183	return base;	150	if (typeof (rel) === "string")
184	},	151	rel = new URI(rel);
185		152	else
186	optimize : function() {	153	rel = rel.clone();
187	this.path = reducePath(this.getSegments());
188	},
189		154
190	getSegments : function() {	155	// //some.host:123/path?q=a#123
191	if (typeof (this.path) === "string")	156	if (rel.host)
192	return ~~this~~.~~path~~.~~split~~(~~"/"~~);	157	return rel;
193	else
194	return [];
195	},
196
197	toString : function() {
198	var uri = [], me = this;
199		158
200	if (me.schema)	159	// /abs/path?q=a#123
201	uri.push(me.schema, ":");	160	if (rel.path && rel.path[0] == "/") {
202	if (me.host)	161	if (me.host) {
203	~~uri~~.~~push~~(~~"//"~~, me.~~host~~);	162	rel.schema = me.schema;
204	if (me.host && me.~~port~~)	163	rel.host = me.host;
205	~~uri~~.p~~ush~~(~~":"~~, me.port);	164	rel.port = me.port;
206
207	if (me.path) {
208	if (me.host && me.path[0] != "/")
209	uri.push("/");
210	uri.push(me.path);
211	} else if (me.host) {
212	uri.push("/");
213	}	165	}
214		166	return rel;
215	if (me.query)
216	uri.push("?", me.query);
217	if (me.hash)
218	uri.push("#", me.hash);
219
220	return uri.join("");
221	}	167	}
222		168
223	});	169	var base = me.clone();
		170
		171	// rel/path?a=b#cd
		172	if (rel.path) {
		173	var segments = base.getSegments();
		174	segments.pop();
		175	segments.push.apply(segments, rel.getSegments());
		176
		177	base.path = reducePath(segments);
		178	}
		179
		180	// ?q=a#123
		181	if (rel.query)
		182	base.query = rel.query;
		183	if (rel.hash)
		184	base.hase = rel.hash;
		185
		186	return base;
		187	},
		188
		189	optimize: function () {
		190	this.path = reducePath(this.getSegments());
		191	},
		192
		193	getSegments: function () {
		194	if (typeof (this.path) === "string")
		195	return this.path.split("/");
		196	else
		197	return [];
		198	},
224		199
225	~~URI~~.~~combine~~ = function(~~base~~, ~~rel~~) {	200	toString: function () {
226	if (typeof (base) === "string")	201	var uri = [],
227	~~bas~~e = ~~new~~ ~~URI~~(~~base~~);	202	me = this;
228	return base.combine(rel).toString();	203
229	};	204	if (me.schema)
		205	uri.push(me.schema, ":");
		206	if (me.host)
		207	uri.push("//", me.host);
		208	if (me.host && me.port)
		209	uri.push(":", me.port);
		210
		211	if (me.path) {
		212	if (me.host && me.path[0] != "/")
		213	uri.push("/");
		214	uri.push(me.path);
		215	} else if (me.host) {
		216	uri.push("/");
		217	}
230		218
231	return URI;	219	if (me.query)
232	}); No newline at end of file	220	uri.push("?", me.query);
		221	if (me.hash)
		222	uri.push("#", me.hash);
		223
		224	return uri.join("");
		225	}
		226
		227	});
		228
		229	URI.combine = function (base, rel) {
		230	if (typeof (base) === "string")
		231	base = new URI(base);
		232	return base.combine(rel).toString();
		233	};
		234
		235	return URI;
		236	}); No newline at end of file

src/amd/js/messaging/Session.js +188 -190

@@ -1,217 +1,215
1	define(	1	define([
2	[	2	"dojo/_base/declare",
3	"dojo/_base/declare",	3	"dojo/request",
4	"dojo/_base/lang",	4	"./Destination",
5	"dojo/~~request~~",	5	"dojo/Evented",
6	"./Destination",	6	"dojo/Deferred",
7	"dojo/Evented",	7	"../log/_LogMixin"
8	"dojo/Deferred",	8	], function (declare, request, Destination, Evented, Deferred, _LogMixin) {
9	"../log/_LogMixin" ],
10
11	function(declare, lang, request, Destination, Evented, Deferred, _LogMixin) {
12		9
13	var cls = declare(	10	var cls = declare(
14	[ Evented, _LogMixin ],	11	[Evented, _LogMixin], {
15	{	12	_id: null,
16	~~_id~~ : null,	13	_baseUrl: null,
17	~~_baseUrl~~ : null,	14	_destinations: null,
18	_destinations : null,	15	_timeout: 100000,
19	_timeout : 100000,	16	_clients: null,
20	~~_clients~~ : null,	17	_started: null,
21	_started : ~~null~~,	18	_starting: false,
22	_starting : false,
23		19
24	constructor : function(baseUrl, options) {	20	constructor: function (baseUrl, options) {
25	if (!baseUrl)	21	if (!baseUrl)
26	throw new Error("baseUrl is required");	22	throw new Error("baseUrl is required");
27	options = options \|\| {};	23	options = options \|\| {};
28		24
29	this._baseUrl = baseUrl.replace(/\/*$/, "");	25	this._baseUrl = baseUrl.replace(/\/*$/, "");
30	this._destinations = {};	26	this._destinations = {};
31	this._pending = [];	27	this._pending = [];
32	this._clients = {};	28	this._clients = {};
33	if (options.timeout)	29	if (options.timeout)
34	this._timeout = options.timeout;	30	this._timeout = options.timeout;
35		31
36	this._started = new Deferred();	32	this._started = new Deferred();
37	},	33	},
38
39	start : function() {
40	if (this._starting)
41	return this._started;
42	this._starting = true;
43		34
44	var me = this;	35	start: function () {
45	me.log("START");	36	if (this._starting)
46	re~~quest~~(this._~~baseUrl~~, {	37	return this._started;
47	method : "POST",	38	this._starting = true;
48	handleAs : "json"
49	}).then(function(result) {
50	me._id = result;
51	me._emitConnected();
52	me._poll();
53	me._started.resolve(me);
54	}, function(error) {
55	me._emitError(error);
56	me._started.reject(me);
57	});
58	return me._started.promise;
59	},
60
61	createClient : function(options) {
62	if (!options \|\| !options.destination \|\| !options.mode)
63	throw new Error("Invalid argument");
64
65	var me = this;
66
67	return me._started
68	.then(function() {
69	var url = me._makeUrl(me._id);
70	me.log(
71	"CREATE mode=${0}, destination=${1}",
72	options.mode,
73	options.destination);
74		39
75	return request(url, {	40	var me = this;
76	method : "POST",	41	me.log("START");
77	data : {	42	request(this._baseUrl, {
78	mode : options.mode,	43	method: "POST",
79	destination : options.destination	44	handleAs: "json"
80	},	45	}).then(function (result) {
81	handleAs : 'json'	46	me._id = result;
82	})	47	me._emitConnected();
83	.~~then~~(	48	me._poll();
84	function(id) {	49	me._started.resolve(me);
85	me	50	}, function (error) {
86	.log(	51	me._emitError(error);
87	"CLIENT id=${0}, mode=${1}, destination=${2}",	52	me._started.reject(me);
88	id,	53	});
89	options.mode,	54	return me._started.promise;
90	options.destination);	55	},
91	me._clients[id] = options.client
92	? options.client
93	: function(msg) {
94	me
95	.warn(
96	"The client id=${0}, mode=${1}, destination=${2} isn't accepting mesages",
97	id,
98	options.mode,
99	options.destination);
100	};
101	return id;
102	});
103	});
104		56
105	},	57	createClient: function (options) {
		58	if (!options \|\| !options.destination \|\| !options.mode)
		59	throw new Error("Invalid argument");
106		60
107	deleteClient : function(options) {	61	var me = this;
108	if (!options \|\| !options.clientId)
109	throw new Error("Invalid argument");
110		62
111	var me = this, id = options.clientId;	63	return me._started
112		64	.then(function () {
113	~~return~~ me._~~started~~.~~then~~(~~function~~() {	65	var url = me._makeUrl(me._id);
114	var url = me._makeUrl(me._id, options.clientId);	66	me.log(
115		67	"CREATE mode=${0}, destination=${1}",
116	me.~~log~~(~~"DELETE CLIENT ${0}"~~, options.~~clientId~~);	68	options.mode,
		69	options.destination);
117		70
118	return request(url, {	71	return request(url, {
119	method : "~~DELETE~~",	72	method: "POST",
120	~~handleAs~~ : ~~'json'~~	73	data: {
121	}).then(function() {	74	mode: options.mode,
122	me.log("CLIENT DELETED ${0}", options.clientId);	75	destination: options.destination
123	me.~~_clients~~[id] = ~~undefined~~;	76	},
124	~~});~~	77	handleAs: 'json'
		78	})
		79	.then(
		80	function (id) {
		81	me
		82	.log(
		83	"CLIENT id=${0}, mode=${1}, destination=${2}",
		84	id,
		85	options.mode,
		86	options.destination);
		87	me._clients[id] = options.client ?
		88	options.client :
		89	function (msg) {
		90	me
		91	.warn(
		92	"The client id=${0}, mode=${1}, destination=${2} isn't accepting mesages",
		93	id,
		94	options.mode,
		95	options.destination);
		96	};
		97	return id;
		98	});
125	});	99	});
126	},	100
		101	},
		102
		103	deleteClient: function (options) {
		104	if (!options \|\| !options.clientId)
		105	throw new Error("Invalid argument");
127		106
128	~~_poll~~ : ~~function~~() {	107	var me = this,
129	var me = this, url = this._makeUrl(this._id);	108	id = options.clientId;
130	me.log("POLL timeout=${0}", me._timeout);	109
131	request(url, {	110	return me._started.then(function () {
132	method : "GET",	111	var url = me._makeUrl(me._id, options.clientId);
133	handleAs : "json",	112
134	query : {	113	me.log("DELETE CLIENT ${0}", options.clientId);
135	timeout : me._timeout	114
136	}	115	return request(url, {
137	}).then(function(response) {	116	method: "DELETE",
138	me._handle~~Poll~~(~~response~~);	117	handleAs: 'json'
139	me.~~_poll~~();	118	}).then(function () {
140	}, function(err) {	119	me.log("CLIENT DELETED ${0}", options.clientId);
141	me.error("POLL faield with ${0}", err);	120	me._clients[id] = undefined;
142	me._emitError(err);
143	});	121	});
144	},	122	});
		123	},
145		124
146	~~_handlePoll~~ : function(~~response~~) {	125	_poll: function () {
147	if (!~~response~~) {	126	var me = this,
148	this.log("POLL response undefined, looks like a bug");	127	url = this._makeUrl(this._id);
149	return;	128	me.log("POLL timeout=${0}", me._timeout);
		129	request(url, {
		130	method: "GET",
		131	handleAs: "json",
		132	query: {
		133	timeout: me._timeout
150	}	134	}
151	if (!response.results \|\| !response.results.length) {	135	}).then(function (response) {
152	~~this~~.~~log~~(~~"POLL~~ response ~~is empty"~~);	136	me._handlePoll(response);
153	~~return~~;	137	me._poll();
154	}	138	}, function (err) {
155		139	me.error("POLL faield with ${0}", err);
156	var results = response.results;	140	me._emitError(err);
157	this.log("POLL got ${0} results", results.length);	141	});
		142	},
158		143
159	for (var i = 0; i < results.length; i++) {	144	_handlePoll: function (response) {
160	var result = results[i];	145	if (!response) {
161	var client = this._clients[result.clientId];	146	this.log("POLL response undefined, looks like a bug");
162	if (!~~client~~) {	147	return;
163	// TODO this could happen due to client isn't	148	}
164	// registered yet	149	if (!response.results \|\| !response.results.length) {
165	this.error("Unknown client ${0}", result.clientId);	150	this.log("POLL response is empty");
166	~~continue~~;	151	return;
167	}	152	}
168	client.call(this, result);	153
169	}	154	var results = response.results;
170	},	155	this.log("POLL got ${0} results", results.length);
171		156
172	_emitError : function(err) {	157	for (var i = 0; i < results.length; i++) {
173	this.emit("error", err);	158	var result = results[i];
174	},	159	var client = this._clients[result.clientId];
		160	if (!client) {
		161	// TODO this could happen due to client isn't
		162	// registered yet
		163	this.error("Unknown client ${0}", result.clientId);
		164	continue;
		165	}
		166	client.call(this, result);
		167	}
		168	},
175		169
176	~~_emitConnected~~ : function() {	170	_emitError: function (err) {
177	var me = this;	171	this.emit("error", err);
178	me.log("CONNECTED");	172	},
179	me.emit("connected");
180	},
181		173
182	~~_makeUrl~~ : function() {	174	_emitConnected: function () {
183	var ~~parts~~ = [ this.~~_baseUrl~~ ];	175	var me = this;
184	for (var i = 0; i < arguments.length; i++)	176	me.log("CONNECTED");
185	parts.push(arguments[i].replace(/\/*$/, ""));	177	me.emit("connected");
186	return parts.join('/');	178	},
187	},
188		179
189	~~queue~~ : function(~~name~~) {	180	_makeUrl: function () {
190	return this._getDestination("queue://" + name);	181	var parts = [this._baseUrl];
191	},	182	for (var i = 0; i < arguments.length; i++)
		183	parts.push(arguments[i].replace(/\/*$/, ""));
		184	return parts.join('/');
		185	},
192		186
193	~~topic~~ : function(name) {	187	queue: function (name) {
194	return this._getDestination("~~topic~~://" + name);	188	return this._getDestination("queue://" + name);
195	},	189	},
196		190
197	~~_getDestination~~ : function(~~uri~~) {	191	topic: function (name) {
198	if (~~uri~~ in this._~~destinations~~)	192	return this._getDestination("topic://" + name);
199	return this._destinations[uri];	193	},
200		194
201	var dest = new Destination(this, uri);	195	_getDestination: function (uri) {
202	this._destinations[~~uri~~] = ~~dest~~;	196	if (uri in this._destinations)
203	return dest;	197	return this._destinations[uri];
204	},	198
		199	var dest = new Destination(this, uri);
		200	this._destinations[uri] = dest;
		201	return dest;
		202	},
205		203
206	toString : function() {	204	toString: function () {
207	return [ "[", "SESSION ", this._id, "]" ].join(" ");	205	return ["[", "SESSION ", this._id, "]"].join(" ");
208	}	206	}
209	});	207	});
210		208
211	cls.connect = function(url, options) {	209	cls.connect = function (url, options) {
212	var session = new cls(url, options);	210	var session = new cls(url, options);
213	return session.start();	211	return session.start();
214	};	212	};
215		213
216	return cls;	214	return cls;
217	});	215	}); No newline at end of file

src/cjs/tsconfig.json +6 -1

             {
                 "extends": "../tsconfig",
                 "compilerOptions": {
                     "types": [
-                        "@types/node"
+                        "node"
+                    ],
+                    "rootDir": "ts",
+                    "rootDirs": [
+                        "ts",
+                        "../typings/main"
                     ]
                 },
                 "include": [
                     "ts/**/*.ts"
                 ]
             }

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) => void;
+                _cancel: (e: any) => void;
                 _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;
                         }
                     };
                     return this._completion = guard();
                 }
-                cancel(reason) {
+                cancel(reason: any) {
                     if (this._cancel)
                         this._cancel(reason);
                 }
             }

src/main/ts/di.ts +1 0

	@@ -0,0 +1,1
				1	export { Container } from "./di/Container";

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

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

src/main/ts/di/Configuration.ts +41 -24

             import {
                 ServiceRegistration,
                 TypeRegistration,
                 FactoryRegistration,
                 ServiceMap,
                 isDescriptor,
                 isDependencyRegistration,
                 DependencyRegistration,
                 ValueRegistration,
                 ActivationType,
                 isValueRegistration,
                 isTypeRegistration,
                 isFactoryRegistration
             } 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");
             declare const define;
             declare const require;
+            declare const module;
             function hasAmdLoader() {
-                return (typeof define === "function" && define.amd);
+                try {
+                    // es6 may throw the exception
+                    return (typeof define === "function" && define.amd);
+                } catch {
+                    return false;
+                }
+            }
+            function hasNodeJs() {
+                try {
+                    return (typeof module !== "undefined" && module.exports);
+                } catch {
+                    return false;
+                }
             }
             async function mapAll(data: object | any[], map?: (v, k) => 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;
                 }
             }
-            type Resolver = (qname: string) => any;
+            export type ModuleResolver = (moduleName: string, ct?: ICancellation) => any;
             type _key = string | number;
             export class Configuration {
                 _hasInnerDescriptors = false;
                 _container: Container;
                 _path: Array<_key>;
                 _configName: string;
-                _require: Resolver;
+                _require: ModuleResolver;
                 constructor(container: Container) {
                     argumentNotNull(container, container);
                     this._container = container;
                     this._path = [];
                 }
-                async loadConfiguration(moduleName: string, ct = Cancellation.none) {
+                async loadConfiguration(moduleName: string, contextRequire?: any, ct = Cancellation.none) {
                     argumentNotEmptyString(moduleName, "moduleName");
-                    // TODO remove the code below somewehere else
-                    if (hasAmdLoader()) {
+                    trace.log("loadConfiguration moduleName={0}", moduleName);
-                        // if we have a requirejs loader, use it directly
-                        // don't rely on typescript 'import' function
+                    this._configName = moduleName;
-                        const m = await new Promise<any>(cb => require(["./RequireJsHelper"], cb));
-                        const r = m.makeResolver(require);
+                    const r = makeResolver(null, contextRequire);
-                        const config = await r(moduleName);
-                        return this.applyConfiguration(
+                    const config = await r(moduleName, ct);
-                            config,
-                            m.makeResolver(await m.createContextRequire(moduleName))
+                    await this._applyConfiguration(
-                        );
+                        config,
-                    } else {
+                        makeResolver(moduleName, contextRequire),
-                        throw new Error("This feature is supported only with the amd loader");
+                        ct
+                    );
                 }
-                async applyConfiguration(data: object, resolver?: Resolver, ct = Cancellation.none) {
+                applyConfiguration(data: object, contextRequire?: any, ct = Cancellation.none) {
                     argumentNotNull(data, "data");
+                    return this._applyConfiguration(data, 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;
                     try {
                         services = await this._visitRegistrations(data, "$");
                     } catch (e) {
                         throw this._makeError(e);
                     }
                     this._container.register(services);
                 }
                 _makeError(inner) {
                     const e = new ConfigError("Failed to load configuration", inner);
                     e.configName = this._configName;
                     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;
                     }
                 }
-                async _loadModule(moduleName: string) {
+                _loadModule(moduleName: string) {
                     trace.debug("loadModule {0}", moduleName);
-                    const m = await this._require(moduleName);
+                    return this._require(moduleName);
-                    return m;
                 }
                 async _visitRegistrations(data, name: _key) {
                     this._enter(name);
                     if (data.constructor &&
                         data.constructor.prototype !== Object.prototype)
                         throw new Error("Configuration must be a simple object");
                     const o: ServiceMap = {};
                     const keys = Object.keys(data);
                     const services = await mapAll(data, async (v, k) => {
                         const d = await this._visit(v, k);
                         return isDescriptor(d) ? d : new AggregateDescriptor(d);
                     }) as ServiceMap;
                     this._leave();
                     return services;
                 }
                 _enter(name: _key) {
                     this._path.push(name);
                     trace.debug(">{0}", name);
                 }
                 _leave() {
                     const name = this._path.pop();
                     trace.debug("<{0}", name);
                 }
-                async _visit(data, name: string): Promise<any> {
+                _visit(data, name: string): Promise<any> {
                     if (isPrimitive(data) || isDescriptor(data))
                         return data;
                     if (isDependencyRegistration(data)) {
                         return this._visitDependencyRegistration(data, name);
                     } else if (isValueRegistration(data)) {
                         return this._visitValueRegistration(data, name);
                     } else if (isTypeRegistration(data)) {
                         return this._visitTypeRegistration(data, name);
                     } else if (isFactoryRegistration(data)) {
                         return this._visitFactoryRegistration(data, name);
                     } else if (data instanceof Array) {
                         return this._visitArray(data, name);
                     }
                     return this._visitObject(data, name);
                 }
                 async _visitObject(data: object, name: _key) {
                     if (data.constructor &&
                         data.constructor.prototype !== Object.prototype)
                         return new ValueDescriptor(data);
                     this._enter(name);
                     const v = await mapAll(data, delegate(this, "_visit"));
                     // TODO: handle inline descriptors properly
                     // const ex = {
                     //     activate(ctx) {
                     //         const value = ctx.activate(this.prop, "prop");
                     //         // some code
                     //     },
                     //     // will be turned to ReferenceDescriptor
                     //     prop: { $dependency: "depName" }
                     // };
                     this._leave();
                     return v;
                 }
                 async _visitArray(data: any[], name: _key) {
                     if (data.constructor &&
                         data.constructor.prototype !== Array.prototype)
                         return new ValueDescriptor(data);
                     this._enter(name);
                     const v = await mapAll(data, delegate(this, "_visit"));
                     this._leave();
                     return v;
                 }
                 _makeServiceParams(data: ServiceRegistration) {
                     const opts: any = {
                         owner: this._container
                     };
                     if (data.services)
                         opts.services = this._visitRegistrations(data.services, "services");
                     if (data.inject) {
                         this._path.push("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(data: ValueRegistration, name: _key) {
                     this._enter(name);
                     const d = data.parse ? new AggregateDescriptor(data.$value) : new ValueDescriptor(data.$value);
                     this._leave();
                     return d;
                 }
                 async _visitDependencyRegistration(data: DependencyRegistration, name: _key) {
                     argumentNotEmptyString(data && data.$dependency, "data.$dependency");
                     this._enter(name);
                     const d = new ReferenceDescriptor({
                         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(data: TypeRegistration, name: _key) {
                     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(data: FactoryRegistration, name: _key) {
                     argumentOfType(data.$factory, Function, "data.$type");
                     this._enter(name);
                     const opts = this._makeServiceParams(data);
                     opts.factory = opts.$factory;
                     const d = new FactoryServiceDescriptor(
                         await mapAll(opts)
                     );
                     this._leave();
                     return d;
                 }
             }

src/main/ts/di/Container.ts +2 -2

             import { ActivationContext } from "./ActivationContext";
             import { ValueDescriptor } from "./ValueDescriptor";
             import { ActivationError } from "./ActivationError";
             import { isDescriptor, ServiceMap } from "./interfaces";
             import { TraceSource } from "../log/TraceSource";
             import { Configuration } from "./Configuration";
             import { Cancellation } from "../Cancellation";
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
             export class Container {
                 _services: ServiceMap;
                 _cache: object;
                 _cleanup: (() => void)[];
                 _root: Container;
                 _parent: Container;
                 constructor(parent?: Container) {
                     this._parent = parent;
                     this._services = parent ? Object.create(parent._services) : {};
                     this._cache = {};
                     this._cleanup = [];
                     this._root = parent ? parent.getRootContainer() : this;
                     this._services.container = new ValueDescriptor(this);
                 }
                 getRootContainer() {
                     return this._root;
                 }
                 getParent() {
                     return this._parent;
                 }
                 resolve(name: string, def?) {
                     trace.debug("resolve {0}", name);
                     const d = this._services[name];
                     if (d === undefined) {
                         if (arguments.length > 1)
                             return def;
                         else
                             throw new Error("Service '" + name + "' isn't found");
                     }
                     const context = new ActivationContext(this, this._services);
                     try {
                         return context.activate(d, name);
                     } catch (error) {
                         throw new ActivationError(name, context.getStack(), error);
                     }
                 }
                 /**
                  * @deprecated use resolve() method
                  */
                 getService() {
                     return this.resolve.apply(this, arguments);
                 }
                 register(nameOrCollection, service?) {
                     if (arguments.length === 1) {
                         const data = nameOrCollection;
                         for (const name in data)
                             this.register(name, data[name]);
                     } else {
                         if (!isDescriptor(service))
                             throw new Error("The service parameter must be a descriptor");
                         this._services[nameOrCollection] = service;
                     }
                     return this;
                 }
                 onDispose(callback) {
                     if (!(callback instanceof Function))
                         throw new Error("The callback must be a function");
                     this._cleanup.push(callback);
                 }
                 dispose() {
                     if (this._cleanup) {
                         for (const f of this._cleanup)
                             f();
                         this._cleanup = null;
                     }
                 }
                 /**
                  * @param{String|Object} config
                  *  The configuration of the contaier. Can be either a string or an object,
                  *  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?, ct = Cancellation.none) {
+                async configure(config: string | object, opts?: any, ct = Cancellation.none) {
                     const c = new Configuration(this);
                     if (typeof (config) === "string") {
-                        return c.loadConfiguration(config, ct);
+                        return c.loadConfiguration(config, opts && opts.contextRequire, ct);
                     } else {
                         return c.applyConfiguration(config, opts && opts.contextRequire, ct);
                     }
                 }
                 createChildContainer() {
                     return new Container(this);
                 }
                 has(id) {
                     return id in this._cache;
                 }
                 get(id) {
                     return this._cache[id];
                 }
                 store(id, value) {
                     return (this._cache[id] = value);
                 }
             }

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

             export type Constructor<T = {}> = new (...args: any[]) => 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();
             }
             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);
                 /**
                  * 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>;
                 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>;
             }

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

             import { Observable } from "../Observable";
             import { Registry } from "./Registry";
             import { format } from "../text/StringFormat";
             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 arg: any;
             }
             export class TraceSource {
                 readonly id: any;
                 level: number;
                 readonly events: Observable<TraceEvent>;
                 _notifyNext: (arg: TraceEvent) => void;
                 constructor(id: any) {
                     this.id = id || new Object();
                     this.events = new Observable(next => {
                         this._notifyNext = next;
                     });
                 }
                 protected emit(level: number, arg: any) {
                     this._notifyNext({ source: this, level, arg });
                 }
                 isDebugEnabled() {
                     return this.level >= DebugLevel;
                 }
                 debug(msg: string, ...args: any[]) {
                     if (this.isEnabled(DebugLevel))
-                        this.emit(DebugLevel, format(msg, args));
+                        this.emit(DebugLevel, format.apply(null, arguments));
                 }
                 isLogEnabled() {
                     return this.level >= LogLevel;
                 }
                 log(msg: string, ...args: any[]) {
                     if (this.isEnabled(LogLevel))
-                        this.emit(LogLevel, format(msg, args));
+                        this.emit(LogLevel, format.apply(null, arguments));
                 }
                 isWarnEnabled() {
                     return this.level >= WarnLevel;
                 }
                 warn(msg: string, ...args: any[]) {
                     if (this.isEnabled(WarnLevel))
-                        this.emit(WarnLevel, format(msg, args));
+                        this.emit(WarnLevel, format.apply(null, arguments));
                 }
                 /**
                  * returns true if errors will be recorded.
                  */
                 isErrorEnabled() {
                     return this.level >= ErrorLevel;
                 }
                 /**
                  * Traces a error.
                  *
                  * @param msg the message.
                  * @param args parameters which will be substituted in the message.
                  */
                 error(msg: string, ...args: any[]) {
                     if (this.isEnabled(ErrorLevel))
                         this.emit(ErrorLevel, format.apply(null, arguments));
                 }
                 /**
                  * 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 arg the data of the event, can be a simple string or any object.
                  */
                 traceEvent(level: number, arg: any) {
                     if (this.isEnabled(level))
                         this.emit(level, arg);
                 }
                 /**
                  * 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/ConsoleWriter.ts +17 -4

             import { IObservable, IDestroyable, ICancellation } from "../../interfaces";
             import { TraceEvent, LogLevel, WarnLevel, DebugLevel } from "../TraceSource";
             import { Cancellation } from "../../Cancellation";
             import { destroy } from "../../safe";
+            function hasConsole() {
+                try {
+                    // tslint:disable-next-line:no-console
+                    return (typeof console !== "undefined" && typeof console.log === "function");
+                } catch {
+                    return false;
+                }
+            }
             export class ConsoleWriter implements IDestroyable {
                 readonly _subscriptions = new Array<IDestroyable>();
                 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) {
+                    // IE will create console only when devepoler tools are activated
+                    if (!hasConsole())
+                        return;
                     if (next.level >= DebugLevel) {
-                        // tslint:disable-next-line
+                        // tslint:disable-next-line:no-console
                         console.debug(next.source.id.toString(), next.arg);
                     } else if (next.level >= LogLevel) {
-                        // tslint:disable-next-line
+                        // tslint:disable-next-line:no-console
                         console.log(next.source.id.toString(), next.arg);
                     } else if (next.level >= WarnLevel) {
-                        // tslint:disable-next-line
+                        // tslint:disable-next-line:no-console
                         console.warn(next.source.id.toString(), next.arg);
                     } else {
-                        // tslint:disable-next-line
+                        // tslint:disable-next-line:no-console
                         console.error(next.source.id.toString(), next.arg);
                     }
                 }
                 destroy() {
                     this._subscriptions.forEach(destroy);
                 }
             }

src/test/ts/ContainerTests.ts +1 -2

-            import { test, TapeWriter } from "./TestTraits";
+            import { test } from "./TestTraits";
             import { Container } from "@implab/core/di/Container";
             import { ReferenceDescriptor } from "@implab/core/di/ReferenceDescriptor";
             import { AggregateDescriptor } from "@implab/core/di/AggregateDescriptor";
             import { ValueDescriptor } from "@implab/core/di/ValueDescriptor";
-            import { TraceSource, DebugLevel } from "@implab/core/log/TraceSource";
             import { Foo } from "./mock/Foo";
             import { Bar } from "./mock/Bar";
             import { isNull } from "@implab/core/safe";
             test("Container register/resolve tests", async t => {
                 const container = new Container();
                 const connection1 = "db://localhost";
                 t.throws(
                     () => container.register("bla-bla", "bla-bla"),
                     "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("test/mock/config1");
                 t.pass("The configuration should load");
                 const f1 = container.resolve("foo");
                 t.assert(!isNull(f1), "foo should be not null");
                 const b1 = container.resolve("bar") as Bar;
                 t.assert(!isNull(b1), "bar should not be null");
                 t.assert(!isNull(b1.foo), "bar.foo should not be null");
             });

src/test/ts/TestTraits.ts +4 -5

             import { IObservable, ICancellation, IDestroyable } from "@implab/core/interfaces";
             import { Cancellation } from "@implab/core/Cancellation";
             import { TraceEvent, LogLevel, WarnLevel, DebugLevel, TraceSource } from "@implab/core/log/TraceSource";
             import * as tape from "tape";
-            import { argumentNotNull } from "@implab/core/safe";
+            import { argumentNotNull, destroy } from "@implab/core/safe";
             export class TapeWriter implements IDestroyable {
                 readonly _tape: tape.Test;
                 _subscriptions = new Array<IDestroyable>();
                 constructor(t: tape.Test) {
                     argumentNotNull(t, "tape");
                     this._tape = t;
                 }
                 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._tape.comment(`DEBUG ${next.source.id} ${next.arg}`);
                     } else if (next.level >= LogLevel) {
                         this._tape.comment(`LOG   ${next.source.id} ${next.arg}`);
                     } else if (next.level >= WarnLevel) {
                         this._tape.comment(`WARN  ${next.source.id} ${next.arg}`);
                     } else {
                         this._tape.comment(`ERROR ${next.source.id} ${next.arg}`);
                     }
                 }
                 destroy() {
-                    this._subscriptions.forEach(x => x.destroy());
+                    this._subscriptions.forEach(destroy);
                 }
             }
             export async function delay(timeout: number, ct: ICancellation = Cancellation.none) {
                 let un: IDestroyable;
                 try {
                     await new Promise((resolve, reject) => {
                         if (ct.isRequested()) {
                             un = ct.register(reject);
                         } else {
                             const ht = setTimeout(() => {
                                 resolve();
                             }, timeout);
                             un = ct.register(e => {
                                 clearTimeout(ht);
                                 reject(e);
                             });
                         }
                     });
                 } finally {
-                    if (un)
+                    destroy(un);
-                        un.destroy();
                 }
             }
             export function test(name: string, cb: (t: tape.Test) => any) {
                 tape(name, async t => {
                     const writer = new TapeWriter(t);
                     TraceSource.on(ts => {
                         ts.level = DebugLevel;
                         writer.writeEvents(ts.events);
                     });
                     try {
                         await cb(t);
                     } catch (e) {
                         // verbose error information
                         // tslint:disable-next-line
                         console.error(e);
                         t.fail(e);
                     } finally {
                         t.end();
-                        writer.destroy();
+                        destroy(writer);
                     }
                 });
             }

src/test/tsconfig.json +1 -1

             {
                 "extends": "../tsconfig",
                 "compilerOptions": {
                     "rootDir": "ts",
                     "baseUrl": ".",
                     "paths": {
                         "@implab/core/*": [
-                            "../../build/dist/amd/*"
+                            "../../build/dist/*"
                         ]
                     }
                 },
                 "include" : [
                     "ts/**/*.ts"
                 ]
             }

src/tsconfig.json +2 -10

             {
                 "compilerOptions": {
-                    "target": "es3",
-                    "sourceMap": true,
-                    "declaration": true,
                     "moduleResolution": "node",
                     "noEmitOnError": true,
                     "listFiles": true,
-                    "lib": [
+                    "types": [],
-                        "es5",
+                    "lib": ["es5", "es2015.promise", "es2015.symbol", "dom", "scripthost"]
-                        "es2015.promise",
-                        "es2015.symbol",
-                        "dom"
-                    ],
-                    "types": []
                 },
                 "files": []
             }

.project removed 0 -17

NO CONTENT: file was removed

src/amd/js/data/ObjectStore.js removed 0 -174

	1	NO CONTENT: file was removed			NO CONTENT: file was removed

NO CONTENT: file was removed

src/amd/js/data/StatefullStoreAdapter.js removed 0 -19

	1	NO CONTENT: file was removed			NO CONTENT: file was removed

NO CONTENT: file was removed

src/amd/js/data/declare-model.js removed 0 -72

	1	NO CONTENT: file was removed			NO CONTENT: file was removed

NO CONTENT: file was removed

src/amd/js/declare/_load.js removed 0 -12

NO CONTENT: file was removed

src/amd/js/log/trace.js removed 0 -52

NO CONTENT: file was removed

src/amd/ts/di/RequireJsHelper.ts removed 0 -41

NO CONTENT: file was removed

src/cjs/ts/di/CommonJsHelper.ts removed 0 -3

NO CONTENT: file was removed

src/main/ts/text/TemplateCompiler.ts removed 0 -102

NO CONTENT: file was removed

src/main/ts/text/TemplateParser.ts removed 0 -64

NO CONTENT: file was removed

src/package.template.json removed 0 -23

NO CONTENT: file was removed

src/test/js/example.js removed 0 -7

NO CONTENT: file was removed

src/test/js/mock/config1.js removed 0 -20

NO CONTENT: file was removed

src/test/js/plan.js removed 0 -8

NO CONTENT: file was removed

src/test/js/run-amd-tests.js removed 0 -22

NO CONTENT: file was removed

src/test/js/trace-test.js removed 0 -30

NO CONTENT: file was removed

General Comments 0

Write
Preview

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

No TODOs yet

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

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