implab/implabjs-core Commit - r57:c981b10db77f

Merge with di-typescript

cin -

r57:c981b10db77f default

parent child

Context file:

r57:c981b10db77f

Expand all files

.project created 644 +17 0

			@@ -0,0 +1,17
		1	<?xml version="1.0" encoding="UTF-8"?>
		2	<projectDescription>
		3	<name>core</name>
		4	<comment>Project core created by Buildship.</comment>
		5	<projects>
		6	</projects>
		7	<buildSpec>
		8	<buildCommand>
		9	<name>org.eclipse.buildship.core.gradleprojectbuilder</name>
		10	<arguments>
		11	</arguments>
		12	</buildCommand>
		13	</buildSpec>
		14	<natures>
		15	<nature>org.eclipse.buildship.core.gradleprojectnature</nature>
		16	</natures>
		17	</projectDescription>

.settings/org.eclipse.buildship.core.prefs created 644 +2 0

			@@ -0,0 +1,2
		1	connection.project.dir=
		2	eclipse.preferences.version=1

.vscode/settings.json created 644 +15 0

			@@ -0,0 +1,15
		1	{
		2	"java.configuration.updateBuildConfiguration": "disabled",
		3	"tslint.enable": true,
		4	"search.exclude": {
		5	"**/node_modules": true,
		6	"**/bower_components": true,
		7	"/build": true
		8	},
		9	"files.watcherExclude": {
		10	"/.git/objects/": true,
		11	"/.git/subtree-cache/": true,
		12	"/node_modules/": true,
		13	"/build": true
		14	}
		15	} No newline at end of file

src/amd/ts/di/RequireJsHelper.ts created 644 +41 0

			@@ -0,0 +1,41
		1	import { Uuid } from "../Uuid";
		2	import { argumentNotEmptyString, argumentNotNull } from "../safe";
		3	import { TraceSource } from "../log/TraceSource";
		4	import m = require("module");
		5
		6	const trace = TraceSource.get(m.id);
		7
		8	export async function createContextRequire(moduleName: string): Promise<Require> {
		9	argumentNotEmptyString(moduleName, "moduleName");
		10
		11	const parts = moduleName.split("/");
		12	if (parts[0] === ".")
		13	throw new Error("An absolute module path is required");
		14
		15	if (parts.length > 1)
		16	parts.splice(-1, 1, Uuid());
		17	else
		18	parts.push(Uuid());
		19
		20	const shim = parts.join("/");
		21
		22	trace.debug(`define shim ${shim}`);
		23
		24	return new Promise<Require>(cb => {
		25	define(shim, ["require"], r => {
		26	trace.debug("shim resolved");
		27	return r;
		28	});
		29	require([shim], cb);
		30	});
		31	}
		32
		33	export function makeResolver(req: Require) {
		34	argumentNotNull(req, "req");
		35
		36	return (name: string) => {
		37	return new Promise<any>((cb, eb) => {
		38	req([name], cb, eb);
		39	});
		40	};
		41	}

src/amd/ts/text/format-compile.ts created 644 +8 0

			@@ -0,0 +1,8
		1	import * as module from "module";
		2	import { TraceSource } from "../log/TraceSource";
		3
		4	const logger = TraceSource.get(module.id);
		5
		6	logger.warn("The module is deprecated, use StringFormat.compile() method directly");
		7
		8	export { compile } from "./StringFormat";

src/amd/ts/text/format.ts created 644 +47 0

			@@ -0,0 +1,47
		1	import { format as dojoFormatNumber } from "dojo/number";
		2	import { format as dojoFormatDate } from "dojo/date/locale";
		3	import { Formatter } from "./StringFormat";
		4
		5	import { isNumber } from "../safe";
		6
		7	interface NumberFormatOptions {
		8	round?: number;
		9	pattern?: string;
		10	}
		11
		12	function convertNumber(value: any, pattern: string) {
		13	if (isNumber(value)) {
		14	const nopt = {} as NumberFormatOptions;
		15	if (pattern.indexOf("!") === 0) {
		16	nopt.round = -1;
		17	pattern = pattern.substr(1);
		18	}
		19	nopt.pattern = pattern;
		20
		21	return dojoFormatNumber(value, nopt);
		22	}
		23	}
		24
		25	function convertDate(value: any, pattern: string) {
		26	if (value instanceof Date) {
		27	const m = pattern.match(/^(\w+)-(\w+)$/);
		28	if (m)
		29	return dojoFormatDate(value, {
		30	selector: m[2],
		31	formatLength: m[1]
		32	});
		33	else if (pattern === "iso")
		34	return value.toISOString();
		35	else
		36	return dojoFormatDate(value, {
		37	selector: "date",
		38	datePattern: pattern
		39	});
		40	}
		41	}
		42
		43	const _formatter = new Formatter([convertNumber, convertDate]);
		44
		45	export = function format(msg: string, ...args: any[]) {
		46	return _formatter.format.apply(msg, ...args);
		47	};

src/amd/ts/text/template-compile.ts created 644 +49 0

			@@ -0,0 +1,49
		1	import request = require("dojo/request");
		2	import m = require("module");
		3	import { TraceSource } from "../log/TraceSource";
		4	import { TemplateCompiler } from "./TemplateCompiler";
		5	import { TemplateParser } from "./TemplateParser";
		6	import { isNullOrEmptyString } from "../safe";
		7	import { MapOf } from "../interfaces";
		8
		9	type TemplateFn = (obj: object) => string;
		10
		11	const trace = TraceSource.get(m.id);
		12
		13	function compile(str: string) {
		14	if (isNullOrEmptyString(str))
		15	return () => "";
		16
		17	const parser = new TemplateParser(str);
		18	const compiler = new TemplateCompiler();
		19
		20	return compiler.compile(parser);
		21	}
		22
		23	const cache: MapOf<TemplateFn> = {};
		24
		25	interface OnLoadFn<T> {
		26	(res: T): void;
		27	error(e: any): void;
		28	}
		29
		30	compile.load = (id: string, require: Require, callback: OnLoadFn<TemplateFn>) => {
		31	const url = require.toUrl(id);
		32	if (url in cache) {
		33	trace.debug("{0} -> {1}: cached", id, url);
		34	callback(cache[url]);
		35	} else {
		36	trace.debug("{0} -> {1}: load", id, url);
		37	request(url).then(compile).then((tc: TemplateFn) => {
		38	trace.debug("{0}: compiled", url);
		39	callback(cache[url] = tc);
		40	}, (err: any) => {
		41	callback.error({
		42	inner: err,
		43	src: "@implab/core/text/template-compile"
		44	});
		45	});
		46	}
		47	};
		48
		49	export = compile;

src/amd/tsconfig.json created 644 +16 0

			@@ -0,0 +1,16
		1	{
		2	"extends": "../tsconfig",
		3	"compilerOptions": {
		4	"types": [
		5	"requirejs"
		6	],
		7	"rootDir": "ts",
		8	"rootDirs": [
		9	"ts",
		10	"../typings/main"
		11	]
		12	},
		13	"include": [
		14	"ts/*/.ts"
		15	]
		16	} No newline at end of file

src/cjs/ts/di/CommonJsHelper.ts created 644 +3 0

			@@ -0,0 +1,3
		1	export function createContextResolver(moduleName: string) {
		2	return (m: string) => { };
		3	}

src/cjs/tsconfig.json created 644 +11 0

			@@ -0,0 +1,11
		1	{
		2	"extends": "../tsconfig",
		3	"compilerOptions": {
		4	"types": [
		5	"@types/node"
		6	]
		7	},
		8	"include": [
		9	"ts/*/.ts"
		10	]
		11	} No newline at end of file

src/main/ts/di.ts created 644 0 0

NO CONTENT: new file 100644

src/main/ts/di/ActivationContext.ts created 644 +132 0

			@@ -0,0 +1,132
		1	import { TraceSource } from "../log/TraceSource";
		2	import { argumentNotNull, argumentNotEmptyString, isPrimitive, each, isNull } from "../safe";
		3	import { Descriptor, ServiceMap } from "./interfaces";
		4	import { Container } from "./Container";
		5
		6	const trace = TraceSource.get("@implab/core/di/ActivationContext");
		7
		8	export interface ActivationContextInfo {
		9	name: string;
		10
		11	service: string;
		12
		13	scope: ServiceMap;
		14	}
		15
		16	export class ActivationContext {
		17	_cache: object;
		18
		19	_services: ServiceMap;
		20
		21	_stack: ActivationContextInfo[];
		22
		23	_visited: object;
		24
		25	_name: string;
		26
		27	_localized: boolean;
		28
		29	container: Container;
		30
		31	constructor(container: Container, services: ServiceMap, name?: string, cache?: object, visited?) {
		32	argumentNotNull(container, "container");
		33	argumentNotNull(services, "services");
		34
		35	this._name = name;
		36	this._visited = visited \|\| {};
		37	this._stack = [];
		38	this._cache = cache \|\| {};
		39	this._services = services;
		40	this.container = container;
		41	}
		42
		43	getName() {
		44	return this._name;
		45	}
		46
		47	resolve(name, def?): any {
		48	const d = this._services[name];
		49
		50	if (!d)
		51	if (arguments.length > 1)
		52	return def;
		53	else
		54	throw new Error(`Service ${name} not found`);
		55
		56	return this.activate(d, name);
		57	}
		58
		59	/**
		60	* registers services local to the the activation context
		61	*
		62	* @name{string} the name of the service
		63	* @service{string} the service descriptor to register
		64	*/
		65	register(name: string, service: Descriptor) {
		66	argumentNotEmptyString(name, "name");
		67
		68	this._services[name] = service;
		69	}
		70
		71	clone() {
		72	return new ActivationContext(
		73	this.container,
		74	this._services,
		75	this._name,
		76	this._cache,
		77	this._visited
		78	);
		79	}
		80
		81	has(id: string) {
		82	return id in this._cache;
		83	}
		84
		85	get(id: string) {
		86	return this._cache[id];
		87	}
		88
		89	store(id: string, value) {
		90	return (this._cache[id] = value);
		91	}
		92
		93	activate(d: Descriptor, name: string) {
		94	if (trace.isLogEnabled())
		95	trace.log(`enter ${name} ${d}`);
		96
		97	this.enter(name, d.toString());
		98	const v = d.activate(this);
		99	this.leave();
		100
		101	if (trace.isLogEnabled())
		102	trace.log(`leave ${name}`);
		103
		104	return v;
		105	}
		106
		107	visit(id: string) {
		108	const count = this._visited[id] \|\| 0;
		109	this._visited[id] = count + 1;
		110	return count;
		111	}
		112
		113	getStack() {
		114	return this._stack.slice().reverse();
		115	}
		116
		117	private enter(name: string, service: string) {
		118	this._stack.push({
		119	name,
		120	service,
		121	scope: this._services
		122	});
		123	this._name = name;
		124	this._services = Object.create(this._services);
		125	}
		126
		127	private leave() {
		128	const ctx = this._stack.pop();
		129	this._services = ctx.scope;
		130	this._name = ctx.name;
		131	}
		132	}

src/main/ts/di/ActivationError.ts created 644 +36 0

			@@ -0,0 +1,36
		1	import { ActivationContextInfo } from "./ActivationContext";
		2
		3	export class ActivationError {
		4	activationStack: ActivationContextInfo[];
		5
		6	service: string;
		7
		8	innerException: any;
		9
		10	message: string;
		11
		12	constructor(service: string, activationStack: ActivationContextInfo[], innerException) {
		13	this.message = "Failed to activate the service";
		14	this.activationStack = activationStack;
		15	this.service = service;
		16	this.innerException = innerException;
		17	}
		18
		19	toString() {
		20	const parts = [this.message];
		21	if (this.service)
		22	parts.push("when activating: " + this.service.toString());
		23
		24	if (this.innerException)
		25	parts.push("caused by: " + this.innerException.toString());
		26
		27	if (this.activationStack) {
		28	parts.push("at");
		29	this.activationStack
		30	.forEach(x => parts.push(` ${x.name} ${x.service}`));
		31
		32	}
		33
		34	return parts.join("\n");
		35	}
		36	}

src/main/ts/di/AggregateDescriptor.ts created 644 +37 0

			@@ -0,0 +1,37
		1	import { Descriptor, isDescriptor } from "./interfaces";
		2	import { ActivationContext } from "./ActivationContext";
		3	import { isPrimitive } from "../safe";
		4
		5	export class AggregateDescriptor implements Descriptor {
		6	_value: object;
		7
		8	constructor(value: object) {
		9	this._value = value;
		10	}
		11
		12	activate(context: ActivationContext) {
		13	return this._parse(this._value, context, "$value");
		14	}
		15
		16	// TODO: make async
		17	_parse(value, context: ActivationContext, path: string) {
		18	if (isPrimitive(value))
		19	return value;
		20
		21	if (isDescriptor(value))
		22	return context.activate(value, path);
		23
		24	if (value instanceof Array)
		25	return value.map((x, i) => this._parse(x, context, `${path}[${i}]`));
		26
		27	const t = {};
		28	for (const p of Object.keys(value))
		29	t[p] = this._parse(value[p], context, `${path}.${p}`);
		30	return t;
		31
		32	}
		33
		34	toString() {
		35	return "@walk";
		36	}
		37	}

src/main/ts/di/ConfigError.ts created 644 +12 0

			@@ -0,0 +1,12
		1	export class ConfigError extends Error {
		2	inner;
		3
		4	path: string;
		5
		6	configName: string;
		7
		8	constructor(message: string, inner?) {
		9	super(message);
		10	this.inner = inner;
		11	}
		12	}

src/main/ts/di/Configuration.ts created 644 +348 0

			@@ -0,0 +1,348
		1	import {
		2	ServiceRegistration,
		3	TypeRegistration,
		4	FactoryRegistration,
		5	ServiceMap,
		6	isDescriptor,
		7	isDependencyRegistration,
		8	DependencyRegistration,
		9	ValueRegistration,
		10	ActivationType,
		11	isValueRegistration,
		12	isTypeRegistration,
		13	isFactoryRegistration
		14	} from "./interfaces";
		15
		16	import { argumentNotEmptyString, isPrimitive, isPromise, delegate, argumentOfType, argumentNotNull, get } from "../safe";
		17	import { AggregateDescriptor } from "./AggregateDescriptor";
		18	import { ValueDescriptor } from "./ValueDescriptor";
		19	import { Container } from "./Container";
		20	import { ReferenceDescriptor } from "./ReferenceDescriptor";
		21	import { TypeServiceDescriptor } from "./TypeServiceDescriptor";
		22	import { FactoryServiceDescriptor } from "./FactoryServiceDescriptor";
		23	import { TraceSource } from "../log/TraceSource";
		24	import { ConfigError } from "./ConfigError";
		25	import { Cancellation } from "../Cancellation";
		26
		27	const trace = TraceSource.get("@implab/core/di/Configuration");
		28
		29	declare const define;
		30	declare const require;
		31
		32	function hasAmdLoader() {
		33	return (typeof define === "function" && define.amd);
		34	}
		35
		36	async function mapAll(data: object \| any[], map?: (v, k) => any): Promise<any> {
		37	if (data instanceof Array) {
		38	return Promise.all(map ? data.map(map) : data);
		39	} else {
		40	const keys = Object.keys(data);
		41
		42	const o: any = {};
		43
		44	await Promise.all(keys.map(async k => {
		45	const v = map ? map(data[k], k) : data[k];
		46	o[k] = isPromise(v) ? await v : v;
		47	}));
		48
		49	return o;
		50	}
		51	}
		52
		53	type Resolver = (qname: string) => any;
		54
		55	type _key = string \| number;
		56
		57	export class Configuration {
		58
		59	_hasInnerDescriptors = false;
		60
		61	_container: Container;
		62
		63	_path: Array<_key>;
		64
		65	_configName: string;
		66
		67	_require: Resolver;
		68
		69	constructor(container: Container) {
		70	argumentNotNull(container, container);
		71	this._container = container;
		72	this._path = [];
		73	}
		74
		75	async loadConfiguration(moduleName: string, ct = Cancellation.none) {
		76	argumentNotEmptyString(moduleName, "moduleName");
		77	// TODO remove the code below somewehere else
		78	if (hasAmdLoader()) {
		79	// if we have a requirejs loader, use it directly
		80	// don't rely on typescript 'import' function
		81	const m = await new Promise<any>(cb => require(["./RequireJsHelper"], cb));
		82	const r = m.makeResolver(require);
		83	const config = await r(moduleName);
		84
		85	return this.applyConfiguration(
		86	config,
		87	m.makeResolver(await m.createContextRequire(moduleName))
		88	);
		89	} else {
		90	throw new Error("This feature is supported only with the amd loader");
		91	}
		92	}
		93
		94	async applyConfiguration(data: object, resolver?: Resolver, ct = Cancellation.none) {
		95	argumentNotNull(data, "data");
		96
		97	trace.log("applyConfiguration");
		98
		99	this._configName = "$";
		100
		101	if (resolver)
		102	this._require = resolver;
		103
		104	let services: ServiceMap;
		105
		106	try {
		107	services = await this._visitRegistrations(data, "$");
		108	} catch (e) {
		109	throw this._makeError(e);
		110	}
		111
		112	this._container.register(services);
		113	}
		114
		115	_makeError(inner) {
		116	const e = new ConfigError("Failed to load configuration", inner);
		117	e.configName = this._configName;
		118	e.path = this._makePath();
		119	return e;
		120	}
		121
		122	_makePath() {
		123	return this._path
		124	.reduce(
		125	(prev, cur) => typeof cur === "number" ?
		126	`${prev}[${cur}]` :
		127	`${prev}.${cur}`
		128	)
		129	.toString();
		130	}
		131
		132	async _resolveType(moduleName: string, localName: string) {
		133	trace.log("resolveType moduleName={0}, localName={1}", moduleName, localName);
		134	try {
		135	const m = await this._loadModule(moduleName);
		136	return localName ? get(localName, m) : m;
		137	} catch (e) {
		138	trace.error("Failed to resolve type moduleName={0}, localName={1}", moduleName, localName);
		139	throw e;
		140	}
		141	}
		142
		143	async _loadModule(moduleName: string) {
		144	trace.debug("loadModule {0}", moduleName);
		145
		146	const m = await this._require(moduleName);
		147
		148	return m;
		149	}
		150
		151	async _visitRegistrations(data, name: _key) {
		152	this._enter(name);
		153
		154	if (data.constructor &&
		155	data.constructor.prototype !== Object.prototype)
		156	throw new Error("Configuration must be a simple object");
		157
		158	const o: ServiceMap = {};
		159	const keys = Object.keys(data);
		160
		161	const services = await mapAll(data, async (v, k) => {
		162	const d = await this._visit(v, k);
		163	return isDescriptor(d) ? d : new AggregateDescriptor(d);
		164	}) as ServiceMap;
		165
		166	this._leave();
		167
		168	return services;
		169	}
		170
		171	_enter(name: _key) {
		172	this._path.push(name);
		173	trace.debug(">{0}", name);
		174	}
		175
		176	_leave() {
		177	const name = this._path.pop();
		178	trace.debug("<{0}", name);
		179	}
		180
		181	async _visit(data, name: string): Promise<any> {
		182	if (isPrimitive(data) \|\| isDescriptor(data))
		183	return data;
		184
		185	if (isDependencyRegistration(data)) {
		186	return this._visitDependencyRegistration(data, name);
		187	} else if (isValueRegistration(data)) {
		188	return this._visitValueRegistration(data, name);
		189	} else if (isTypeRegistration(data)) {
		190	return this._visitTypeRegistration(data, name);
		191	} else if (isFactoryRegistration(data)) {
		192	return this._visitFactoryRegistration(data, name);
		193	} else if (data instanceof Array) {
		194	return this._visitArray(data, name);
		195	}
		196
		197	return this._visitObject(data, name);
		198	}
		199
		200	async _visitObject(data: object, name: _key) {
		201	if (data.constructor &&
		202	data.constructor.prototype !== Object.prototype)
		203	return new ValueDescriptor(data);
		204
		205	this._enter(name);
		206
		207	const v = await mapAll(data, delegate(this, "_visit"));
		208
		209	// TODO: handle inline descriptors properly
		210	// const ex = {
		211	// activate(ctx) {
		212	// const value = ctx.activate(this.prop, "prop");
		213	// // some code
		214	// },
		215	// // will be turned to ReferenceDescriptor
		216	// prop: { $dependency: "depName" }
		217	// };
		218
		219	this._leave();
		220	return v;
		221	}
		222
		223	async _visitArray(data: any[], name: _key) {
		224	if (data.constructor &&
		225	data.constructor.prototype !== Array.prototype)
		226	return new ValueDescriptor(data);
		227
		228	this._enter(name);
		229
		230	const v = await mapAll(data, delegate(this, "_visit"));
		231	this._leave();
		232
		233	return v;
		234	}
		235
		236	_makeServiceParams(data: ServiceRegistration) {
		237	const opts: any = {
		238	owner: this._container
		239	};
		240	if (data.services)
		241	opts.services = this._visitRegistrations(data.services, "services");
		242
		243	if (data.inject) {
		244	this._path.push("inject");
		245	opts.inject = mapAll(
		246	data.inject instanceof Array ?
		247	data.inject :
		248	[data.inject],
		249	delegate(this, "_visitObject")
		250	);
		251	this._leave();
		252	}
		253
		254	if ("params" in data)
		255	opts.params = data.params instanceof Array ?
		256	this._visitArray(data.params, "params") :
		257	this._visit(data.params, "params");
		258
		259	if (data.activation) {
		260	if (typeof (data.activation) === "string") {
		261	switch (data.activation.toLowerCase()) {
		262	case "singleton":
		263	opts.activation = ActivationType.Singleton;
		264	break;
		265	case "container":
		266	opts.activation = ActivationType.Container;
		267	break;
		268	case "hierarchy":
		269	opts.activation = ActivationType.Hierarchy;
		270	break;
		271	case "context":
		272	opts.activation = ActivationType.Context;
		273	break;
		274	case "call":
		275	opts.activation = ActivationType.Call;
		276	break;
		277	default:
		278	throw new Error("Unknown activation type: " +
		279	data.activation);
		280	}
		281	} else {
		282	opts.activation = Number(data.activation);
		283	}
		284	}
		285
		286	if (data.cleanup)
		287	opts.cleanup = data.cleanup;
		288
		289	return opts;
		290	}
		291
		292	async _visitValueRegistration(data: ValueRegistration, name: _key) {
		293	this._enter(name);
		294	const d = data.parse ? new AggregateDescriptor(data.$value) : new ValueDescriptor(data.$value);
		295	this._leave();
		296	return d;
		297	}
		298
		299	async _visitDependencyRegistration(data: DependencyRegistration, name: _key) {
		300	argumentNotEmptyString(data && data.$dependency, "data.$dependency");
		301	this._enter(name);
		302	const d = new ReferenceDescriptor({
		303	name: data.$dependency,
		304	lazy: data.lazy,
		305	optional: data.optional,
		306	default: data.default,
		307	services: data.services && await this._visitRegistrations(data.services, "services")
		308	});
		309	this._leave();
		310	return d;
		311	}
		312
		313	async _visitTypeRegistration(data: TypeRegistration, name: _key) {
		314	argumentNotNull(data.$type, "data.$type");
		315	this._enter(name);
		316
		317	const opts = this._makeServiceParams(data);
		318	if (data.$type instanceof Function) {
		319	opts.type = data.$type;
		320	} else {
		321	const [moduleName, typeName] = data.$type.split(":", 2);
		322	opts.type = this._resolveType(moduleName, typeName);
		323	}
		324
		325	const d = new TypeServiceDescriptor(
		326	await mapAll(opts)
		327	);
		328
		329	this._leave();
		330
		331	return d;
		332	}
		333
		334	async _visitFactoryRegistration(data: FactoryRegistration, name: _key) {
		335	argumentOfType(data.$factory, Function, "data.$type");
		336	this._enter(name);
		337
		338	const opts = this._makeServiceParams(data);
		339	opts.factory = opts.$factory;
		340
		341	const d = new FactoryServiceDescriptor(
		342	await mapAll(opts)
		343	);
		344
		345	this._leave();
		346	return d;
		347	}
		348	}

src/main/ts/di/Container.ts created 644 +128 0

			@@ -0,0 +1,128
		1	import { ActivationContext } from "./ActivationContext";
		2	import { ValueDescriptor } from "./ValueDescriptor";
		3	import { ActivationError } from "./ActivationError";
		4	import { isDescriptor, ServiceMap } from "./interfaces";
		5	import { TraceSource } from "../log/TraceSource";
		6	import { Configuration } from "./Configuration";
		7	import { Cancellation } from "../Cancellation";
		8
		9	const trace = TraceSource.get("@implab/core/di/ActivationContext");
		10
		11	export class Container {
		12	_services: ServiceMap;
		13
		14	_cache: object;
		15
		16	_cleanup: (() => void)[];
		17
		18	_root: Container;
		19
		20	_parent: Container;
		21
		22	constructor(parent?: Container) {
		23	this._parent = parent;
		24	this._services = parent ? Object.create(parent._services) : {};
		25	this._cache = {};
		26	this._cleanup = [];
		27	this._root = parent ? parent.getRootContainer() : this;
		28	this._services.container = new ValueDescriptor(this);
		29	}
		30
		31	getRootContainer() {
		32	return this._root;
		33	}
		34
		35	getParent() {
		36	return this._parent;
		37	}
		38
		39	resolve(name: string, def?) {
		40	trace.debug("resolve {0}", name);
		41	const d = this._services[name];
		42	if (d === undefined) {
		43	if (arguments.length > 1)
		44	return def;
		45	else
		46	throw new Error("Service '" + name + "' isn't found");
		47	}
		48
		49	const context = new ActivationContext(this, this._services);
		50	try {
		51	return context.activate(d, name);
		52	} catch (error) {
		53	throw new ActivationError(name, context.getStack(), error);
		54	}
		55	}
		56
		57	/**
		58	* @deprecated use resolve() method
		59	*/
		60	getService() {
		61	return this.resolve.apply(this, arguments);
		62	}
		63
		64	register(nameOrCollection, service?) {
		65	if (arguments.length === 1) {
		66	const data = nameOrCollection;
		67	for (const name in data)
		68	this.register(name, data[name]);
		69	} else {
		70	if (!isDescriptor(service))
		71	throw new Error("The service parameter must be a descriptor");
		72
		73	this._services[nameOrCollection] = service;
		74	}
		75	return this;
		76	}
		77
		78	onDispose(callback) {
		79	if (!(callback instanceof Function))
		80	throw new Error("The callback must be a function");
		81	this._cleanup.push(callback);
		82	}
		83
		84	dispose() {
		85	if (this._cleanup) {
		86	for (const f of this._cleanup)
		87	f();
		88	this._cleanup = null;
		89	}
		90	}
		91
		92	/**
		93	* @param{String\|Object} config
		94	* The configuration of the contaier. Can be either a string or an object,
		95	* if the configuration is an object it's treated as a collection of
		96	* services which will be registed in the contaier.
		97	*
		98	* @param{Function} opts.contextRequire
		99	* The function which will be used to load a configuration or types for services.
		100	*
		101	*/
		102	async configure(config: string \| object, opts?, ct = Cancellation.none) {
		103	const c = new Configuration(this);
		104
		105	if (typeof (config) === "string") {
		106	return c.loadConfiguration(config, ct);
		107	} else {
		108	return c.applyConfiguration(config, opts && opts.contextRequire, ct);
		109	}
		110	}
		111
		112	createChildContainer() {
		113	return new Container(this);
		114	}
		115
		116	has(id) {
		117	return id in this._cache;
		118	}
		119
		120	get(id) {
		121	return this._cache[id];
		122	}
		123
		124	store(id, value) {
		125	return (this._cache[id] = value);
		126	}
		127
		128	}

src/main/ts/di/FactoryServiceDescriptor.ts created 644 +23 0

			@@ -0,0 +1,23
		1	import { ServiceDescriptor, ServiceDescriptorParams } from "./ServiceDescriptor";
		2	import { Factory } from "../interfaces";
		3	import { argumentNotNull, oid } from "../safe";
		4	import { ActivationType } from "./interfaces";
		5
		6	export interface FactoryServiceDescriptorParams extends ServiceDescriptorParams {
		7	factory: Factory;
		8	}
		9
		10	export class FactoryServiceDescriptor extends ServiceDescriptor {
		11	constructor(opts: FactoryServiceDescriptorParams) {
		12	super(opts);
		13
		14	argumentNotNull(opts && opts.factory, "opts.factory");
		15
		16	// bind to null
		17	this._factory = () => opts.factory();
		18
		19	if (opts.activation === ActivationType.Singleton) {
		20	this._cacheId = oid(opts.factory);
		21	}
		22	}
		23	}

src/main/ts/di/ReferenceDescriptor.ts created 644 +100 0

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

src/main/ts/di/ServiceDescriptor.ts created 644 +234 0

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

src/main/ts/di/TypeServiceDescriptor.ts created 644 +42 0

			@@ -0,0 +1,42
		1	import { ServiceDescriptor, ServiceDescriptorParams } from "./ServiceDescriptor";
		2	import { Constructor, Factory } from "../interfaces";
		3	import { argumentNotNull, isPrimitive } from "../safe";
		4
		5	export interface TypeServiceDescriptorParams extends ServiceDescriptorParams {
		6	type: Constructor;
		7	}
		8
		9	export class TypeServiceDescriptor extends ServiceDescriptor {
		10	_type: Constructor;
		11
		12	constructor(opts: TypeServiceDescriptorParams) {
		13	super(opts);
		14	argumentNotNull(opts && opts.type, "opts.type");
		15
		16	const ctor = this._type = opts.type;
		17
		18	if (this._params) {
		19	if (this._params.length) {
		20	this._factory = (...args) => {
		21	const t = Object.create(ctor.prototype);
		22	const inst = ctor.apply(t, args);
		23	return isPrimitive(inst) ? t : inst;
		24	};
		25	} else {
		26	this._factory = arg => {
		27	return new ctor(arg);
		28	};
		29	}
		30	} else {
		31	this._factory = () => {
		32	return new ctor();
		33	};
		34	}
		35
		36	}
		37
		38	toString() {
		39	// @constructor {singleton} foo/bar/Baz
		40	return ``;
		41	}
		42	}

src/main/ts/di/ValueDescriptor.ts created 644 +17 0

			@@ -0,0 +1,17
		1	import { Descriptor } from "./interfaces";
		2
		3	export class ValueDescriptor implements Descriptor {
		4	_value;
		5
		6	constructor(value) {
		7	this._value = value;
		8	}
		9
		10	activate() {
		11	return this._value;
		12	}
		13
		14	toString() {
		15	return `@type=${typeof this._value}`;
		16	}
		17	}

src/main/ts/di/interfaces.ts created 644 +75 0

			@@ -0,0 +1,75
		1	import { isNull, isPrimitive } from "../safe";
		2	import { ActivationContext } from "./ActivationContext";
		3	import { Constructor, Factory } from "../interfaces";
		4
		5	export interface Descriptor {
		6	activate(context: ActivationContext, name?: string);
		7	}
		8
		9	export function isDescriptor(x): x is Descriptor {
		10	return (!isPrimitive(x)) &&
		11	(x.activate instanceof Function);
		12	}
		13
		14	export interface ServiceMap {
		15	[s: string]: Descriptor;
		16	}
		17
		18	export enum ActivationType {
		19	Singleton,
		20	Container,
		21	Hierarchy,
		22	Context,
		23	Call
		24	}
		25
		26	export interface RegistrationWithServices {
		27	services?: object;
		28	}
		29
		30	export interface ServiceRegistration extends RegistrationWithServices {
		31
		32	activation?: "singleton" \| "container" \| "hierarchy" \| "context" \| "call";
		33
		34	params?;
		35
		36	inject?: object \| object[];
		37
		38	cleanup?: (instance) => void \| string;
		39	}
		40
		41	export interface TypeRegistration extends ServiceRegistration {
		42	$type: string \| Constructor;
		43	}
		44
		45	export interface FactoryRegistration extends ServiceRegistration {
		46	$factory: string \| Factory;
		47	}
		48
		49	export interface ValueRegistration {
		50	$value;
		51	parse?: boolean;
		52	}
		53
		54	export interface DependencyRegistration extends RegistrationWithServices {
		55	$dependency: string;
		56	lazy?: boolean;
		57	optional?: boolean;
		58	default?;
		59	}
		60
		61	export function isTypeRegistration(x): x is TypeRegistration {
		62	return (!isPrimitive(x)) && ("$type" in x \|\| "$factory" in x);
		63	}
		64
		65	export function isFactoryRegistration(x): x is FactoryRegistration {
		66	return (!isPrimitive(x)) && ("$type" in x \|\| "$factory" in x);
		67	}
		68
		69	export function isValueRegistration(x): x is ValueRegistration {
		70	return (!isPrimitive(x)) && ("$value" in x);
		71	}
		72
		73	export function isDependencyRegistration(x): x is DependencyRegistration {
		74	return (!isPrimitive(x)) && ("$dependency" in x);
		75	}

src/main/ts/log/Registry.ts created 644 +55 0

			@@ -0,0 +1,55
		1	import { TraceSource } from "./TraceSource";
		2	import { argumentNotNull } from "../safe";
		3	import { IDestroyable } from "../interfaces";
		4
		5	export class Registry {
		6	static readonly instance = new Registry();
		7
		8	private _registry: object = new Object();
		9	private _listeners: object = new Object();
		10	private _nextCookie: number = 1;
		11
		12	get(id: any): TraceSource {
		13	argumentNotNull(id, "id");
		14
		15	if (this._registry[id])
		16	return this._registry[id];
		17
		18	const source = new TraceSource(id);
		19	this._registry[id] = source;
		20	this._onNewSource(source);
		21
		22	return source;
		23	}
		24
		25	add(id: any, source: TraceSource) {
		26	argumentNotNull(id, "id");
		27	argumentNotNull(source, "source");
		28
		29	this._registry[id] = source;
		30	this._onNewSource(source);
		31	}
		32
		33	_onNewSource(source: TraceSource) {
		34	for (const i in this._listeners)
		35	this._listeners[i].call(null, source);
		36	}
		37
		38	on(handler: (source: TraceSource) => void): IDestroyable {
		39	argumentNotNull(handler, "handler");
		40	const me = this;
		41
		42	const cookie = this._nextCookie++;
		43
		44	this._listeners[cookie] = handler;
		45
		46	for (const i in this._registry)
		47	handler(this._registry[i]);
		48
		49	return {
		50	destroy() {
		51	delete me._listeners[cookie];
		52	}
		53	};
		54	}
		55	}

src/main/ts/text/StringFormat.ts created 644 +173 0

			@@ -0,0 +1,173
		1	import { isPrimitive, isNull, each } from "../safe";
		2	import { MapOf } from "../interfaces";
		3
		4	type SubstFn = (name: string, format?: string) => string;
		5	type TemplateFn = (subst: SubstFn) => string;
		6	type ConvertFn = (value: any, format?: string) => string;
		7
		8	const map = {
		9	"\\{": "&curlopen;",
		10	"\\}": "&curlclose;",
		11	"&": "&",
		12	"\\:": "&colon;"
		13	};
		14
		15	const rev = {
		16	curlopen: "{",
		17	curlclose: "}",
		18	amp: "&",
		19	colon: ":"
		20	};
		21
		22	function espaceString(s: string) {
		23	if (!s)
		24	return s;
		25	return "'" + s.replace(/('\|\\)/g, "\\$1").replace("\n", "\\n") + "'";
		26	}
		27
		28	function encode(s: string) {
		29	if (!s)
		30	return s;
		31	return s.replace(/\\{\|\\}\|&\|\\:\|\n/g, m => map[m] \|\| m);
		32	}
		33
		34	function decode(s: string) {
		35	if (!s)
		36	return s;
		37	return s.replace(/&(\w+);/g, (m, $1) => rev[$1] \|\| m);
		38	}
		39
		40	function subst(s: string) {
		41	const i = s.indexOf(":");
		42	let name: string;
		43	let pattern: string;
		44	if (i >= 0) {
		45	name = s.substr(0, i);
		46	pattern = s.substr(i + 1);
		47	} else {
		48	name = s;
		49	}
		50
		51	if (pattern)
		52	return [
		53	espaceString(decode(name)),
		54	espaceString(decode(pattern))];
		55	else
		56	return [espaceString(decode(name))];
		57	}
		58
		59	function _compile(str: string) {
		60	if (!str)
		61	return () => void 0;
		62
		63	const chunks = encode(str).split("{");
		64	let chunk: string;
		65
		66	const code = ["var result=[];"];
		67
		68	for (let i = 0; i < chunks.length; i++) {
		69	chunk = chunks[i];
		70
		71	if (i === 0) {
		72	if (chunk)
		73	code.push("result.push(" + espaceString(decode(chunk)) +
		74	");");
		75	} else {
		76	const len = chunk.indexOf("}");
		77	if (len < 0)
		78	throw new Error("Unbalanced substitution #" + i);
		79
		80	code.push("result.push(subst(" +
		81	subst(chunk.substr(0, len)).join(",") + "));");
		82	if (chunk.length > len + 1)
		83	code.push("result.push(" +
		84	espaceString(decode(chunk.substr(len + 1))) + ");");
		85	}
		86	}
		87
		88	code.push("return result.join('');");
		89
		90	// the code for this function is generated from the template
		91	// tslint:disable-next-line:function-constructor
		92	return new Function("subst", code.join("\n")) as TemplateFn;
		93	}
		94
		95	const cache: MapOf<TemplateFn> = {};
		96
		97	export function compile(template: string) {
		98	let compiled = cache[template];
		99	if (!compiled) {
		100	compiled = _compile(template);
		101	cache[template] = compiled;
		102	}
		103	return compiled;
		104	}
		105
		106	function defaultConverter(value: any, pattern: string) {
		107	if (pattern && pattern.toLocaleLowerCase() === "json") {
		108	const seen = [];
		109	return JSON.stringify(value, (k, v) => {
		110	if (!isPrimitive(v)) {
		111	const id = seen.indexOf(v);
		112	if (id >= 0)
		113	return "@ref-" + id;
		114	else {
		115	seen.push(v);
		116	return v;
		117	}
		118	} else {
		119	return v;
		120	}
		121	}, 2);
		122	} else if (isNull(value)) {
		123	return "";
		124	} else if (value instanceof Date) {
		125	return value.toISOString();
		126	} else {
		127	return pattern ? value.toString(pattern) : value.toString();
		128	}
		129	}
		130
		131	export class Formatter {
		132	_converters: ConvertFn[];
		133
		134	constructor(converters?: ConvertFn[]) {
		135	this._converters = converters \|\| [];
		136	this._converters.push(defaultConverter);
		137	}
		138
		139	convert(value: any, pattern: string) {
		140	for (const c of this._converters) {
		141	const res = c(value, pattern);
		142	if (!isNull(res))
		143	return res;
		144	}
		145	return "";
		146	}
		147
		148	format(msg: string, ...args: any[]) {
		149	const template = compile(msg);
		150
		151	return template((name, pattern) => {
		152	const value = args[name];
		153	return !isNull(value) ? this.convert(value, pattern) : "";
		154	});
		155
		156	}
		157
		158	compile(msg: string) {
		159	const template = compile(msg);
		160	return (...args: any[]) => {
		161	return template((name, pattern) => {
		162	const value = args[name];
		163	return !isNull(value) ? this.convert(value, pattern) : "";
		164	});
		165	};
		166	}
		167	}
		168
		169	const _default = new Formatter();
		170
		171	export function format(msg: string, ...args: any[]) {
		172	return _default.format(msg, ...args);
		173	}

src/main/ts/text/TemplateCompiler.ts created 644 +102 0

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

src/main/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/main/tsconfig.json created 644 +9 0

			@@ -0,0 +1,9
		1	{
		2	"extends": "../tsconfig",
		3	"compilerOptions": {
		4	"rootDir": "ts"
		5	},
		6	"include": [
		7	"ts/*/.ts"
		8	]
		9	} No newline at end of file

src/package.template.json created 644 +23 0

			@@ -0,0 +1,23
		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	}
		23	No newline at end of file

src/test/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/test/ts/ContainerTests.ts created 644 +94 0

			@@ -0,0 +1,94
		1	import { test, TapeWriter } from "./TestTraits";
		2	import { Container } from "@implab/core/di/Container";
		3	import { ReferenceDescriptor } from "@implab/core/di/ReferenceDescriptor";
		4	import { AggregateDescriptor } from "@implab/core/di/AggregateDescriptor";
		5	import { ValueDescriptor } from "@implab/core/di/ValueDescriptor";
		6	import { TraceSource, DebugLevel } from "@implab/core/log/TraceSource";
		7	import { Foo } from "./mock/Foo";
		8	import { Bar } from "./mock/Bar";
		9	import { isNull } from "@implab/core/safe";
		10
		11	test("Container register/resolve tests", async t => {
		12	const container = new Container();
		13
		14	const connection1 = "db://localhost";
		15
		16	t.throws(
		17	() => container.register("bla-bla", "bla-bla"),
		18	"Do not allow to register anything other than descriptors"
		19	);
		20
		21	t.doesNotThrow(
		22	() => container.register("connection", new ValueDescriptor(connection1)),
		23	"register ValueDescriptor"
		24	);
		25
		26	t.equals(container.resolve("connection"), connection1, "resolve string value");
		27
		28	t.doesNotThrow(
		29	() => container.register(
		30	"dbParams",
		31	new AggregateDescriptor({
		32	timeout: 10,
		33	connection: new ReferenceDescriptor({ name: "connection" })
		34	})
		35	),
		36	"register AggregateDescriptor"
		37	);
		38
		39	const dbParams = container.resolve("dbParams");
		40	t.equals(dbParams.connection, connection1, "should get string value 'dbParams.connection'");
		41	});
		42
		43	test("Container configure/resolve tests", async t => {
		44
		45	const container = new Container();
		46
		47	await container.configure({
		48	foo: {
		49	$type: Foo
		50	},
		51
		52	box: {
		53	$type: Bar,
		54	params: {
		55	$dependency: "foo"
		56	}
		57	},
		58
		59	bar: {
		60	$type: Bar,
		61	params: {
		62	db: {
		63	provider: {
		64	$dependency: "db"
		65	}
		66	}
		67	}
		68	}
		69	});
		70	t.pass("should configure from js object");
		71
		72	const f1 = container.resolve("foo");
		73
		74	t.assert(!isNull(f1), "foo should be not null");
		75
		76	t.throws(() => container.resolve("bar"), "should not resolve dependency 'db'");
		77
		78	});
		79
		80	test("Load configuration from module", async t => {
		81	const container = new Container();
		82
		83	await container.configure("test/mock/config1");
		84	t.pass("The configuration should load");
		85
		86	const f1 = container.resolve("foo");
		87
		88	t.assert(!isNull(f1), "foo should be not null");
		89
		90	const b1 = container.resolve("bar") as Bar;
		91
		92	t.assert(!isNull(b1), "bar should not be null");
		93	t.assert(!isNull(b1.foo), "bar.foo should not be null");
		94	});

src/test/ts/mock/Bar.ts created 644 +12 0

			@@ -0,0 +1,12
		1	import { Foo } from "./Foo";
		2
		3	export class Bar {
		4	name = "bar";
		5
		6	foo: Foo;
		7
		8	constructor(_opts) {
		9	if (_opts && _opts.foo)
		10	this.foo = _opts.foo;
		11	}
		12	}

src/test/ts/mock/Foo.ts created 644 +3 0

			@@ -0,0 +1,3
		1	export class Foo {
		2	name = "foo";
		3	}

src/test/ts/mock/MockActivationController.ts created 644 +43 0

			@@ -0,0 +1,43
		1	import { IActivatable, ICancellation, IActivationController } from "@implab/core/interfaces";
		2	import { Cancellation } from "@implab/core/Cancellation";
		3
		4	export class MockActivationController implements IActivationController {
		5
		6	_active: IActivatable = null;
		7
		8	getActive(): IActivatable {
		9	return this._active;
		10	}
		11
		12	async deactivate() {
		13	if (this._active)
		14	await this._active.deactivate();
		15	this._active = null;
		16	}
		17
		18	async activate(component: IActivatable) {
		19	if (!component \|\| component.isActive())
		20	return;
		21	component.setActivationController(this);
		22
		23	await component.activate();
		24	}
		25
		26	async activating(component: IActivatable, ct: ICancellation = Cancellation.none) {
		27	if (component !== this._active)
		28	await this.deactivate();
		29	}
		30
		31	async activated(component: IActivatable, ct: ICancellation = Cancellation.none) {
		32	this._active = component;
		33	}
		34
		35	async deactivating(component: IActivatable, ct: ICancellation = Cancellation.none) {
		36
		37	}
		38
		39	async deactivated(component: IActivatable, ct: ICancellation = Cancellation.none) {
		40	if (this._active === component)
		41	this._active = null;
		42	}
		43	}

src/test/ts/mock/SimpleActivatable.ts created 644 +6 0

			@@ -0,0 +1,6
		1	import { AsyncComponent } from "@implab/core/components/AsyncComponent";
		2	import { ActivatableMixin } from "@implab/core/components/ActivatableMixin";
		3
		4	export class SimpleActivatable extends ActivatableMixin(AsyncComponent) {
		5
		6	}

src/test/tsconfig.json created 644 +15 0

			@@ -0,0 +1,15
		1	{
		2	"extends": "../tsconfig",
		3	"compilerOptions": {
		4	"rootDir": "ts",
		5	"baseUrl": ".",
		6	"paths": {
		7	"@implab/core/*": [
		8	"../../build/dist/amd/*"
		9	]
		10	}
		11	},
		12	"include" : [
		13	"ts/*/.ts"
		14	]
		15	} No newline at end of file

src/tsconfig.json created 644 +18 0

			@@ -0,0 +1,18
		1	{
		2	"compilerOptions": {
		3	"target": "es3",
		4	"sourceMap": true,
		5	"declaration": true,
		6	"moduleResolution": "node",
		7	"noEmitOnError": true,
		8	"listFiles": true,
		9	"lib": [
		10	"es5",
		11	"es2015.promise",
		12	"es2015.symbol",
		13	"dom"
		14	],
		15	"types": []
		16	},
		17	"files": []
		18	} No newline at end of file

tslint.json created 644 +40 0

			@@ -0,0 +1,40
		1	{
		2	"extends": "tslint:recommended",
		3	"rules": {
		4	"align": [
		5	true,
		6	"parameters",
		7	"statements"
		8	],
		9	"interface-name": [false],
		10	"max-line-length": [ true, 185 ],
		11	"member-access": false,
		12	"member-ordering": [
		13	false,
		14	"variables-before-functions"
		15	],
		16	"no-bitwise": false,
		17	"no-empty": false,
		18	"no-namespace": false,
		19	"no-string-literal": false,
		20	"ordered-imports": false,
		21	"one-line": [
		22	true,
		23	"check-open-brace",
		24	"check-catch",
		25	"check-whitespace"
		26	],
		27	"object-literal-sort-keys": false,
		28	"trailing-comma": [
		29	true,
		30	{
		31	"singleline": "never",
		32	"multiline": "never"
		33	}
		34	],
		35	"variable-name": false,
		36	"curly": false,
		37	"array-type": false,
		38	"arrow-parens": [true, "ban-single-arg-parens"]
		39	}
		40	} No newline at end of file

.hgignore +1 0

              .gradle/
              build/
              node_modules/
+             src/typings/

.hgtags +1 0

		@@ -1,1 +1,2
1	1	9b7927c5bafc1c80e589d9feb807e428075ef513 v1.1.1
	2	43a2828f8abeb9f2f9bfaf9e6d0e0b370c8a6456 v1.2.0-rc

build.gradle +81 -41

                  version += "-$release"
              }
-             println "version: $version"
+             if(!npmName)
+                 npmName = name;
+             if(!["amd", "cjs"].contains(platform))
+                 throw new Exception("Invalid platform specified: $platform");
+             def moduleTypes = [
+                 "amd": "amd",
+                 "cjs": "commonjs"
+             ]
+             ext.packageName="$npmScope/$npmName-$platform";
-             def distDir = "$buildDir/dist"
-             def testDir = "$buildDir/test"
+             def srcDir = "$projectDir/src"
+             def typingsDir = "$srcDir/typings"
+             def distDir = "$buildDir/dist/$platform"
+             def testDir = "$buildDir/test/$platform"
+             def moduleType = moduleTypes[platform]
+             def sourceSets = ["main", "amd", "cjs", "test"];
+             task printVersion {
+                 doLast {
+                     println "version: $version"
+                     println "packageName: $packageName"
+                     println "platform: $platform"
+                     println "module: $moduleType"
+                 }
+             }
              task clean {
                  doLast {
                      delete buildDir
-                     delete 'node_modules/@implab'
+                     delete "node_modules/$packageName"
+                     delete typingsDir
                  }
              }
                  }
              }
-             task _legacyJs(type:Copy) {
-                 from 'src/js/'
-                 into distDir
+             sourceSets.each {
+                 def setName = it.capitalize();
+                 def destDir = "$buildDir/compile/$it"
+                 def declDir = "$typingsDir/$it"
+                 def setDir = "$projectDir/src/$it"
+                 task "_copyJs$setName"(type:Copy) {
+                     from "$setDir/js"
+                     into distDir
+                 }
+                 task "_compileTs$setName"(dependsOn: _npmInstall, type:Exec) {
+                     inputs.dir("$setDir/ts")
+                     inputs.file("$srcDir/tsconfig.json")
+                     inputs.file("$setDir/tsconfig.json")
+                     outputs.dir(destDir)
+                     outputs.dir(declDir)
+                     commandLine 'node_modules/.bin/tsc',
+                         '-p', "$setDir/tsconfig.json",
+                         '-m', moduleType,
+                         '--outDir', destDir,
+                         '--declarationDir', declDir
+                 }
+                 task "_buildTs$setName"(dependsOn: "_compileTs$setName", type:Copy) {
+                     from tasks.getByPath("_compileTs$setName");
+                     into distDir
+                 }
              }
-             task _buildTs(dependsOn: _npmInstall, type:Exec) {
-                 inputs.dir('src/ts')
-                 inputs.file('tsc.json')
-                 outputs.dir(distDir)
+             _compileTsAmd {
+                 dependsOn _buildTsMain
+             }
-                 commandLine 'node_modules/.bin/tsc', '-p', 'tsc.json'
+             _buildTsTest {
+                 into testDir
+             }
+             _copyJsTest {
+                 into testDir
              }
              task _packageMeta(type: Copy) {
                  inputs.property("version", version)
                  from('.') {
-                     include 'package.json', '.npmignore', 'readme.md', 'license', 'history.md'
+                     include '.npmignore', 'readme.md', 'license', 'history.md'
+                 }
+                 from("$srcDir/package.template.json") {
+                     expand project.properties
+                     rename { "package.json" }
                  }
                  into distDir
-                 doLast {
-                     exec {
-                         workingDir distDir
-                         commandLine 'npm', 'version', version
+                     }
+                 }
              }
-             task build(dependsOn: [_npmInstall, _buildTs, _legacyJs, _packageMeta]) {
+             task build(dependsOn: [_copyJsMain, _copyJsAmd, _npmInstall, _buildTsMain, _buildTsAmd, _packageMeta]) {
              }
-             task _localInstall(dependsOn: build, type: Exec) {
-                 inputs.file("$distDir/package.json")
-                 outputs.upToDateWhen {
-                     new File("$projectDir/node_modules/@implab/core").exists()
+                 }
-                 commandLine 'npm', 'install', '--no-save', '--force', distDir
+             _compileTsTest {
+                 dependsOn build
              }
-             task copyJsTests(type: Copy) {
-                 from 'test/js'
-                 into testDir
+             task buildTests(dependsOn: [_copyJsTest, _buildTsTest]) {
              }
-             task buildTests(dependsOn: _localInstall, type: Exec) {
-                 inputs.dir('test/ts')
-                 inputs.file('tsc.test.json')
-                 outputs.dir(testDir)
-                 commandLine 'node_modules/.bin/tsc', '-p', 'tsc.test.json'
+             }
-             task test(dependsOn: [copyJsTests, buildTests], type: Exec) {
-                 commandLine 'node', 'run-amd-tests.js'
+             task test(dependsOn: buildTests, type: Exec) {
+                 commandLine 'node', "$testDir/run-amd-tests.js"
              }
              task pack(dependsOn: build, type: Exec) {
-                 workingDir = distDir
+                 workingDir distDir
                  commandLine 'npm', 'pack'
              }
  No newline at end of file

gradle.properties +9 -2

		@@ -1,2 +1,9
1		version=1.~~1.1~~
2		release=rtm No newline at end of file
	1	version=1.2.0
	2	release=rc
	3	author=Implab team
	4	platform=amd
	5	description=Dependency injection, logging, simple and fast text template engine
	6	license=BSD-2-Clause
	7	repository=https://bitbucket.org/implab/implabjs
	8	npmScope=@implab
	9	npmName=core No newline at end of file

license +1 -1

-             Copyright 2017-2018 Implab team
+             Copyright 2017-2019 Implab team
              Redistribution and use in source and binary forms, with or without
              modification, are permitted provided that the following conditions are met:

package-lock.json +159 -142

                "requires": true,
                "dependencies": {
                  "@types/node": {
-                   "version": "10.5.1",
-                   "resolved": "https://registry.npmjs.org/@types/node/-/node-10.5.1.tgz",
-                   "integrity": "sha512-AFLl1IALIuyt6oK4AYZsgWVJ/5rnyzQWud7IebaZWWV3YmgtPZkQmYio9R5Ze/2pdd7XfqF5bP+hWS11mAKoOQ==",
+                   "version": "10.12.15",
+                   "resolved": "https://registry.npmjs.org/@types/node/-/node-10.12.15.tgz",
+                   "integrity": "sha512-9kROxduaN98QghwwHmxXO2Xz3MaWf+I1sLVAA6KJDF5xix+IyXVhds0MAfdNwtcpSrzhaTsNB0/jnL86fgUhqA==",
+                   "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": {
                    "integrity": "sha512-xil0KO5wkPoixdBWGIGolPv9dekf6dVkjjJLAFYchfKcd4DICou67rgGCIO7wAh3i5Ff/6j9IDgZz+GU9cMaqQ==",
                    "dev": true,
                    "requires": {
-                     "@types/node": "10.5.1"
+                     "@types/node": "*"
                    }
                  },
                  "balanced-match": {
                    "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
                    "dev": true,
                    "requires": {
-                     "balanced-match": "1.0.0",
+                     "balanced-match": "^1.0.0",
                      "concat-map": "0.0.1"
                    }
                  },
                    "dev": true
                  },
                  "deep-equal": {
-                   "version": "1.0.1",
-                   "resolved": "https://registry.npmjs.org/deep-equal/-/deep-equal-1.0.1.tgz",
-                   "integrity": "sha1-9dJgKStmDghO/0zbyfCK0yR0SLU=",
+                   "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.2",
-                   "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.2.tgz",
-                   "integrity": "sha1-g6c/L+pWmJj7c3GTyPhzyvbUXJQ=",
+                   "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": {
-                     "foreach": "2.0.5",
-                     "object-keys": "1.0.12"
+                     "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": "1.0.0",
-                   "resolved": "https://registry.npmjs.org/defined/-/defined-1.0.0.tgz",
-                   "integrity": "sha1-yY2bzvdWdBiOEQlpFRGZ45sfppM=",
+                   "version": "0.0.0",
+                   "resolved": "https://registry.npmjs.org/defined/-/defined-0.0.0.tgz",
+                   "integrity": "sha1-817qfXBekzuvE7LwOz+D2SFAOz4=",
                    "dev": true
                  },
                  "dojo": {
-                   "version": "1.13.0",
-                   "resolved": "https://registry.npmjs.org/dojo/-/dojo-1.13.0.tgz",
-                   "integrity": "sha512-mGoGvsXAbPkUrBnxCoO7m6CFH8jvWq7rAL7fP7jrhJEOyswA/bZwWdXwEH0ovs68t8S0+xOpV/3V7addYbaiAA=="
+                   "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": "https://registry.npmjs.org/duplexer/-/duplexer-0.1.1.tgz",
+                   "resolved": "http://registry.npmjs.org/duplexer/-/duplexer-0.1.1.tgz",
                    "integrity": "sha1-rOb/gIwc5mtX0ev5eXessCM0z8E=",
                    "dev": true
                  },
                    "integrity": "sha512-C8Fx/0jFmV5IPoMOFPA9P9G5NtqW+4cOPit3MIuvR2t7Ag2K15EJTpxnHAYTzL+aYQJIESYeXZmDBfOBE1HcpA==",
                    "dev": true,
                    "requires": {
-                     "es-to-primitive": "1.1.1",
-                     "function-bind": "1.1.1",
-                     "has": "1.0.3",
-                     "is-callable": "1.1.3",
-                     "is-regex": "1.0.4"
+                     "es-to-primitive": "^1.1.1",
+                     "function-bind": "^1.1.1",
+                     "has": "^1.0.1",
+                     "is-callable": "^1.1.3",
+                     "is-regex": "^1.0.4"
                    }
                  },
                  "es-to-primitive": {
-                   "version": "1.1.1",
-                   "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.1.1.tgz",
-                   "integrity": "sha1-RTVSSKiJeQNLZ5Lhm7gfK3l13Q0=",
+                   "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.3",
-                     "is-date-object": "1.0.1",
-                     "is-symbol": "1.0.1"
+                     "is-callable": "^1.1.4",
+                     "is-date-object": "^1.0.1",
+                     "is-symbol": "^1.0.2"
                    }
                  },
                  "faucet": {
                    "dev": true,
                    "requires": {
                      "defined": "0.0.0",
-                     "duplexer": "0.1.1",
+                     "duplexer": "~0.1.1",
                      "minimist": "0.0.5",
-                     "sprintf": "0.1.5",
-                     "tap-parser": "0.4.3",
-                     "tape": "2.3.3",
-                     "through2": "0.2.3"
+                     "sprintf": "~0.1.3",
+                     "tap-parser": "~0.4.0",
+                     "tape": "~2.3.2",
+                     "through2": "~0.2.3"
                    },
                    "dependencies": {
-                     "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
-                     },
-                     "defined": {
-                       "version": "0.0.0",
-                       "resolved": "https://registry.npmjs.org/defined/-/defined-0.0.0.tgz",
-                       "integrity": "sha1-817qfXBekzuvE7LwOz+D2SFAOz4=",
-                       "dev": true
-                     },
-                     "minimist": {
-                       "version": "0.0.5",
-                       "resolved": "http://registry.npmjs.org/minimist/-/minimist-0.0.5.tgz",
-                       "integrity": "sha1-16oye87PUY+RBqxrjwA/o7zqhWY=",
-                       "dev": true
-                     },
                      "tape": {
                        "version": "2.3.3",
-                       "resolved": "https://registry.npmjs.org/tape/-/tape-2.3.3.tgz",
+                       "resolved": "http://registry.npmjs.org/tape/-/tape-2.3.3.tgz",
                        "integrity": "sha1-Lnzgox3wn41oUWZKcYQuDKUFevc=",
                        "dev": true,
                        "requires": {
-                         "deep-equal": "0.1.2",
-                         "defined": "0.0.0",
-                         "inherits": "2.0.3",
-                         "jsonify": "0.0.0",
-                         "resumer": "0.0.0",
-                         "through": "2.3.8"
+                         "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"
                        }
                      }
                    }
                    "integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==",
                    "dev": true,
                    "requires": {
-                     "is-callable": "1.1.3"
+                     "is-callable": "^1.1.3"
                    }
                  },
-                 "foreach": {
-                   "version": "2.0.5",
-                   "resolved": "https://registry.npmjs.org/foreach/-/foreach-2.0.5.tgz",
-                   "integrity": "sha1-C+4AUBiusmDQo6865ljdATbsG5k=",
-                   "dev": true
-                 },
                  "fs.realpath": {
                    "version": "1.0.0",
                    "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
                    "dev": true
                  },
                  "glob": {
-                   "version": "7.1.2",
-                   "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.2.tgz",
-                   "integrity": "sha512-MJTUg1kjuLeQCJ+ccE4Vpa6kKVXkPYJ2mOCQyUuKLcLQsdrMCpBPUi8qVE6+YuaJkozeA9NusTAw3hLr8Xe5EQ==",
+                   "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.6",
-                     "inherits": "2.0.3",
-                     "minimatch": "3.0.4",
-                     "once": "1.4.0",
-                     "path-is-absolute": "1.0.1"
+                     "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": {
                    "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
                    "dev": true,
                    "requires": {
-                     "function-bind": "1.1.1"
+                     "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.4.0",
-                     "wrappy": "1.0.2"
+                     "once": "^1.3.0",
+                     "wrappy": "1"
                    }
                  },
                  "inherits": {
                    "dev": true
                  },
                  "is-callable": {
-                   "version": "1.1.3",
-                   "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.1.3.tgz",
-                   "integrity": "sha1-hut1OSgF3cM69xySoO7fdO52BLI=",
+                   "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": {
                    "integrity": "sha1-VRdIm1RwkbCTDglWVM7SXul+lJE=",
                    "dev": true,
                    "requires": {
-                     "has": "1.0.3"
+                     "has": "^1.0.1"
                    }
                  },
                  "is-symbol": {
-                   "version": "1.0.1",
-                   "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.1.tgz",
-                   "integrity": "sha1-PMWfAAJRlLarLjjbrmaJJWtmBXI=",
-                   "dev": true
+                   "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",
                    "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
                    "dev": true,
                    "requires": {
-                     "brace-expansion": "1.1.11"
+                     "brace-expansion": "^1.1.7"
                    }
                  },
                  "minimist": {
-                   "version": "1.2.0",
-                   "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
-                   "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=",
+                   "version": "0.0.5",
+                   "resolved": "http://registry.npmjs.org/minimist/-/minimist-0.0.5.tgz",
+                   "integrity": "sha1-16oye87PUY+RBqxrjwA/o7zqhWY=",
                    "dev": true
                  },
                  "object-inspect": {
                    "dev": true
                  },
                  "object-keys": {
-                   "version": "1.0.12",
-                   "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.0.12.tgz",
-                   "integrity": "sha512-FTMyFUm2wBcGHnH2eXmz7tC6IwlqQZ6mVZ+6dm6vZ4IQIHjs6FdNsQBuKGPuUUUY6NfJw2PshC08Tn6LzLDOag==",
+                   "version": "0.4.0",
+                   "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-0.4.0.tgz",
+                   "integrity": "sha1-KKaq50KN0sOpLz2V8hM13SBOAzY=",
                    "dev": true
                  },
                  "once": {
                    "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
                    "dev": true,
                    "requires": {
-                     "wrappy": "1.0.2"
+                     "wrappy": "1"
                    }
                  },
                  "path-is-absolute": {
                    "version": "1.0.1",
-                   "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+                   "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.5",
-                   "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.5.tgz",
-                   "integrity": "sha1-PBrfhx6pzWyUMbbqK9dKD/BVxME=",
+                   "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": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz",
+                   "resolved": "http://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz",
                    "integrity": "sha1-fPTFTvZI44EwhMY23SB54WbAgdk=",
                    "dev": true,
                    "requires": {
-                     "core-util-is": "1.0.2",
-                     "inherits": "2.0.3",
+                     "core-util-is": "~1.0.0",
+                     "inherits": "~2.0.1",
                      "isarray": "0.0.1",
-                     "string_decoder": "0.10.31"
+                     "string_decoder": "~0.10.x"
                    }
                  },
                  "requirejs": {
                  },
                  "resolve": {
                    "version": "1.7.1",
-                   "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.7.1.tgz",
+                   "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"
+                     "path-parse": "^1.0.5"
                    }
                  },
                  "resumer": {
                    "integrity": "sha1-8ej0YeQGS6Oegq883CqMiT0HZ1k=",
                    "dev": true,
                    "requires": {
-                     "through": "2.3.8"
+                     "through": "~2.3.4"
                    }
                  },
                  "sprintf": {
                    "integrity": "sha1-0E3iyJ4Tf019IG8Ia17S+ua+jOo=",
                    "dev": true,
                    "requires": {
-                     "define-properties": "1.1.2",
-                     "es-abstract": "1.12.0",
-                     "function-bind": "1.1.1"
+                     "define-properties": "^1.1.2",
+                     "es-abstract": "^1.5.0",
+                     "function-bind": "^1.0.2"
                    }
                  },
                  "string_decoder": {
                    "version": "0.10.31",
-                   "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz",
+                   "resolved": "http://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz",
                    "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=",
                    "dev": true
                  },
                    "integrity": "sha1-pOrhkMENdsehEZIf84u+TVjwnuo=",
                    "dev": true,
                    "requires": {
-                     "inherits": "2.0.3",
-                     "readable-stream": "1.1.14"
+                     "inherits": "~2.0.1",
+                     "readable-stream": "~1.1.11"
                    }
                  },
                  "tape": {
                    "integrity": "sha512-6fKIXknLpoe/Jp4rzHKFPpJUHDHDqn8jus99IfPnHIjyz78HYlefTGD3b5EkbQzuLfaEvmfPK3IolLgq2xT3kw==",
                    "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"
+                     "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": "https://registry.npmjs.org/through/-/through-2.3.8.tgz",
+                   "resolved": "http://registry.npmjs.org/through/-/through-2.3.8.tgz",
                    "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=",
                    "dev": true
                  },
                  "through2": {
                    "version": "0.2.3",
-                   "resolved": "https://registry.npmjs.org/through2/-/through2-0.2.3.tgz",
+                   "resolved": "http://registry.npmjs.org/through2/-/through2-0.2.3.tgz",
                    "integrity": "sha1-6zKE2k6jEbbMis42U3SKUqvyWj8=",
                    "dev": true,
                    "requires": {
-                     "readable-stream": "1.1.14",
-                     "xtend": "2.1.2"
+                     "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.1.6",
-                   "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.1.6.tgz",
-                   "integrity": "sha512-tDMYfVtvpb96msS1lDX9MEdHrW4yOuZ4Kdc4Him9oU796XldPYF/t2+uKoX0BBa0hXXwDlqYQbXY5Rzjzc5hBA==",
+                   "version": "3.2.2",
+                   "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.2.2.tgz",
+                   "integrity": "sha512-VCj5UiSyHBjwfYacmDuc/NOk4QQixbE+Wn7MFJuS0nRuPQbof132Pw4u53dm264O8LPc2MVsc7RJNml5szurkg==",
                    "dev": true
                  },
                  "wrappy": {
                    "integrity": "sha1-bv7MKk2tjmlixJAbM3znuoe10os=",
                    "dev": true,
                    "requires": {
-                     "object-keys": "0.4.0"
-                   },
-                   "dependencies": {
-                     "object-keys": {
-                       "version": "0.4.0",
-                       "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-0.4.0.tgz",
-                       "integrity": "sha1-KKaq50KN0sOpLz2V8hM13SBOAzY=",
-                       "dev": true
+                     }
+                     "object-keys": "~0.4.0"
                    }
                  }
                }

package.json +8 -3

                "publishConfig": {
                  "access": "public"
                },
-               "dependencies": {
-                 "dojo": "^1.10.0"
+               "peerDependencies": {
+                 "dojo": "^1.10.0",
+                 "tslib": "latest"
                },
                "devDependencies": {
                  "typescript": "latest",
                  "tape": "latest",
                  "@types/tape": "latest",
+                 "@types/requirejs": "latest",
+                 "@types/node": "latest",
                  "requirejs": "latest",
-                 "faucet": "latest"
+                 "faucet": "latest",
+                 "dojo": "^1.10.0",
+                 "tslib": "latest"
                },
                "types": "main.d.ts"
              }

settings.gradle +1 -1

              //include 'sub-project-name'
-             rootProject.name = 'implab-core'
  No newline at end of file
+             rootProject.name = 'core'
  No newline at end of file

src/amd/js/Uri.js ~~src/js/Uri.js~~ renamed 0 0

NO CONTENT: file renamed from src/js/Uri.js to src/amd/js/Uri.js

src/amd/js/data/DataContext.js ~~src/js/data/DataContext.js~~ renamed 0 0

	1		NO CONTENT: file renamed from src/js/data/DataContext.js to src/amd/js/data/DataContext.js

NO CONTENT: file renamed from src/js/data/DataContext.js to src/amd/js/data/DataContext.js

src/amd/js/data/MapSchema.js ~~src/js/data/MapSchema.js~~ renamed 0 0

NO CONTENT: file renamed from src/js/data/MapSchema.js to src/amd/js/data/MapSchema.js

src/amd/js/data/ObjectStore.js ~~src/js/data/ObjectStore.js~~ renamed 0 0

NO CONTENT: file renamed from src/js/data/ObjectStore.js to src/amd/js/data/ObjectStore.js

src/amd/js/data/RestStore.js ~~src/js/data/RestStore.js~~ renamed 0 0

NO CONTENT: file renamed from src/js/data/RestStore.js to src/amd/js/data/RestStore.js

src/amd/js/data/StatefullStoreAdapter.js ~~src/js/data/StatefullStoreAdapter.js~~ renamed 0 0

NO CONTENT: file renamed from src/js/data/StatefullStoreAdapter.js to src/amd/js/data/StatefullStoreAdapter.js

src/amd/js/data/StoreAdapter.js ~~src/js/data/StoreAdapter.js~~ renamed 0 0

NO CONTENT: file renamed from src/js/data/StoreAdapter.js to src/amd/js/data/StoreAdapter.js

src/amd/js/data/_ModelBase.js ~~src/js/data/_ModelBase.js~~ renamed 0 0

NO CONTENT: file renamed from src/js/data/_ModelBase.js to src/amd/js/data/_ModelBase.js

src/amd/js/data/_StatefulModelMixin.js ~~src/js/data/_StatefulModelMixin.js~~ renamed 0 0

NO CONTENT: file renamed from src/js/data/_StatefulModelMixin.js to src/amd/js/data/_StatefulModelMixin.js

src/amd/js/data/declare-model.js ~~src/js/data/declare-model.js~~ renamed 0 0

NO CONTENT: file renamed from src/js/data/declare-model.js to src/amd/js/data/declare-model.js

src/amd/js/declare/_load.js ~~src/js/declare/_load.js~~ renamed 0 0

NO CONTENT: file renamed from src/js/declare/_load.js to src/amd/js/declare/_load.js

src/amd/js/declare/override.js ~~src/js/declare/override.js~~ renamed 0 0

NO CONTENT: file renamed from src/js/declare/override.js to src/amd/js/declare/override.js

src/amd/js/log/trace.js ~~src/js/log/trace.js~~ renamed 0 0

NO CONTENT: file renamed from src/js/log/trace.js to src/amd/js/log/trace.js

src/amd/js/messaging/Client.js ~~src/js/messaging/Client.js~~ renamed 0 0

NO CONTENT: file renamed from src/js/messaging/Client.js to src/amd/js/messaging/Client.js

src/amd/js/messaging/Destination.js ~~src/js/messaging/Destination.js~~ renamed 0 0

NO CONTENT: file renamed from src/js/messaging/Destination.js to src/amd/js/messaging/Destination.js

src/amd/js/messaging/Listener.js ~~src/js/messaging/Listener.js~~ renamed 0 0

NO CONTENT: file renamed from src/js/messaging/Listener.js to src/amd/js/messaging/Listener.js

src/amd/js/messaging/Session.js ~~src/js/messaging/Session.js~~ renamed 0 0

NO CONTENT: file renamed from src/js/messaging/Session.js to src/amd/js/messaging/Session.js

src/main/ts/Cancellation.ts ~~src/ts/Cancellation.ts~~ renamed +12 -13

                          else
                              this._cbs.push(cb);
-                         let me = this;
+                         const me = this;
                          return {
-                     	destroy() {
-                     	    me._unregister(cb);
+                     	}
+                             destroy() {
+                                 me._unregister(cb);
+                             }
                          };
                      }
                  }
                  private _unregister(cb) {
-             	if(this._cbs) {
-             	    let i = this._cbs.indexOf(cb);
-             	    if ( i>=0 )
-             		this._cbs.splice(i,1);
+             	}
+                     if (this._cbs) {
+                         const i = this._cbs.indexOf(cb);
+                         if (i >= 0)
+                             this._cbs.splice(i, 1);
+                     }
                  }
                  private _cancel(reason) {
                      this._reason = (reason = reason || new Error("Operation cancelled"));
                      if (this._cbs) {
                          this._cbs.forEach(cb => cb(reason));
                          this._cbs = null;
                      },
                      register(_cb: (e: any) => void): IDestroyable {
-                 	    return destroyed;
+                         return destroyed;
                      }
                  };
-             }
  No newline at end of file
+             }

src/main/ts/Observable.ts ~~src/ts/Observable.ts~~ renamed +31 -42

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

src/main/ts/Uuid.ts ~~src/ts/Uuid.ts~~ renamed +50 -63

              //     Copyright (c) 2010-2012 Robert Kieffer
              //     MIT License - http://opensource.org/licenses/mit-license.php
-             declare var window: any;
+             declare const window: any;
+             declare const require;
+             declare const Buffer;
-             let _window : any = 'undefined' !== typeof window ? window : null;
+             const _window: any = "undefined" !== typeof window ? window : null;
              // Unique ID creation requires a high quality random # generator. We
              // feature
              function setupBrowser() {
                  // Allow for MSIE11 msCrypto
-                 let _crypto = _window.crypto || _window.msCrypto;
+                 const _crypto = _window.crypto || _window.msCrypto;
                  if (!_rng && _crypto && _crypto.getRandomValues) {
                      // WHATWG crypto-based RNG - http://wiki.whatwg.org/wiki/Crypto
                      //
                      // Moderately fast, high quality
                      try {
-                         let _rnds8 = new Uint8Array(16);
+                         const _rnds8 = new Uint8Array(16);
                          _rng = function whatwgRNG() {
                              _crypto.getRandomValues(_rnds8);
                              return _rnds8;
                      // If all else fails, use Math.random(). It's fast, but is of
                      // unspecified
                      // quality.
-                     let  _rnds = new Array(16);
-                     _rng = function () {
-                         for (var i = 0, r; i < 16; i++) {
+                     const _rnds = new Array(16);
+                     _rng = () => {
+                         for (let i = 0, r; i < 16; i++) {
                              if ((i & 0x03) === 0) {
                                  r = Math.random() * 0x100000000;
                              }
                          return _rnds;
                      };
-                     if ('undefined' !== typeof console && console.warn) {
+                     if ("undefined" !== typeof console && console.warn) {
                          console.warn("[SECURITY] node-uuid: crypto not usable, falling back to insecure Math.random()");
                      }
                  }
                  // http://nodejs.org/docs/v0.6.2/api/crypto.html
                  //
                  // Moderately fast, high quality
-                 if ('function' === typeof require) {
+                 if ("function" === typeof require) {
                      try {
-                         let _rb = require('crypto').randomBytes;
-                         _rng = _rb && function () {
-                             return _rb(16);
-                         };
+                         const _rb = require("crypto").randomBytes;
+                         _rng = _rb && (() => _rb(16));
                          _rng();
                      } catch (e) { /**/ }
                  }
              }
              // Buffer class to use
-             let BufferClass = ('function' === typeof Buffer) ? Buffer : Array;
+             const BufferClass = ("function" === typeof Buffer) ? Buffer : Array;
              // Maps for number <-> hex string conversion
-             let _byteToHex = [];
-             let _hexToByte = {};
+             const _byteToHex = [];
+             const _hexToByte = {};
              for (let i = 0; i < 256; i++) {
                  _byteToHex[i] = (i + 0x100).toString(16).substr(1);
                  _hexToByte[_byteToHex[i]] = i;
              }
              // **`parse()` - Parse a UUID into it's component bytes**
-             function parse(s, buf?, offset?) : Array<string> {
-                 let i = (buf && offset) || 0,        ii = 0;
+             export function _parse(s, buf?, offset?): Array<string> {
+                 const i = (buf && offset) || 0; let ii = 0;
                  buf = buf || [];
-                 s.toLowerCase().replace(/[0-9a-f]{2}/g, function (oct) {
+                 s.toLowerCase().replace(/[0-9a-f]{2}/g, oct => {
                      if (ii < 16) { // Don't overflow!
                          buf[i + ii++] = _hexToByte[oct];
                      }
              }
              // **`unparse()` - Convert UUID byte array (ala parse()) into a string**
-             function unparse(buf, offset?) : string {
-                 let i = offset || 0,        bth = _byteToHex;
+             function _unparse(buf, offset?): string {
+                 let i = offset || 0; const bth = _byteToHex;
                  return bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]] +
-                     bth[buf[i++]] + '-' + bth[buf[i++]] + bth[buf[i++]] + '-' +
-                     bth[buf[i++]] + bth[buf[i++]] + '-' + bth[buf[i++]] +
-                     bth[buf[i++]] + '-' + bth[buf[i++]] + bth[buf[i++]] +
+                     bth[buf[i++]] + "-" + bth[buf[i++]] + bth[buf[i++]] + "-" +
+                     bth[buf[i++]] + bth[buf[i++]] + "-" + bth[buf[i++]] +
+                     bth[buf[i++]] + "-" + bth[buf[i++]] + bth[buf[i++]] +
                      bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]];
              }
              // and http://docs.python.org/library/uuid.html
              // random #'s we need to init node and clockseq
-             let _seedBytes = _rng();
+             const _seedBytes = _rng();
              // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit =
              // 1)
-             let _nodeId = [
+             const _nodeId = [
                  _seedBytes[0] | 0x01,
                  _seedBytes[1],
                  _seedBytes[2],
              let _clockseq = (_seedBytes[6] << 8 | _seedBytes[7]) & 0x3fff;
              // Previous uuid creation time
-             let _lastMSecs = 0,    _lastNSecs = 0;
+             let _lastMSecs = 0; let _lastNSecs = 0;
              // See https://github.com/broofa/node-uuid for API details
-             function v1(options?, buf?, offset?) : string {
+             export function _v1(options?, buf?, offset?): string {
                  let i = buf && offset || 0;
-                 let b = buf || [];
+                 const b = buf || [];
                  options = options || {};
                  let nsecs = (options.nsecs != null) ? options.nsecs : _lastNSecs + 1;
                  // Time since last uuid creation (in msecs)
-                 let dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs) / 10000;
+                 const dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs) / 10000;
                  // Per 4.2.1.2, Bump clockseq on clock regression
                  if (dt < 0 && options.clockseq == null) {
                  // Per 4.2.1.2 Throw error if too many uuids are requested
                  if (nsecs >= 10000) {
                      throw new Error(
-                         'uuid.v1(): Can\'t create more than 10M uuids/sec');
+                         "uuid.v1(): Can't create more than 10M uuids/sec");
                  }
                  _lastMSecs = msecs;
                  msecs += 12219292800000;
                  // `time_low`
-                 let tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
+                 const tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
                  b[i++] = tl >>> 24 & 0xff;
                  b[i++] = tl >>> 16 & 0xff;
                  b[i++] = tl >>> 8 & 0xff;
                  b[i++] = tl & 0xff;
                  // `time_mid`
-                 let tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;
+                 const tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;
                  b[i++] = tmh >>> 8 & 0xff;
                  b[i++] = tmh & 0xff;
                  b[i++] = clockseq & 0xff;
                  // `node`
-                 let node = options.node || _nodeId;
+                 const node = options.node || _nodeId;
                  for (let n = 0; n < 6; n++) {
                      b[i + n] = node[n];
                  }
-                 return buf ? buf : unparse(b);
+                 return buf ? buf : _unparse(b);
              }
              // **`v4()` - Generate random UUID**
              // See https://github.com/broofa/node-uuid for API details
-             function v4(options?, buf?, offset?) : string {
+             export function _v4(options?, buf?, offset?): string {
                  // Deprecated - 'format' argument, as supported in v1.2
-                 let i = buf && offset || 0;
+                 const i = buf && offset || 0;
-                 if (typeof (options) === 'string') {
-                     buf = (options === 'binary') ? new BufferClass(16) : null;
+                 if (typeof (options) === "string") {
+                     buf = (options === "binary") ? new BufferClass(16) : null;
                      options = null;
                  }
                  options = options || {};
-                 let rnds = options.random || (options.rng || _rng)();
+                 const rnds = options.random || (options.rng || _rng)();
                  // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
                  rnds[6] = (rnds[6] & 0x0f) | 0x40;
                      }
                  }
-                 return buf || unparse(rnds);
+                 return buf || _unparse(rnds);
+             }
+             export function Uuid() {
+                 return _v4();
              }
-             // Export public API
-             const empty = "00000000-0000-0000-0000-000000000000";
-             interface uuid {
-                 (options?, buf?, offset?) : string;
-                 v1(options?, buf?, offset?) : string;
-                 v4(options?, buf?, offset?) : string;
-                 readonly empty: string;
-                 parse(s, buf?, offset?) : Array<string>;
-                 unparse(buf, offset?) : string;
+             export namespace Uuid {
+                 export const v4 = _v4;
+                 export const v1 = _v1;
+                 export const empty = "00000000-0000-0000-0000-000000000000";
+                 export const parse = _parse;
              }
-             export = <uuid>(() =>{
-                 var f : any = function(options?, buf?, offset?) : string {
-                     return v4(options, buf, offset);
-                 };
-                 f.v1 = v1;
-                 f.v4 = v4;
-                 f.empty = empty;
-                 f.parse = parse;
-                 f.unparse = unparse;
-                 return f;
-             })();
  No newline at end of file

src/main/ts/components/ActivatableMixin.ts ~~src/ts/components/ActivatableMixin.ts~~ renamed +7 -7

-             import { IActivationController, IActivatable, ICancellation } from '../interfaces';
-             import { AsyncComponent } from './AsyncComponent';
-             import { Cancellation } from '../Cancellation';
-             import { TraceSource } from '../log/TraceSource';
+             import { IActivationController, IActivatable, ICancellation } from "../interfaces";
+             import { AsyncComponent } from "./AsyncComponent";
+             import { Cancellation } from "../Cancellation";
+             import { TraceSource } from "../log/TraceSource";
              type Constructor<T = {}> = new (...args: any[]) => T;
-             const log = TraceSource.get('@implab/core/components/ActivatableMixin');
+             const log = TraceSource.get("@implab/core/components/ActivatableMixin");
              export function ActivatableMixin<TBase extends Constructor<AsyncComponent>>(Base: TBase) {
                  return class extends Base implements IActivatable {
                              log.error("Suppressed onDeactivated error: {0}", e);
                          }
                      }
+                 }
+                 };
              }
-             export const traceSource = log;
  No newline at end of file
+             export const traceSource = log;

src/main/ts/components/AsyncComponent.ts ~~src/ts/components/AsyncComponent.ts~~ renamed +5 -5

                  _completion: Promise<void> = Promise.resolve();
-                 getCompletion() { return this._completion };
+                 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;
-                     let inner = new Cancellation(cancel => {
+                     const inner = new Cancellation(cancel => {
                          this._cancel = cancel;
                          h = ct.register(cancel);
                      });
                      // TODO create cancellation source here
-                     let guard = async () => {
+                     const guard = async () => {
                          try {
                              await op(inner);
                          } finally {
                              destroy(h);
                              this._cancel = null;
                          }
+                     }
+                     };
                      return this._completion = guard();
                  }
                      if (this._cancel)
                          this._cancel(reason);
                  }
-             }
  No newline at end of file
+             }

src/main/ts/interfaces.ts ~~src/ts/interfaces.ts~~ renamed +14 -6

+             export type Constructor<T = {}> = new (...args: any[]) => T;
+             export type Factory<T = {}> = (...args: any[]) => T;
+             export interface MapOf<T> {
+                 [key: string]: T;
+             }
              export interface IDestroyable {
                  destroy();
              }
                   * Starts the component activation
                   * @param ct cancellation token for this operation
                   */
-                 activate(ct?: ICancellation) : Promise<void>;
+                 activate(ct?: ICancellation): Promise<void>;
                  /**
                   * Starts the component deactivation
                   * @param ct cancellation token for this operation
                   */
-                 deactivate(ct?: ICancellation) : Promise<void>;
+                 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
              }
              export interface IObservable<T> {
-                 on(next: (x:T) => void, error?: (e:any) => void, complete?:() => void): IDestroyable;
-                 next(ct?: ICancellation) : Promise<T>;
-             }
  No newline at end of file
+                 on(next: (x: T) => void, error?: (e: any) => void, complete?: () => void): IDestroyable;
+                 next(ct?: ICancellation): Promise<T>;
+             }

src/main/ts/log/TraceSource.ts ~~src/ts/log/TraceSource.ts~~ renamed +20 -80

-             import * as format from '../text/format'
-             import { argumentNotNull } from '../safe';
-             import { Observable } from '../Observable'
-             import { IDestroyable } from '../interfaces';
+             import { Observable } from "../Observable";
+             import { Registry } from "./Registry";
+             import { format } from "../text/StringFormat";
              export const DebugLevel = 400;
              export const SilentLevel = 0;
-             export class TraceEvent {
+             export interface TraceEvent {
                  readonly source: TraceSource;
-                 readonly level: Number;
+                 readonly level: number;
                  readonly arg: any;
-                 constructor(source: TraceSource, level: Number, arg: any) {
-                     this.source = source;
-                     this.level = level;
-                     this.arg = arg;
+                 }
+             }
-             class Registry {
-                 static readonly instance = new Registry();
-                 private _registry: object = new Object();
-                 private _listeners: object = new Object();
-                 private _nextCookie: number = 1;
-                 get(id: any): TraceSource {
-                     argumentNotNull(id, "id");
-                     if (this._registry[id])
-                         return this._registry[id];
-                     var source = new TraceSource(id);
-                     this._registry[id] = source;
-                     this._onNewSource(source);
-                     return source;
+                 }
-                 add(id: any, source: TraceSource) {
-                     argumentNotNull(id, "id");
-                     argumentNotNull(source, "source");
-                     this._registry[id] = source;
-                     this._onNewSource(source);
+                 }
-                 _onNewSource(source: TraceSource) {
-                     for (let i in this._listeners)
-                         this._listeners[i].call(null, source);
+                 }
-                 on(handler: (source: TraceSource) => void): IDestroyable {
-                     argumentNotNull(handler, "handler");
-                     var me = this;
-                     var cookie = this._nextCookie++;
-                     this._listeners[cookie] = handler;
-                     for (let i in this._registry)
-                         handler(this._registry[i]);
-                     return {
-                         destroy() {
-                             delete me._listeners[cookie];
+                         }
-                     };
+                 }
              }
              export class TraceSource {
-                 readonly id: any
+                 readonly id: any;
-                 level: number
+                 level: number;
-                 readonly events: Observable<TraceEvent>
+                 readonly events: Observable<TraceEvent>;
-                 _notifyNext: (arg: TraceEvent) => void
+                 _notifyNext: (arg: TraceEvent) => void;
                  constructor(id: any) {
                      this.id = id || new Object();
-                     this.events = new Observable((next) => {
+                     this.events = new Observable(next => {
                          this._notifyNext = next;
-                     })
+                     });
                  }
                  protected emit(level: number, arg: any) {
-                     this._notifyNext(new TraceEvent(this, level, arg));
+                     this._notifyNext({ source: this, level, arg });
                  }
                  isDebugEnabled() {
                  debug(msg: string, ...args: any[]) {
                      if (this.isEnabled(DebugLevel))
-                         this.emit(DebugLevel, format.apply(null, arguments));
+                         this.emit(DebugLevel, format(msg, args));
                  }
                  isLogEnabled() {
                  log(msg: string, ...args: any[]) {
                      if (this.isEnabled(LogLevel))
-                         this.emit(LogLevel, format.apply(null, arguments));
+                         this.emit(LogLevel, format(msg, args));
                  }
                  isWarnEnabled() {
                  warn(msg: string, ...args: any[]) {
                      if (this.isEnabled(WarnLevel))
-                         this.emit(WarnLevel, format.apply(null, arguments));
+                         this.emit(WarnLevel, format(msg, args));
                  }
                  /**
                  /**
                   * Traces a error.
+                  *
+                  *
                   * @param msg the message.
                   * @param args parameters which will be substituted in the message.
                   */
                  /**
                   * Checks whether the specified level is enabled for this
                   * trace source.
+                  *
+                  *
                   * @param level the trace level which should be checked.
                   */
                  isEnabled(level: number) {
                  /**
                   * 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.
                   */
                  /**
                   * 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) {
                  /**
                   * 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 ~~src/ts/log/writers/ConsoleWriter.ts~~ renamed +13 -6

              import { IObservable, IDestroyable, ICancellation } from "../../interfaces";
+             import { TraceEvent, LogLevel, WarnLevel, DebugLevel } from "../TraceSource";
              import { Cancellation } from "../../Cancellation";
-             import { TraceEvent, LogLevel, WarnLevel } from "../TraceSource";
+             import { destroy } from "../../safe";
              export class ConsoleWriter implements IDestroyable {
                  readonly _subscriptions = new Array<IDestroyable>();
                  writeEvents(source: IObservable<TraceEvent>, ct: ICancellation = Cancellation.none) {
-                     var subscription = source.on(this.writeEvent.bind(this));
+                     const subscription = source.on(this.writeEvent.bind(this));
                      if (ct.isSupported()) {
                          ct.register(subscription.destroy.bind(subscription));
                      }
                  }
                  writeEvent(next: TraceEvent) {
-                     if (next.level >= LogLevel) {
+                     if (next.level >= DebugLevel) {
+                         // tslint:disable-next-line
+                         console.debug(next.source.id.toString(), next.arg);
+                     } else if (next.level >= LogLevel) {
+                         // tslint:disable-next-line
                          console.log(next.source.id.toString(), next.arg);
-                     } else if(next.level >= WarnLevel) {
+                     } else if (next.level >= WarnLevel) {
+                         // tslint:disable-next-line
                          console.warn(next.source.id.toString(), next.arg);
                      } else {
+                         // tslint:disable-next-line
                          console.error(next.source.id.toString(), next.arg);
                      }
                  }
                  destroy() {
-                     this._subscriptions.forEach(x => x.destroy());
+                     this._subscriptions.forEach(destroy);
                  }
-             }
  No newline at end of file
+             }

src/main/ts/main.ts ~~src/ts/main.ts~~ renamed 0 0

NO CONTENT: file renamed from src/ts/main.ts to src/main/ts/main.ts

src/main/ts/safe.ts ~~src/ts/safe.ts~~ renamed +120 -48

+             let _nextOid = 0;
+             const _oid = typeof Symbol === "function" ?
+                 Symbol("__implab__oid__") :
+                 "__implab__oid__";
+             export function oid(instance: object): string {
+                 if (isNull(instance))
+                     return null;
+                 if (_oid in instance)
+                     return instance[_oid];
+                 else
+                     return (instance[_oid] = "oid_" + (++_nextOid));
+             }
              export function argumentNotNull(arg, name) {
                  if (arg === null || arg === undefined)
                      throw new Error("The argument " + name + " can't be null or undefined");
              }
              export function isInteger(arg) {
-                 return parseInt(arg) == arg;
+                 return parseInt(arg, 10) === arg;
              }
              export function isNumber(arg) {
-                 return parseFloat(arg) == arg;
+                 return parseFloat(arg) === arg;
              }
              export function isString(val) {
-                 return typeof (val) == "string" || val instanceof String;
+                 return typeof (val) === "string" || val instanceof String;
+             }
+             export function isPromise(val): val is PromiseLike<any> {
+                 return "then" in val && val.then instanceof Function;
              }
              export function isNullOrEmptyString(str) {
                  if (str === null || str === undefined ||
-                     ((typeof (str) == "string" || str instanceof String) && str.length === 0))
+                     ((typeof (str) === "string" || str instanceof String) && str.length === 0))
                      return true;
              }
-             export function isNotEmptyArray(arg) {
+             export function isNotEmptyArray(arg): arg is Array<any> {
                  return (arg instanceof Array && arg.length > 0);
              }
+             export function getGlobal() {
+                 return this;
+             }
+             export function get(member: string, context?: object) {
+                 argumentNotEmptyString(member, "member");
+                 let that = context || getGlobal();
+                 const parts = member.split(".");
+                 for (const m of parts) {
+                     if (!m)
+                         continue;
+                     if (isNull(that = that[m]))
+                         break;
+                 }
+                 return that;
+             }
              /**
               * Выполняет метод для каждого элемента массива, останавливается, когда
               * либо достигнут конец массива, либо функция <c>cb</c> вернула
               * значение.
+              *
+              *
               * @param {Array | Object} obj массив элементов для просмотра
               * @param {Function} cb функция, вызываемая для каждого элемента
               * @param {Object} thisArg значение, которое будет передано в качестве
               * @returns Результат вызова функции <c>cb</c>, либо <c>undefined</c>
               *          если достигнут конец массива.
               */
-             export function each(obj, cb, thisArg) {
+             export function each(obj, cb, thisArg?) {
                  argumentNotNull(cb, "cb");
-                 var i, x;
                  if (obj instanceof Array) {
-                     for (i = 0; i < obj.length; i++) {
-                         x = cb.call(thisArg, obj[i], i);
+                     for (let i = 0; i < obj.length; i++) {
+                         const x = cb.call(thisArg, obj[i], i);
                          if (x !== undefined)
                              return x;
                      }
                  } else {
-                     var keys = Object.keys(obj);
-                     for (i = 0; i < keys.length; i++) {
-                         var k = keys[i];
-                         x = cb.call(thisArg, obj[k], k);
+                     const keys = Object.keys(obj);
+                     for (const k of keys) {
+                         const x = cb.call(thisArg, obj[k], k);
                          if (x !== undefined)
                              return x;
                      }
                  }
              }
+             /** Copies property values from a source object to the destination and returns
+              * the destination onject.
+              *
+              * @param dest The destination object into which properties from the source
+              *  object will be copied.
+              * @param source The source of values which will be copied to the destination
+              *  object.
+              * @param template An optional parameter specifies which properties should be
+              *  copied from the source and how to map them to the destination. If the
+              *  template is an array it contains the list of property names to copy from the
+              *  source to the destination. In case of object the templates contains the map
+              *  where keys are property names in the source and the values are property
+              *  names in the destination object. If the template isn't specified then the
+              *  own properties of the source are entirely copied to the destination.
+              *
+              */
+             export function mixin<T, S>(dest: T, source: S, template?: string[] | object): T & S {
+                 argumentNotNull(dest, "to");
+                 const _res = dest as T & S;
+                 if (template instanceof Array) {
+                     for (const p of template) {
+                         if (p in source)
+                             _res[p] = source[p];
+                     }
+                 } else if (template) {
+                     const keys = Object.keys(source);
+                     for (const p of keys) {
+                         if (p in template)
+                             _res[template[p]] = source[p];
+                     }
+                 } else {
+                     const keys = Object.keys(source);
+                     for (const p of keys)
+                         _res[p] = source[p];
+                 }
+                 return _res;
+             }
              /** Wraps the specified function to emulate an asynchronous execution.
               * @param{Object} thisArg [Optional] Object which will be passed as 'this' to the function.
               * @param{Function|String} fn [Required] Function wich will be wrapped.
               */
-             export function async(_fn: (...args: any[]) => any, thisArg) : (...args: any[]) => PromiseLike<any> {
+             export function async(_fn: (...args: any[]) => any, thisArg): (...args: any[]) => PromiseLike<any> {
                  let fn = _fn;
-                 if (arguments.length == 2 && !(fn instanceof Function))
+                 if (arguments.length === 2 && !(fn instanceof Function))
                      fn = thisArg[fn];
                  if (fn == null)
                      throw new Error("The function must be specified");
-                 function wrapresult(x, e?) : PromiseLike<any> {
+                 function wrapresult(x, e?): PromiseLike<any> {
                      if (e) {
                          return {
-                             then: function (cb, eb) {
+                             then(cb, eb) {
                                  try {
                                      return eb ? wrapresult(eb(e)) : this;
                                  } catch (e2) {
                          if (x && x.then)
                              return x;
                          return {
-                             then: function (cb) {
+                             then(cb) {
                                  try {
                                      return cb ? wrapresult(cb(x)) : this;
                                  } catch (e2) {
                      }
                  }
-                 return function () {
+                 return (...args) => {
                      try {
-                         return wrapresult(fn.apply(thisArg, arguments));
+                         return wrapresult(fn.apply(thisArg, args));
                      } catch (e) {
                          return wrapresult(null, e);
                      }
                  };
              }
-             export function delegate(target, _method: (string | Function)) {
-                 let method : Function;
+             type _AnyFn = (...args) => any;
+             export function delegate<T, K extends keyof T>(target: T, _method: (K | _AnyFn)) {
+                 let method;
                  if (!(_method instanceof Function)) {
                      argumentNotNull(target, "target");
                      method = target[_method];
+                     if (!(method instanceof Function))
+                         throw new Error("'method' argument must be a Function or a method name");
                  } else {
                      method = _method;
                  }
-                 if (!(method instanceof Function))
-                     throw new Error("'method' argument must be a Function or a method name");
-                 return function () {
-                     return method.apply(target, arguments);
+                 return (...args) => {
+                     return method.apply(target, args);
                  };
              }
              /**
               * Для каждого элемента массива вызывает указанную функцию и сохраняет
               * возвращенное значение в массиве результатов.
+              *
+              *
               * @remarks cb может выполняться асинхронно, при этом одновременно будет
               *          только одна операция.
+              *
+              *
               * @async
               */
              export function pmap(items, cb) {
                  argumentNotNull(cb, "cb");
-                 if (items && items.then instanceof Function)
-                     return items.then(function (data) {
-                         return pmap(data, cb);
-                     });
+                 if (isPromise(items))
+                     return items.then(data => pmap(data, cb));
                  if (isNull(items) || !items.length)
                      return items;
-                 var i = 0,
-                     result = [];
+                 let i = 0;
+                 const result = [];
                  function next() {
-                     var r, ri;
+                     let r;
+                     let ri;
                      function chain(x) {
                          result[ri] = x;
                          r = cb(items[i], i);
                          ri = i;
                          i++;
-                         if (r && r.then) {
+                         if (isPromise(r)) {
                              return r.then(chain);
                          } else {
                              result[ri] = r;
              /**
               * Выбирает первый элемент из последовательности, или обещания, если в
               * качестве параметра используется обещание, оно должно вернуть массив.
+              *
+              *
               * @param {Function} cb обработчик результата, ему будет передан первый
               *                  элемент последовательности в случае успеха
               * @param {Function} err обработчик исключения, если массив пустой, либо
               *                  не массив
+              *
+              *
               * @remarks Если не указаны ни cb ни err, тогда функция вернет либо
               *          обещание, либо первый элемент.
               * @async
               */
-             export function first(sequence: any, cb: Function, err: Function) {
+             export function first(sequence, cb: (x) => any, err: (x) => any) {
                  if (sequence) {
-                     if (sequence.then instanceof Function) {
-                         return sequence.then(function (res) {
-                             return first(res, cb, err);
-                         }, err);
+                     if (isPromise(sequence)) {
+                         return sequence.then(res => first(res, cb, err));
                      } else if (sequence && "length" in sequence) {
                          if (sequence.length === 0) {
                              if (err)
                      throw new Error("The sequence is required");
              }
-             export function destroy(d: any) {
-                 if (d && 'destroy' in d)
+             export function destroy(d) {
+                 if (d && "destroy" in d)
                      d.destroy();
-             }
  No newline at end of file
+             }

src/test/js/example.js ~~test/js/example.js~~ renamed 0 0

NO CONTENT: file renamed from test/js/example.js to src/test/js/example.js

src/test/js/plan.js ~~test/js/plan.js~~ renamed +8 -3

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

src/test/js/run-amd-tests.js ~~run-amd-tests.js~~ renamed +3 -8

              requirejs.config({
                  baseUrl: '.',
-                 map: {
-                     "*": {
-                         "@implab/core": "core"
+                     }
-                 },
                  packages: [{
-                         name: "core",
-                         location: "build/dist"
+                         name: "@implab/core",
+                         location: "build/dist/amd"
                      },
                      {
                          name: "test",
-                         location: "build/test"
+                         location: "build/test/amd"
                      },
                      {
                          name: "dojo",

src/test/js/trace-test.js ~~test/js/trace-test.js~~ renamed +1 -1

                  var sourceId = '73a633f3-eab8-49b0-8601-07cae710f234';
                  var sourceId2 = '3ba9c7cd-ed77-437b-9a2f-1cbeb1226b5b';
                  tape('Load TraceSource for the module', function(t) {
-                     require(["core/log/trace!" + sourceId, "core/log/TraceSource"], function(trace, TraceSource_1) {
+                     require(["@implab/core/log/trace!" + sourceId, "@implab/core/log/TraceSource"], function(trace, TraceSource_1) {
                          var TraceSource = TraceSource_1.TraceSource;
                          t.equal(trace && trace.id, sourceId, "trace should be taken from the loader plugin parameter");

src/test/ts/ActivatableTests.ts ~~test/ts/ActivatableTests.ts~~ renamed +15 -63

-             import * as tape from 'tape';
-             import { ActivatableMixin} from '@implab/core/components/ActivatableMixin';
-             import { AsyncComponent } from '@implab/core/components/AsyncComponent';
-             import { IActivationController, IActivatable, ICancellation } from '@implab/core/interfaces';
-             import { Cancellation } from '@implab/core/Cancellation';
-             class SimpleActivatable extends ActivatableMixin(AsyncComponent) {
+             }
-             class MockActivationController implements IActivationController {
-                 _active: IActivatable = null;
-                 getActive() : IActivatable {
-                     return this._active;
+                 }
+             import * as tape from "tape";
+             import { MockActivationController } from "./mock/MockActivationController";
+             import { SimpleActivatable } from "./mock/SimpleActivatable";
-                 async deactivate() {
-                     if (this._active)
-                         await this._active.deactivate();
-                     this._active = null;
+                 }
-                 async activate(component: IActivatable) {
-                     if (!component || component.isActive())
-                         return;
-                     component.setActivationController(this);
-                     await component.activate();
+                 }
-                 async activating(component: IActivatable, ct: ICancellation = Cancellation.none) {
-                     if (component != this._active)
-                         await this.deactivate();
+                 }
+             tape("simple activation", async t => {
-                 async activated(component: IActivatable, ct: ICancellation = Cancellation.none) {
-                     this._active = component;
+                 }
-                 async deactivating(component: IActivatable, ct: ICancellation = Cancellation.none) {
+                 }
+                 const a = new SimpleActivatable();
+                 t.false(a.isActive());
-                 async deactivated(component: IActivatable, ct: ICancellation = Cancellation.none) {
-                     if (this._active == component)
-                         this._active = null;
+                 }
+             }
-             tape('simple activation',async function(t){
-                 let a = new SimpleActivatable();
-                 t.false(a.isActive());
                  await a.activate();
                  t.true(a.isActive());
                  await a.deactivate();
                  t.false(a.isActive());
                  t.end();
              });
-             tape('controller activation', async function(t) {
+             tape("controller activation", async t => {
-                 let a = new SimpleActivatable();
-                 let c = new MockActivationController();
+                 const a = new SimpleActivatable();
+                 const c = new MockActivationController();
                  t.false(a.isActive(), "the component is not active by default");
                  t.assert(c.getActive() == null, "the activation controller doesn't have an active component by default");
                  t.end();
              });
-             tape('handle error in onActivating', async function(t) {
-                 let a = new SimpleActivatable();
+             tape("handle error in onActivating", async t => {
+                 const a = new SimpleActivatable();
-                 a.onActivating = async function() {
-                     throw "Should fail";
+                 a.onActivating = async () => {
+                     throw new Error("Should fail");
                  };
                  try {
                  t.false(a.isActive(), "the component should remain inactive");
                  t.end();
-             });
  No newline at end of file
+             });

src/test/ts/CancellationTests.ts ~~test/ts/CancellationTests.ts~~ renamed +17 -17

-             import * as tape from 'tape';
-             import { Cancellation } from '@implab/core/Cancellation';
-             import { ICancellation } from '@implab/core/interfaces';
-             import { delay } from './TestTraits';
+             import * as tape from "tape";
+             import { Cancellation } from "@implab/core/Cancellation";
+             import { ICancellation } from "@implab/core/interfaces";
+             import { delay } from "./TestTraits";
-             tape('standalone cancellation', async t => {
+             tape("standalone cancellation", async t => {
                  let doCancel: (e) => void;
-                 let ct = new Cancellation(cancel => {
+                 const ct = new Cancellation(cancel => {
                      doCancel = cancel;
                  });
                  let counter = 0;
-                 let reason = "BILL";
+                 const reason = "BILL";
                  t.true(ct.isSupported(), "Cancellation must be supported");
                  t.false(ct.isRequested(), "Cancellation shouldn't be requested");
                  t.equals(counter, 2, "The callback should be triggered immediately");
                  let msg;
-                 ct.register((e) => msg = e);
+                 ct.register(e => msg = e);
                  t.equals(msg, reason, "The cancellation reason should be passed to callback");
                  try {
                  t.end();
              });
-             tape('async cancellation', async t => {
+             tape("async cancellation", async t => {
-                 let ct = new Cancellation(cancel => {
+                 const ct = new Cancellation(cancel => {
                      cancel("STOP!");
                  });
                  t.end();
              });
-             tape('cancel with external event', async t => {
-                 let ct = new Cancellation((cancel) => {
-                     setTimeout(x => cancel('STOP!'), 0);
-                 })
+             tape("cancel with external event", async t => {
+                 const ct = new Cancellation(cancel => {
+                     setTimeout(x => cancel("STOP!"), 0);
+                 });
                  try {
                      await delay(10000, ct);
                  t.end();
              });
-             tape('operation normal flow', async t => {
+             tape("operation normal flow", async t => {
                  let htimeout;
-                 let ct = new Cancellation((cancel) => {
+                 const ct = new Cancellation(cancel => {
                      htimeout = setTimeout(() => cancel("STOP!"), 1000);
                  });
                  }
                  t.end();
-             });
  No newline at end of file
+             });

src/test/ts/ObservableTests.ts ~~test/ts/ObservableTests.ts~~ renamed +19 -20

-             import { TraceSource, DebugLevel } from '@implab/core/log/TraceSource'
-             import * as tape from 'tape';
-             import { TapeWriter, delay } from './TestTraits';
-             import { Observable } from '@implab/core/Observable';
-             import { IObservable } from '@implab/core/interfaces';
-             let trace = TraceSource.get("ObservableTests");
+             import { TraceSource, DebugLevel } from "@implab/core/log/TraceSource";
+             import * as tape from "tape";
+             import { TapeWriter, delay } from "./TestTraits";
+             import { Observable } from "@implab/core/Observable";
+             import { IObservable } from "@implab/core/interfaces";
-             tape('events sequence example', async t => {
+             const trace = TraceSource.get("ObservableTests");
+             tape("events sequence example", async t => {
-                 let events: IObservable<number>
+                 let events: IObservable<number>;
-                 let done = new Promise<void>((resolve) => {
-                     events = new Observable<number>(async (notify, fail, complete) => {
+                 const done = new Promise<void>(resolve => {
+                     events = new Observable<number>(async (notify, fail, finish) => {
                          for (let i = 0; i < 10; i++) {
                              await delay(0);
                              notify(i);
                          }
-                         complete();
+                         finish();
                          resolve();
                      });
                  });
                  let complete = false;
                  events.on(x => count = count + x, null, () => complete = true);
-                 let first = await events.next();
+                 const first = await events.next();
                  t.equals(first, 0, "the first event");
                  t.false(complete, "the sequence is not complete");
                  t.end();
              });
-             tape('event sequence termination', async t => {
-                 let events: IObservable<number>
+             tape("event sequence termination", async t => {
+                 let events: IObservable<number>;
-                 let done = new Promise<void>((resolve) => {
+                 const done = new Promise<void>(resolve => {
                      events = new Observable<number>(async (notify, fail, complete) => {
                          await delay(0);
                          notify(1);
                  });
                  let count = 0;
-                 events.on(() => {}, (e) => count++, () => count++);
+                 events.on(() => {}, e => count++, () => count++);
-                 let first = await events.next();
+                 const first = await events.next();
                  t.equals(first, 1, "the first message");
                  try {
                      await events.next();
                      t.fail("shoud throw an exception");
-                 } catch(e) {
+                 } catch (e) {
                      t.pass("the sequence is terminated");
                  }
                  t.equals(count, 1, "the sequence must be terminated once");
                  t.end();
-             });
  No newline at end of file
+             });

src/test/ts/TestTraits.ts ~~test/ts/TestTraits.ts~~ renamed +56 -29

              import { IObservable, ICancellation, IDestroyable } from "@implab/core/interfaces";
              import { Cancellation } from "@implab/core/Cancellation";
-             import { TraceEvent, LogLevel, WarnLevel } from "@implab/core/log/TraceSource";
-             import * as tape from 'tape';
+             import { TraceEvent, LogLevel, WarnLevel, DebugLevel, TraceSource } from "@implab/core/log/TraceSource";
+             import * as tape from "tape";
              import { argumentNotNull } from "@implab/core/safe";
              export class TapeWriter implements IDestroyable {
-                 readonly _tape: tape.Test
+                 readonly _tape: tape.Test;
                  _subscriptions = new Array<IDestroyable>();
-                 constructor(tape: tape.Test) {
-                     argumentNotNull(tape, "tape");
-                     this._tape = tape;
+                 constructor(t: tape.Test) {
+                     argumentNotNull(t, "tape");
+                     this._tape = t;
                  }
                  writeEvents(source: IObservable<TraceEvent>, ct: ICancellation = Cancellation.none) {
-                     let subscription = source.on(this.writeEvent.bind(this));
+                     const subscription = source.on(this.writeEvent.bind(this));
                      if (ct.isSupported()) {
                          ct.register(subscription.destroy.bind(subscription));
                      }
                  }
                  writeEvent(next: TraceEvent) {
-                     if (next.level >= LogLevel) {
-                         this._tape.comment("LOG " + next.arg);
+                     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.arg);
+                         this._tape.comment(`WARN  ${next.source.id} ${next.arg}`);
                      } else {
-                         this._tape.comment("ERROR " + next.arg);
+                         this._tape.comment(`ERROR ${next.source.id} ${next.arg}`);
                      }
                  }
              export async function delay(timeout: number, ct: ICancellation = Cancellation.none) {
                  let un: IDestroyable;
                  try {
-             	await new Promise((resolve, reject) => {
+                     await new Promise((resolve, reject) => {
                          if (ct.isRequested()) {
-             	        un = ct.register(reject);
-                 	    } else {
-                 		let ht = setTimeout(() => {
-                 		    resolve();
-                     	    }, timeout);
-             	    	un = ct.register(e => {
-                 	    	    clearTimeout(ht);
-                 		    reject(e);
-                 	        });
+                 	    }
-             	});
+                             un = ct.register(reject);
+                         } else {
+                             const ht = setTimeout(() => {
+                                 resolve();
+                             }, timeout);
+                             un = ct.register(e => {
+                                 clearTimeout(ht);
+                                 reject(e);
+                             });
+                         }
+                     });
                  } finally {
-             	if(un)
-             	    un.destroy();
-                 };
-             }
  No newline at end of file
+                     if (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();
+                     }
+                 });
+             }

src/test/ts/TraceSourceTests.ts ~~test/ts/TraceSourceTests.ts~~ renamed +16 -16

-             import { TraceSource, DebugLevel } from '@implab/core/log/TraceSource'
-             import * as tape from 'tape';
-             import { TapeWriter } from './TestTraits';
+             import { TraceSource, DebugLevel } from "@implab/core/log/TraceSource";
+             import * as tape from "tape";
+             import { TapeWriter } from "./TestTraits";
-             const sourceId = 'test/TraceSourceTests';
+             const sourceId = "test/TraceSourceTests";
-             tape('trace message', t => {
-                 let trace = TraceSource.get(sourceId);
+             tape("trace message", t => {
+                 const trace = TraceSource.get(sourceId);
                  trace.level = DebugLevel;
-                 let h = trace.events.on((ev) => {
+                 const h = trace.events.on(ev => {
                      t.equal(ev.source, trace, "sender should be the current trace source");
                      t.equal(ev.level, DebugLevel, "level should be debug level");
                      t.equal(ev.arg, "Hello, World!", "The message should be a formatted message");
                  h.destroy();
              });
-             tape('trace event', t => {
-                 let trace = TraceSource.get(sourceId);
+             tape("trace event", t => {
+                 const trace = TraceSource.get(sourceId);
                  trace.level = DebugLevel;
-                 let event = {
+                 const event = {
                      name: "custom event"
                  };
-                 let h = trace.events.on((ev) => {
+                 const h = trace.events.on(ev => {
                      t.equal(ev.source, trace, "sender should be the current trace source");
                      t.equal(ev.level, DebugLevel, "level should be debug level");
                      t.equal(ev.arg, event, "The message should be the specified object");
                  h.destroy();
              });
-             tape('tape comment writer', async t => {
-                 let writer = new TapeWriter(t);
+             tape("tape comment writer", async t => {
+                 const writer = new TapeWriter(t);
                  TraceSource.on(ts => {
                      writer.writeEvents(ts.events);
                  });
-                 let trace = TraceSource.get(sourceId);
+                 const trace = TraceSource.get(sourceId);
                  trace.level = DebugLevel;
-                 trace.log("Hello, {0}!", 'World');
+                 trace.log("Hello, {0}!", "World");
                  trace.log("Multi\n  line");
                  trace.warn("Look at me!");
                  trace.error("DIE!");
                  t.comment("DONE");
                  t.end();
-             });
  No newline at end of file
+             });

src/test/ts/dummy.ts ~~test/ts/dummy.ts~~ renamed +6 -6

-             import * as tape from 'tape';
-             import * as uuid from '@implab/core/Uuid';
+             import * as tape from "tape";
+             import { Uuid } from "@implab/core/Uuid";
-             tape('simple', function(t){
+             tape("simple", t => {
                  t.pass("sync assert");
                  setTimeout(() => {
                      t.pass("async assert");
-                     t.comment(uuid());
-                     t.ok(uuid() != uuid());
+                     t.comment(Uuid());
+                     t.ok(Uuid() !== Uuid());
                      // end should be called after the last assertion
                      t.end();
                  }, 100);
-             });
  No newline at end of file
+             });

src/js/Deferred.js removed 0 -3

NO CONTENT: file was removed

src/js/declare.js removed 0 -6

NO CONTENT: file was removed

src/js/di/ActivationContext.js removed 0 -138

NO CONTENT: file was removed

src/js/di/ActivationError.js removed 0 -39

NO CONTENT: file was removed

src/js/di/Container.js removed 0 -299

NO CONTENT: file was removed

src/js/di/Descriptor.js removed 0 -4

NO CONTENT: file was removed

src/js/di/ReferenceDescriptor.js removed 0 -90

NO CONTENT: file was removed

src/js/di/ServiceDescriptor.js removed 0 -289

NO CONTENT: file was removed

src/js/di/ValueDescriptor.js removed 0 -38

NO CONTENT: file was removed

src/js/text/format-compile.js removed 0 -101

NO CONTENT: file was removed

src/js/text/format.js removed 0 -87

NO CONTENT: file was removed

src/js/text/template-compile.js removed 0 -134

NO CONTENT: file was removed

src/ts/text/format.d.ts removed 0 -7

NO CONTENT: file was removed

tsc.json removed 0 -15

NO CONTENT: file was removed

tsc.test.json removed 0 -15

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