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

             syntax: glob
             .gradle/
             build/
             node_modules/
+            src/typings/

.hgtags +1 0

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

build.gradle +81 -41

@@ -1,94 +1,134
1	if (release != 'rtm') {	1	if (release != 'rtm') {
2	version += "-$release"	2	version += "-$release"
3	}	3	}
4		4
5	println "version: $version"	5	if(!npmName)
		6	npmName = name;
		7
		8	if(!["amd", "cjs"].contains(platform))
		9	throw new Exception("Invalid platform specified: $platform");
		10
		11	def moduleTypes = [
		12	"amd": "amd",
		13	"cjs": "commonjs"
		14	]
		15
		16	ext.packageName="$npmScope/$npmName-$platform";
6		17
7	def ~~dist~~Dir = "$~~buildDir/dist~~"	18	def srcDir = "$projectDir/src"
8	def t~~est~~Dir = "$~~buildDir/test~~"	19	def typingsDir = "$srcDir/typings"
		20	def distDir = "$buildDir/dist/$platform"
		21	def testDir = "$buildDir/test/$platform"
		22	def moduleType = moduleTypes[platform]
		23
		24	def sourceSets = ["main", "amd", "cjs", "test"];
		25
		26	task printVersion {
		27	doLast {
		28	println "version: $version"
		29	println "packageName: $packageName"
		30	println "platform: $platform"
		31	println "module: $moduleType"
		32	}
		33	}
9		34
10	task clean {	35	task clean {
11	doLast {	36	doLast {
12	delete buildDir	37	delete buildDir
13	delete 'node_modules/~~@implab'~~	38	delete "node_modules/$packageName"
		39	delete typingsDir
14	}	40	}
15	}	41	}
16		42
17	task cleanNpm {	43	task cleanNpm {
18	doLast {	44	doLast {
19	delete 'node_modules'	45	delete 'node_modules'
20	}	46	}
21	}	47	}
22		48
23	task _npmInstall() {	49	task _npmInstall() {
24	inputs.file("package.json")	50	inputs.file("package.json")
25	outputs.dir("node_modules")	51	outputs.dir("node_modules")
26	doLast {	52	doLast {
27	exec {	53	exec {
28	commandLine 'npm', 'install'	54	commandLine 'npm', 'install'
29	}	55	}
30	}	56	}
31	}	57	}
32		58
33	task _legacyJs(type:Copy) {	59	sourceSets.each {
34	from 'src/js/'	60	def setName = it.capitalize();
35	into distDir	61
		62	def destDir = "$buildDir/compile/$it"
		63	def declDir = "$typingsDir/$it"
		64	def setDir = "$projectDir/src/$it"
		65
		66	task "_copyJs$setName"(type:Copy) {
		67	from "$setDir/js"
		68	into distDir
		69	}
		70
		71	task "_compileTs$setName"(dependsOn: _npmInstall, type:Exec) {
		72	inputs.dir("$setDir/ts")
		73	inputs.file("$srcDir/tsconfig.json")
		74	inputs.file("$setDir/tsconfig.json")
		75	outputs.dir(destDir)
		76	outputs.dir(declDir)
		77
		78	commandLine 'node_modules/.bin/tsc',
		79	'-p', "$setDir/tsconfig.json",
		80	'-m', moduleType,
		81	'--outDir', destDir,
		82	'--declarationDir', declDir
		83	}
		84
		85	task "_buildTs$setName"(dependsOn: "_compileTs$setName", type:Copy) {
		86	from tasks.getByPath("_compileTs$setName");
		87	into distDir
		88	}
36	}	89	}
37		90
38	task _buildTs(dependsOn: _npmInstall, type:Exec) {	91	_compileTsAmd {
39	inputs.dir('src/ts')	92	dependsOn _buildTsMain
40	inputs.file('tsc.json')	93	}
41	outputs.dir(distDir)
42		94
43	commandLine 'node_modules/.bin/tsc', '-p', 'tsc.json'	95	_buildTsTest {
		96	into testDir
		97	}
		98
		99	_copyJsTest {
		100	into testDir
44	}	101	}
45		102
46	task _packageMeta(type: Copy) {	103	task _packageMeta(type: Copy) {
47	inputs.property("version", version)	104	inputs.property("version", version)
48	from('.') {	105	from('.') {
49	include ~~'package.json'~~, '.npmignore', 'readme.md', 'license', 'history.md'	106	include '.npmignore', 'readme.md', 'license', 'history.md'
		107	}
		108	from("$srcDir/package.template.json") {
		109	expand project.properties
		110	rename { "package.json" }
50	}	111	}
51	into distDir	112	into distDir
52	doLast {
53	exec {
54	workingDir distDir
55	commandLine 'npm', 'version', version
56	}
57	}
58	}	113	}
59		114
60	task build(dependsOn: [_npmInstall, _buildTs, _~~legacyJs~~, _packageMeta]) {	115	task build(dependsOn: [_copyJsMain, _copyJsAmd, _npmInstall, _buildTsMain, _buildTsAmd, _packageMeta]) {
61		116
62	}	117	}
63		118
64	task _localInstall(dependsOn: build, type: Exec) {	119	_compileTsTest {
65	inputs.file("$distDir/package.json")	120	dependsOn build
66	outputs.upToDateWhen {
67	new File("$projectDir/node_modules/@implab/core").exists()
68	}
69
70	commandLine 'npm', 'install', '--no-save', '--force', distDir
71	}	121	}
72		122
73	task copyJsTests(type: Copy) {	123	task buildTests(dependsOn: [_copyJsTest, _buildTsTest]) {
74	from 'test/js'
75	into testDir
76	}	124	}
77		125
78	task ~~buildTests~~(dependsOn: ~~_localInstall~~, type: Exec) {	126	task test(dependsOn: buildTests, type: Exec) {
79	inputs.dir('test/ts')	127	commandLine 'node', "$testDir/run-amd-tests.js"
80	inputs.file('tsc.test.json')
81	outputs.dir(testDir)
82
83	commandLine 'node_modules/.bin/tsc', '-p', 'tsc.test.json'
84	}
85
86	task test(dependsOn: [copyJsTests, buildTests], type: Exec) {
87	commandLine 'node', 'run-amd-tests.js'
88	}	128	}
89		129
90	task pack(dependsOn: build, type: Exec) {	130	task pack(dependsOn: build, type: Exec) {
91	workingDir = distDir	131	workingDir distDir
92		132
93	commandLine 'npm', 'pack'	133	commandLine 'npm', 'pack'
94	} No newline at end of file	134	}

gradle.properties +9 -2

@@ -1,2 +1,9
1	version=1.~~1.1~~	1	version=1.2.0
2	release=rtm No newline at end of file	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:
 . Redistributions of source code must retain the above copyright notice, this
             list of conditions and the following disclaimer.
 . Redistributions in binary form must reproduce the above copyright notice,
             this list of conditions and the following disclaimer in the documentation
             and/or other materials provided with the distribution.
             THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
             ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
             WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
             DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
             FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
             DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
             SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
             CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
             OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
             OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package-lock.json +159 -142

             {
               "name": "@implab/core",
               "version": "0.0.1-dev",
               "lockfileVersion": 1,
               "requires": true,
               "dependencies": {
                 "@types/node": {
-                  "version": "10.5.1",
+                  "version": "10.12.15",
-                  "resolved": "https://registry.npmjs.org/@types/node/-/node-10.5.1.tgz",
+                  "resolved": "https://registry.npmjs.org/@types/node/-/node-10.12.15.tgz",
-                  "integrity": "sha512-AFLl1IALIuyt6oK4AYZsgWVJ/5rnyzQWud7IebaZWWV3YmgtPZkQmYio9R5Ze/2pdd7XfqF5bP+hWS11mAKoOQ==",
+                  "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": {
                   "version": "4.2.32",
                   "resolved": "http://registry.npmjs.org/@types/tape/-/tape-4.2.32.tgz",
                   "integrity": "sha512-xil0KO5wkPoixdBWGIGolPv9dekf6dVkjjJLAFYchfKcd4DICou67rgGCIO7wAh3i5Ff/6j9IDgZz+GU9cMaqQ==",
                   "dev": true,
                   "requires": {
-                    "@types/node": "10.5.1"
+                    "@types/node": "*"
                   }
                 },
                 "balanced-match": {
                   "version": "1.0.0",
                   "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz",
                   "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=",
                   "dev": true
                 },
                 "brace-expansion": {
                   "version": "1.1.11",
                   "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
                   "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
                   "dev": true,
                   "requires": {
-                    "balanced-match": "1.0.0",
+                    "balanced-match": "^1.0.0",
                     "concat-map": "0.0.1"
                   }
                 },
                 "concat-map": {
                   "version": "0.0.1",
                   "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
                   "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=",
                   "dev": true
                 },
                 "core-util-is": {
                   "version": "1.0.2",
                   "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz",
                   "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=",
                   "dev": true
                 },
                 "deep-equal": {
-                  "version": "1.0.1",
+                  "version": "0.1.2",
-                  "resolved": "https://registry.npmjs.org/deep-equal/-/deep-equal-1.0.1.tgz",
+                  "resolved": "https://registry.npmjs.org/deep-equal/-/deep-equal-0.1.2.tgz",
-                  "integrity": "sha1-9dJgKStmDghO/0zbyfCK0yR0SLU=",
+                  "integrity": "sha1-skbCuApXCkfBG+HZvRBw7IeLh84=",
                   "dev": true
                 },
                 "define-properties": {
-                  "version": "1.1.2",
+                  "version": "1.1.3",
-                  "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.2.tgz",
+                  "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.3.tgz",
-                  "integrity": "sha1-g6c/L+pWmJj7c3GTyPhzyvbUXJQ=",
+                  "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",
+                  "version": "0.0.0",
-                  "resolved": "https://registry.npmjs.org/defined/-/defined-1.0.0.tgz",
+                  "resolved": "https://registry.npmjs.org/defined/-/defined-0.0.0.tgz",
-                  "integrity": "sha1-yY2bzvdWdBiOEQlpFRGZ45sfppM=",
+                  "integrity": "sha1-817qfXBekzuvE7LwOz+D2SFAOz4=",
                   "dev": true
                 },
                 "dojo": {
-                  "version": "1.13.0",
+                  "version": "1.14.2",
-                  "resolved": "https://registry.npmjs.org/dojo/-/dojo-1.13.0.tgz",
+                  "resolved": "https://registry.npmjs.org/dojo/-/dojo-1.14.2.tgz",
-                  "integrity": "sha512-mGoGvsXAbPkUrBnxCoO7m6CFH8jvWq7rAL7fP7jrhJEOyswA/bZwWdXwEH0ovs68t8S0+xOpV/3V7addYbaiAA=="
+                  "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
                 },
                 "es-abstract": {
                   "version": "1.12.0",
                   "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.12.0.tgz",
                   "integrity": "sha512-C8Fx/0jFmV5IPoMOFPA9P9G5NtqW+4cOPit3MIuvR2t7Ag2K15EJTpxnHAYTzL+aYQJIESYeXZmDBfOBE1HcpA==",
                   "dev": true,
                   "requires": {
-                    "es-to-primitive": "1.1.1",
+                    "es-to-primitive": "^1.1.1",
-                    "function-bind": "1.1.1",
+                    "function-bind": "^1.1.1",
-                    "has": "1.0.3",
+                    "has": "^1.0.1",
-                    "is-callable": "1.1.3",
+                    "is-callable": "^1.1.3",
-                    "is-regex": "1.0.4"
+                    "is-regex": "^1.0.4"
                   }
                 },
                 "es-to-primitive": {
-                  "version": "1.1.1",
+                  "version": "1.2.0",
-                  "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.1.1.tgz",
+                  "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.0.tgz",
-                  "integrity": "sha1-RTVSSKiJeQNLZ5Lhm7gfK3l13Q0=",
+                  "integrity": "sha512-qZryBOJjV//LaxLTV6UC//WewneB3LcXOL9NP++ozKVXsIIIpm/2c13UDiD9Jp2eThsecw9m3jPqDwTyobcdbg==",
                   "dev": true,
                   "requires": {
-                    "is-callable": "1.1.3",
+                    "is-callable": "^1.1.4",
-                    "is-date-object": "1.0.1",
+                    "is-date-object": "^1.0.1",
-                    "is-symbol": "1.0.1"
+                    "is-symbol": "^1.0.2"
                   }
                 },
                 "faucet": {
                   "version": "0.0.1",
                   "resolved": "https://registry.npmjs.org/faucet/-/faucet-0.0.1.tgz",
                   "integrity": "sha1-WX3PHSGJosBiMhtZHo8VHtIDnZw=",
                   "dev": true,
                   "requires": {
                     "defined": "0.0.0",
-                    "duplexer": "0.1.1",
+                    "duplexer": "~0.1.1",
                     "minimist": "0.0.5",
-                    "sprintf": "0.1.5",
+                    "sprintf": "~0.1.3",
-                    "tap-parser": "0.4.3",
+                    "tap-parser": "~0.4.0",
-                    "tape": "2.3.3",
+                    "tape": "~2.3.2",
-                    "through2": "0.2.3"
+                    "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",
+                        "deep-equal": "~0.1.0",
-                        "defined": "0.0.0",
+                        "defined": "~0.0.0",
-                        "inherits": "2.0.3",
+                        "inherits": "~2.0.1",
-                        "jsonify": "0.0.0",
+                        "jsonify": "~0.0.0",
-                        "resumer": "0.0.0",
+                        "resumer": "~0.0.0",
-                        "through": "2.3.8"
+                        "through": "~2.3.4"
                       }
                     }
                   }
                 },
                 "for-each": {
                   "version": "0.3.3",
                   "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz",
                   "integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==",
                   "dev": true,
                   "requires": {
-                    "is-callable": "1.1.3"
+                    "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",
                   "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=",
                   "dev": true
                 },
                 "function-bind": {
                   "version": "1.1.1",
                   "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz",
                   "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==",
                   "dev": true
                 },
                 "glob": {
-                  "version": "7.1.2",
+                  "version": "7.1.3",
-                  "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.2.tgz",
+                  "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.3.tgz",
-                  "integrity": "sha512-MJTUg1kjuLeQCJ+ccE4Vpa6kKVXkPYJ2mOCQyUuKLcLQsdrMCpBPUi8qVE6+YuaJkozeA9NusTAw3hLr8Xe5EQ==",
+                  "integrity": "sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==",
                   "dev": true,
                   "requires": {
-                    "fs.realpath": "1.0.0",
+                    "fs.realpath": "^1.0.0",
-                    "inflight": "1.0.6",
+                    "inflight": "^1.0.4",
-                    "inherits": "2.0.3",
+                    "inherits": "2",
-                    "minimatch": "3.0.4",
+                    "minimatch": "^3.0.4",
-                    "once": "1.4.0",
+                    "once": "^1.3.0",
-                    "path-is-absolute": "1.0.1"
+                    "path-is-absolute": "^1.0.0"
                   }
                 },
                 "has": {
                   "version": "1.0.3",
                   "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
                   "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
                   "dev": true,
                   "requires": {
-                    "function-bind": "1.1.1"
+                    "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",
+                    "once": "^1.3.0",
-                    "wrappy": "1.0.2"
+                    "wrappy": "1"
                   }
                 },
                 "inherits": {
                   "version": "2.0.3",
                   "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
                   "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=",
                   "dev": true
                 },
                 "is-callable": {
-                  "version": "1.1.3",
+                  "version": "1.1.4",
-                  "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.1.3.tgz",
+                  "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.1.4.tgz",
-                  "integrity": "sha1-hut1OSgF3cM69xySoO7fdO52BLI=",
+                  "integrity": "sha512-r5p9sxJjYnArLjObpjA4xu5EKI3CuKHkJXMhT7kwbpUyIFD1n5PMAsoPvWnvtZiNz7LjkYDRZhd7FlI0eMijEA==",
                   "dev": true
                 },
                 "is-date-object": {
                   "version": "1.0.1",
                   "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.1.tgz",
                   "integrity": "sha1-mqIOtq7rv/d/vTPnTKAbM1gdOhY=",
                   "dev": true
                 },
                 "is-regex": {
                   "version": "1.0.4",
                   "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.0.4.tgz",
                   "integrity": "sha1-VRdIm1RwkbCTDglWVM7SXul+lJE=",
                   "dev": true,
                   "requires": {
-                    "has": "1.0.3"
+                    "has": "^1.0.1"
                   }
                 },
                 "is-symbol": {
-                  "version": "1.0.1",
+                  "version": "1.0.2",
-                  "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.1.tgz",
+                  "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.2.tgz",
-                  "integrity": "sha1-PMWfAAJRlLarLjjbrmaJJWtmBXI=",
+                  "integrity": "sha512-HS8bZ9ox60yCJLH9snBpIwv9pYUAkcuLhSA1oero1UB5y9aiQpRA8y2ex945AOtCZL1lJDeIk3G5LthswI46Lw==",
-                  "dev": true
+                  "dev": true,
+                  "requires": {
+                    "has-symbols": "^1.0.0"
+                  }
                 },
                 "isarray": {
                   "version": "0.0.1",
                   "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz",
                   "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=",
                   "dev": true
                 },
                 "jsonify": {
                   "version": "0.0.0",
                   "resolved": "https://registry.npmjs.org/jsonify/-/jsonify-0.0.0.tgz",
                   "integrity": "sha1-LHS27kHZPKUbe1qu6PUDYx0lKnM=",
                   "dev": true
                 },
                 "minimatch": {
                   "version": "3.0.4",
                   "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
                   "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
                   "dev": true,
                   "requires": {
-                    "brace-expansion": "1.1.11"
+                    "brace-expansion": "^1.1.7"
                   }
                 },
                 "minimist": {
-                  "version": "1.2.0",
+                  "version": "0.0.5",
-                  "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
+                  "resolved": "http://registry.npmjs.org/minimist/-/minimist-0.0.5.tgz",
-                  "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=",
+                  "integrity": "sha1-16oye87PUY+RBqxrjwA/o7zqhWY=",
                   "dev": true
                 },
                 "object-inspect": {
                   "version": "1.6.0",
                   "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.6.0.tgz",
                   "integrity": "sha512-GJzfBZ6DgDAmnuaM3104jR4s1Myxr3Y3zfIyN4z3UdqN69oSRacNK8UhnobDdC+7J2AHCjGwxQubNJfE70SXXQ==",
                   "dev": true
                 },
                 "object-keys": {
-                  "version": "1.0.12",
+                  "version": "0.4.0",
-                  "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.0.12.tgz",
+                  "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-0.4.0.tgz",
-                  "integrity": "sha512-FTMyFUm2wBcGHnH2eXmz7tC6IwlqQZ6mVZ+6dm6vZ4IQIHjs6FdNsQBuKGPuUUUY6NfJw2PshC08Tn6LzLDOag==",
+                  "integrity": "sha1-KKaq50KN0sOpLz2V8hM13SBOAzY=",
                   "dev": true
                 },
                 "once": {
                   "version": "1.4.0",
                   "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
                   "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
                   "dev": true,
                   "requires": {
-                    "wrappy": "1.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",
+                  "version": "1.0.6",
-                  "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.5.tgz",
+                  "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz",
-                  "integrity": "sha1-PBrfhx6pzWyUMbbqK9dKD/BVxME=",
+                  "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",
+                    "core-util-is": "~1.0.0",
-                    "inherits": "2.0.3",
+                    "inherits": "~2.0.1",
                     "isarray": "0.0.1",
-                    "string_decoder": "0.10.31"
+                    "string_decoder": "~0.10.x"
                   }
                 },
                 "requirejs": {
                   "version": "2.3.6",
                   "resolved": "https://registry.npmjs.org/requirejs/-/requirejs-2.3.6.tgz",
                   "integrity": "sha512-ipEzlWQe6RK3jkzikgCupiTbTvm4S0/CAU5GlgptkN5SO6F3u0UD0K18wy6ErDqiCyP4J4YYe1HuAShvsxePLg==",
                   "dev": true
                 },
                 "resolve": {
                   "version": "1.7.1",
-                  "resolved": "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": {
                   "version": "0.0.0",
                   "resolved": "https://registry.npmjs.org/resumer/-/resumer-0.0.0.tgz",
                   "integrity": "sha1-8ej0YeQGS6Oegq883CqMiT0HZ1k=",
                   "dev": true,
                   "requires": {
-                    "through": "2.3.8"
+                    "through": "~2.3.4"
                   }
                 },
                 "sprintf": {
                   "version": "0.1.5",
                   "resolved": "https://registry.npmjs.org/sprintf/-/sprintf-0.1.5.tgz",
                   "integrity": "sha1-j4PjmpMXwaUCy324BQ5Rxnn27c8=",
                   "dev": true
                 },
                 "string.prototype.trim": {
                   "version": "1.1.2",
                   "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.1.2.tgz",
                   "integrity": "sha1-0E3iyJ4Tf019IG8Ia17S+ua+jOo=",
                   "dev": true,
                   "requires": {
-                    "define-properties": "1.1.2",
+                    "define-properties": "^1.1.2",
-                    "es-abstract": "1.12.0",
+                    "es-abstract": "^1.5.0",
-                    "function-bind": "1.1.1"
+                    "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
                 },
                 "tap-parser": {
                   "version": "0.4.3",
                   "resolved": "https://registry.npmjs.org/tap-parser/-/tap-parser-0.4.3.tgz",
                   "integrity": "sha1-pOrhkMENdsehEZIf84u+TVjwnuo=",
                   "dev": true,
                   "requires": {
-                    "inherits": "2.0.3",
+                    "inherits": "~2.0.1",
-                    "readable-stream": "1.1.14"
+                    "readable-stream": "~1.1.11"
                   }
                 },
                 "tape": {
                   "version": "4.9.1",
                   "resolved": "https://registry.npmjs.org/tape/-/tape-4.9.1.tgz",
                   "integrity": "sha512-6fKIXknLpoe/Jp4rzHKFPpJUHDHDqn8jus99IfPnHIjyz78HYlefTGD3b5EkbQzuLfaEvmfPK3IolLgq2xT3kw==",
                   "dev": true,
                   "requires": {
-                    "deep-equal": "1.0.1",
+                    "deep-equal": "~1.0.1",
-                    "defined": "1.0.0",
+                    "defined": "~1.0.0",
-                    "for-each": "0.3.3",
+                    "for-each": "~0.3.3",
-                    "function-bind": "1.1.1",
+                    "function-bind": "~1.1.1",
-                    "glob": "7.1.2",
+                    "glob": "~7.1.2",
-                    "has": "1.0.3",
+                    "has": "~1.0.3",
-                    "inherits": "2.0.3",
+                    "inherits": "~2.0.3",
-                    "minimist": "1.2.0",
+                    "minimist": "~1.2.0",
-                    "object-inspect": "1.6.0",
+                    "object-inspect": "~1.6.0",
-                    "resolve": "1.7.1",
+                    "resolve": "~1.7.1",
-                    "resumer": "0.0.0",
+                    "resumer": "~0.0.0",
-                    "string.prototype.trim": "1.1.2",
+                    "string.prototype.trim": "~1.1.2",
-                    "through": "2.3.8"
+                    "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",
+                    "readable-stream": "~1.1.9",
-                    "xtend": "2.1.2"
+                    "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",
+                  "version": "3.2.2",
-                  "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.1.6.tgz",
+                  "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.2.2.tgz",
-                  "integrity": "sha512-tDMYfVtvpb96msS1lDX9MEdHrW4yOuZ4Kdc4Him9oU796XldPYF/t2+uKoX0BBa0hXXwDlqYQbXY5Rzjzc5hBA==",
+                  "integrity": "sha512-VCj5UiSyHBjwfYacmDuc/NOk4QQixbE+Wn7MFJuS0nRuPQbof132Pw4u53dm264O8LPc2MVsc7RJNml5szurkg==",
                   "dev": true
                 },
                 "wrappy": {
                   "version": "1.0.2",
                   "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
                   "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=",
                   "dev": true
                 },
                 "xtend": {
                   "version": "2.1.2",
                   "resolved": "https://registry.npmjs.org/xtend/-/xtend-2.1.2.tgz",
                   "integrity": "sha1-bv7MKk2tjmlixJAbM3znuoe10os=",
                   "dev": true,
                   "requires": {
-                    "object-keys": "0.4.0"
+                    "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
                   }
                 }
               }
             }

package.json +8 -3

             {
               "name": "@implab/core",
               "version": "0.0.1-dev",
               "description": "Dependency injection, logging, simple and fast text template engine",
               "main": "main.js",
               "keywords": [
                 "di",
                 "ioc",
                 "logging",
                 "template engine",
                 "dependency injection"
               ],
               "author": "Implab team",
               "license": "BSD-2-Clause",
               "repository": "https://bitbucket.org/implab/implabjs",
               "publishConfig": {
                 "access": "public"
               },
-              "dependencies": {
+              "peerDependencies": {
-                "dojo": "^1.10.0"
+                "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

             /*
              * This settings file was generated by the Gradle 'init' task.
              *
              * The settings file is used to specify which projects to include in your build.
              * In a single project build this file can be empty or even removed.
              *
              * Detailed information about configuring a multi-project build in Gradle can be found
              * in the user guide at https://docs.gradle.org/3.5/userguide/multi_project_builds.html
              */
             // To declare projects as part of a multi-project build use the 'include' method
             //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

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

             import { ICancellation, IDestroyable } from "./interfaces";
             import { argumentNotNull } from "./safe";
             const destroyed = {
                 destroy() {
                 }
             };
             export class Cancellation implements ICancellation {
                 private _reason: any;
                 private _cbs: Array<(e) => void>;
                 constructor(action: (cancel: (e) => void) => void) {
                     argumentNotNull(action, "action");
                     action(this._cancel.bind(this));
                 }
                 isSupported(): boolean {
                     return true;
                 }
                 throwIfRequested(): void {
                     if (this._reason)
                         throw this._reason;
                 }
                 isRequested(): boolean {
                     return !!this._reason;
                 }
                 register(cb: (e: any) => void): IDestroyable {
                     argumentNotNull(cb, "cb");
                     if (this._reason) {
                         cb(this._reason);
                         return destroyed;
                     } else {
                         if (!this._cbs)
                             this._cbs = [cb];
                         else
                             this._cbs.push(cb);
-                        let me = this;
+                        const me = this;
                         return {
-                    	destroy() {
+                            destroy() {
-                    	    me._unregister(cb);
+                                me._unregister(cb);
+                            }
                         };
                     }
                 }
                 private _unregister(cb) {
-            	if(this._cbs) {
+                    if (this._cbs) {
-            	    let i = this._cbs.indexOf(cb);
+                        const i = this._cbs.indexOf(cb);
-            	    if ( i>=0 )
+                        if (i >= 0)
-            		this._cbs.splice(i,1);
+                            this._cbs.splice(i, 1);
+                    }
                 }
                 private _cancel(reason) {
                     if (this._reason)
                         return;
                     this._reason = (reason = reason || new Error("Operation cancelled"));
                     if (this._cbs) {
                         this._cbs.forEach(cb => cb(reason));
                         this._cbs = null;
                     }
                 }
                 static readonly none: ICancellation = {
                     isSupported(): boolean {
                         return false;
                     },
                     throwIfRequested(): void {
                     },
                     isRequested(): boolean {
                         return false;
                     },
                     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 { IObservable, IDestroyable, ICancellation } from "./interfaces";
-            import { Cancellation } from './Cancellation'
+            import { Cancellation } from "./Cancellation";
-            import { argumentNotNull } from './safe';
+            import { argumentNotNull } from "./safe";
-            interface Handler<T> {
+            type Handler<T> = (x: T) => void;
-                (x: T): void
-            interface Initializer<T> {
+            type Initializer<T> = (notify: Handler<T>, error?: (e: any) => void, complete?: () => void) => void;
-                (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)
                         func(
                             this._notifyNext.bind(this),
                             this._notifyError.bind(this),
                             this._notifyCompleted.bind(this)
                         );
                 }
                 /**
                  * Registers handlers for the current observable object.
+                 *
                  * @param next the handler for events
                  * @param error the handler for a error
                  * @param complete the handler for a completion
                  * @returns {IDestroyable} the handler for the current subscription, this
                  *  handler can be used to unsubscribe from events.
+                 *
                  */
                 on(next: Handler<T>, error?: Handler<any>, complete?: () => void): IDestroyable {
                     argumentNotNull(next, "next");
-                    let me = this;
+                    const me = this;
-                    let observer: IObserver<T> & IDestroyable = {
+                    const observer: IObserver<T> & IDestroyable = {
-                        next: next,
+                        next,
                         error: error ? error.bind(null) : noop,
                         complete: complete ? complete.bind(null) : noop,
                         destroy() {
                             me._removeObserver(this);
                         }
                     };
                     this._addObserver(observer);
                     return observer;
                 }
                 private _addObserver(observer: IObserver<T>) {
                     if (this._complete) {
                         try {
                             if (this._error)
                                 observer.error(this._error);
                             else
                                 observer.complete();
                         } catch (e) {
                             this.onObserverException(e);
                         }
                     } else {
                         this._observers.push(observer);
                     }
                 }
                 /**
                  * Waits for the next event. This method can't be used to read messages
                  * as a sequence since it can skip some messages between calls.
+                 *
                  * @param ct a cancellation token
                  */
                 next(ct: ICancellation = Cancellation.none): 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 _addOnce(observer: IObserver<T>) {
                     if (this._complete) {
                         try {
                             if (this._error)
                                 observer.error(this._error);
                             else
                                 observer.complete();
                         } catch (e) {
                             this.onObserverException(e);
                         }
                         return false;
                     }
                     this._once.push(observer);
                     return true;
                 }
                 protected onObserverException(e: any) {
                 }
                 private _removeOnce(d: IObserver<T>) {
-                    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) {
+                    this._once.forEach(guard);
-                        for (let i = 0; i < this._once.length; i++)
+                    this._once = [];
-                            guard(this._once[i]);
-                        this._once = [];
-                    for (let i = 0; i < this._observers.length; i++)
+                    this._observers.forEach(guard);
-                        guard(this._observers[i]);
                 }
                 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 = [];
                     this._complete = true;
                 }
                 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

             // Typescript port of the uuid.js
             //  Copyright (c) 2018 Sergey Smirnov
             //  BSD-2-Clause License https://opensource.org/licenses/BSD-2-Clause
             //
             // uuid.js
             //     Copyright (c) 2010-2012 Robert Kieffer
             //     MIT License - http://opensource.org/licenses/mit-license.php
-            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
             // detect to determine the best RNG source, normalizing to a function
             // that
             // returns 128-bits of randomness, since that's what's usually required
             let _rng;
             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;
                         };
                         _rng();
                     } catch (e) { /**/ }
                 }
                 if (!_rng) {
                     // Math.random()-based (RNG)
                     //
                     // If all else fails, use Math.random(). It's fast, but is of
                     // unspecified
                     // quality.
-                    let  _rnds = new Array(16);
+                    const _rnds = new Array(16);
-                    _rng = function () {
+                    _rng = () => {
-                        for (var i = 0, r; i < 16; i++) {
+                        for (let i = 0, r; i < 16; i++) {
                             if ((i & 0x03) === 0) {
                                 r = Math.random() * 0x100000000;
                             }
                             _rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;
                         }
                         return _rnds;
                     };
-                    if ('undefined' !== typeof console && console.warn) {
+                    if ("undefined" !== typeof console && console.warn) {
                         console.warn("[SECURITY] node-uuid: crypto not usable, falling back to insecure Math.random()");
                     }
                 }
             }
             function setupNode() {
                 // Node.js crypto-based RNG -
                 // http://nodejs.org/docs/v0.6.2/api/crypto.html
                 //
                 // Moderately fast, high quality
-                if ('function' === typeof require) {
+                if ("function" === typeof require) {
                     try {
-                        let _rb = require('crypto').randomBytes;
+                        const _rb = require("crypto").randomBytes;
-                        _rng = _rb && function () {
+                        _rng = _rb && (() => _rb(16));
-                            return _rb(16);
-                        };
                         _rng();
                     } catch (e) { /**/ }
                 }
             }
             if (_window) {
                 setupBrowser();
             } else {
                 setupNode();
             }
             // 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 = [];
+            const _byteToHex = [];
-            let _hexToByte = {};
+            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> {
+            export function _parse(s, buf?, offset?): Array<string> {
-                let i = (buf && offset) || 0,        ii = 0;
+                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];
                     }
                 });
                 // Zero out remaining bytes if string was short
                 while (ii < 16) {
                     buf[i + ii++] = 0;
                 }
                 return buf;
             }
             // **`unparse()` - Convert UUID byte array (ala parse()) into a string**
-            function unparse(buf, offset?) : string {
+            function _unparse(buf, offset?): string {
-                let i = offset || 0,        bth = _byteToHex;
+                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++]];
             }
             // **`v1()` - Generate time-based UUID**
             //
             // Inspired by https://github.com/LiosK/UUID.js
             // and http://docs.python.org/library/uuid.html
             // random #'s we need to init node and clockseq
-            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],
                 _seedBytes[3],
                 _seedBytes[4],
                 _seedBytes[5]
             ];
             // Per 4.2.2, randomize (14 bit) clockseq
             let _clockseq = (_seedBytes[6] << 8 | _seedBytes[7]) & 0x3fff;
             // Previous uuid creation time
-            let _lastMSecs = 0,    _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 clockseq = (options.clockseq != null) ? options.clockseq : _clockseq;
                 // UUID timestamps are 100 nano-second units since the Gregorian
                 // epoch,
                 // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so
                 // time is handled internally as 'msecs' (integer milliseconds) and
                 // 'nsecs'
                 // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01
                 // 00:00.
                 let msecs = (options.msecs != null) ? options.msecs : new Date()
                     .getTime();
                 // Per 4.2.1.2, use count of uuid's generated during the current
                 // clock
                 // cycle to simulate higher resolution clock
                 let nsecs = (options.nsecs != null) ? options.nsecs : _lastNSecs + 1;
                 // Time since last uuid creation (in msecs)
-                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) {
                     clockseq = clockseq + 1 & 0x3fff;
                 }
                 // Reset nsecs if clock regresses (new clockseq) or we've moved onto
                 // a new
                 // time interval
                 if ((dt < 0 || msecs > _lastMSecs) && options.nsecs == null) {
                     nsecs = 0;
                 }
                 // Per 4.2.1.2 Throw error if too many uuids are requested
                 if (nsecs >= 10000) {
                     throw new Error(
-                        'uuid.v1(): Can\'t create more than 10M uuids/sec');
+                        "uuid.v1(): Can't create more than 10M uuids/sec");
                 }
                 _lastMSecs = msecs;
                 _lastNSecs = nsecs;
                 _clockseq = clockseq;
                 // Per 4.1.4 - Convert from unix epoch to Gregorian epoch
                 msecs += 12219292800000;
                 // `time_low`
-                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;
                 // `time_high_and_version`
                 b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
                 b[i++] = tmh >>> 16 & 0xff;
                 // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
                 b[i++] = clockseq >>> 8 | 0x80;
                 // `clock_seq_low`
                 b[i++] = clockseq & 0xff;
                 // `node`
-                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') {
+                if (typeof (options) === "string") {
-                    buf = (options === 'binary') ? new BufferClass(16) : null;
+                    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;
                 rnds[8] = (rnds[8] & 0x3f) | 0x80;
                 // Copy bytes to buffer, if provided
                 if (buf) {
                     for (let ii = 0; ii < 16; ii++) {
                         buf[i + ii] = rnds[ii];
                     }
                 }
-                return buf || unparse(rnds);
+                return buf || _unparse(rnds);
+            }
+            export function Uuid() {
+                return _v4();
             }
-            // Export public API
+            export namespace Uuid {
-            const empty = "00000000-0000-0000-0000-000000000000";
+                export const v4 = _v4;
+                export const v1 = _v1;
-            interface uuid {
+                export const empty = "00000000-0000-0000-0000-000000000000";
-                (options?, buf?, offset?) : string;
+                export const parse = _parse;
-                v1(options?, buf?, offset?) : string;
-                v4(options?, buf?, offset?) : string;
-                readonly empty: string;
-                parse(s, buf?, offset?) : Array<string>;
-                unparse(buf, offset?) : string;
             }
-            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 { IActivationController, IActivatable, ICancellation } from "../interfaces";
-            import { AsyncComponent } from './AsyncComponent';
+            import { AsyncComponent } from "./AsyncComponent";
-            import { Cancellation } from '../Cancellation';
+            import { Cancellation } from "../Cancellation";
-            import { TraceSource } from '../log/TraceSource';
+            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 {
                     _controller: IActivationController;
                     _active: boolean;
                     isActive() {
                         return this._active;
                     }
                     getActivationController() {
                         return this._controller;
                     }
                     setActivationController(controller: IActivationController) {
                         this._controller = controller;
                     }
                     async onActivating(ct: ICancellation) {
                         if (this._controller)
                             await this._controller.activating(this, ct);
                     }
                     async onActivated(ct: ICancellation) {
                         if (this._controller)
                             await this._controller.activated(this, ct);
                     }
                     activate(ct: ICancellation = Cancellation.none) {
                         return this.runOperation(this._activateAsync.bind(this), ct);
                     }
                     async _activateAsync(ct: ICancellation) {
                         if (this.isActive())
                             return;
                         await this.onActivating(ct);
                         this._active = true;
                         try {
                             await this.onActivated(ct);
                         } catch (e) {
                             log.error("Suppressed onActivated error: {0}", e);
                         }
                     }
                     async onDeactivating(ct: ICancellation) {
                         if (this._controller)
                             await this._controller.deactivating(this, ct);
                     }
                     async onDeactivated(ct: ICancellation) {
                         if (this._controller)
                             await this._controller.deactivated(this, ct);
                     }
                     deactivate(ct: ICancellation = Cancellation.none) {
                         return this.runOperation(this._deactivateAsync.bind(this), ct);
                     }
                     async _deactivateAsync(ct: ICancellation) {
                         if (!this.isActive())
                             return;
                         await this.onDeactivating(ct);
                         this._active = false;
                         try {
                             await this.onDeactivated(ct);
                         } catch (e) {
                             log.error("Suppressed onDeactivated error: {0}", e);
                         }
                     }
+                };
             }
-            export const traceSource = log;
  No newline at end of file
+            export const traceSource = log;

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

             import { Cancellation } from "../Cancellation";
             import { IAsyncComponent, ICancellation, ICancellable, IDestroyable } from "../interfaces";
             import { destroy } from "../safe";
             export class AsyncComponent implements IAsyncComponent, ICancellable {
                 _cancel: (e) => void;
                 _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 {
                             // after the operation is complete we need to cleanup the
                             // resources
                             destroy(h);
                             this._cancel = null;
                         }
+                    };
                     return this._completion = guard();
                 }
                 cancel(reason) {
                     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();
             }
             export interface ICancellation {
                 throwIfRequested(): void;
                 isRequested(): boolean;
                 isSupported(): boolean;
                 register(cb: (e: any) => void): IDestroyable;
             }
             /**
              * Интерфейс поддерживающий асинхронную активацию
              */
             export interface IActivatable {
                 /**
                  * @returns Boolean indicates the current state
                  */
                 isActive(): boolean;
                 /**
                  * Starts the component activation
                  * @param ct cancellation token for this operation
                  */
-                activate(ct?: ICancellation) : Promise<void>;
+                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
                  */
                 setActivationController(controller: IActivationController);
                 /**
                  * Gets the current activation controller for this component
                  */
                 getActivationController(): IActivationController;
             }
             export interface IActivationController {
                 activating(component: IActivatable, ct?: ICancellation): Promise<void>;
                 activated(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivating(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivated(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivate(ct?: ICancellation): Promise<void>;
                 activate(component: IActivatable, ct?: ICancellation): Promise<void>;
                 getActive(): IActivatable;
             }
             export interface IAsyncComponent {
                 getCompletion(): Promise<void>;
             }
             export interface ICancellable {
                 cancel(reason?: any): void;
             }
             export interface IObservable<T> {
-                on(next: (x:T) => void, error?: (e:any) => void, complete?:() => void): IDestroyable;
+                on(next: (x: T) => void, error?: (e: any) => void, complete?: () => void): IDestroyable;
-                next(ct?: ICancellation) : Promise<T>;
+                next(ct?: ICancellation): Promise<T>;
-            }
  No newline at end of file

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

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

src/main/ts/log/writers/ConsoleWriter.ts ~~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));
                     }
                     this._subscriptions.push(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 argumentNotEmptyString(arg, name) {
                 if (typeof (arg) !== "string" || !arg.length)
                     throw new Error("The argument '" + name + "' must be a not empty string");
             }
             export function argumentNotEmptyArray(arg, name) {
                 if (!(arg instanceof Array) || !arg.length)
                     throw new Error("The argument '" + name + "' must be a not empty array");
             }
             export function argumentOfType(arg, type, name) {
                 if (!(arg instanceof type))
                     throw new Error("The argument '" + name + "' type doesn't match");
             }
             export function isNull(arg) {
                 return (arg === null || arg === undefined);
             }
             export function isPrimitive(arg) {
                 return (arg === null || arg === undefined || typeof (arg) === "string" ||
                     typeof (arg) === "number" || typeof (arg) === "boolean");
             }
             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 значение, которое будет передано в качестве
              *                <c>this</c> в <c>cb</c>.
              * @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++) {
+                    for (let i = 0; i < obj.length; i++) {
-                        x = cb.call(thisArg, obj[i], i);
+                        const x = cb.call(thisArg, obj[i], i);
                         if (x !== undefined)
                             return x;
                     }
                 } else {
-                    var keys = Object.keys(obj);
+                    const keys = Object.keys(obj);
-                    for (i = 0; i < keys.length; i++) {
+                    for (const k of keys) {
-                        var k = keys[i];
+                        const x = cb.call(thisArg, obj[k], k);
-                        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) {
                                     return wrapresult(null, e2);
                                 }
                             }
                         };
                     } else {
                         if (x && x.then)
                             return x;
                         return {
-                            then: function (cb) {
+                            then(cb) {
                                 try {
                                     return cb ? wrapresult(cb(x)) : this;
                                 } catch (e2) {
                                     return wrapresult(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)) {
+            type _AnyFn = (...args) => any;
-                let method : Function;
+            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))
+                return (...args) => {
-                    throw new Error("'method' argument must be a Function or a method name");
+                    return method.apply(target, args);
-                return function () {
-                    return method.apply(target, arguments);
                 };
             }
             /**
              * Для каждого элемента массива вызывает указанную функцию и сохраняет
              * возвращенное значение в массиве результатов.
+             *
              * @remarks cb может выполняться асинхронно, при этом одновременно будет
              *          только одна операция.
+             *
              * @async
              */
             export function pmap(items, cb) {
                 argumentNotNull(cb, "cb");
-                if (items && items.then instanceof Function)
+                if (isPromise(items))
-                    return items.then(function (data) {
+                    return items.then(data => pmap(data, cb));
-                        return pmap(data, cb);
-                    });
                 if (isNull(items) || !items.length)
                     return items;
-                var i = 0,
+                let i = 0;
-                    result = [];
+                const result = [];
                 function next() {
-                    var r, ri;
+                    let r;
+                    let ri;
                     function chain(x) {
                         result[ri] = x;
                         return next();
                     }
                     while (i < items.length) {
                         r = cb(items[i], i);
                         ri = i;
                         i++;
-                        if (r && r.then) {
+                        if (isPromise(r)) {
                             return r.then(chain);
                         } else {
                             result[ri] = r;
                         }
                     }
                     return result;
                 }
                 return next();
             }
             /**
              * Выбирает первый элемент из последовательности, или обещания, если в
              * качестве параметра используется обещание, оно должно вернуть массив.
+             *
              * @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) {
+                    if (isPromise(sequence)) {
-                        return sequence.then(function (res) {
+                        return sequence.then(res => first(res, cb, err));
-                            return first(res, cb, err);
-                        }, err);
                     } else if (sequence && "length" in sequence) {
                         if (sequence.length === 0) {
                             if (err)
                                 return err(new Error("The sequence is empty"));
                             else
                                 throw new Error("The sequence is empty");
                         }
                         return cb ? cb(sequence[0]) : sequence[0];
                     }
                 }
                 if (err)
                     return err(new Error("The sequence is required"));
                 else
                     throw new Error("The sequence is required");
             }
-            export function destroy(d: any) {
+            export function destroy(d) {
-                if (d && 'destroy' in 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"]);	1	define([
2	//define(["./CancellationTests"]);	2	"./ActivatableTests",
3	define(["./ObservableTests"]); No newline at end of file	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

             var requirejs = require('requirejs');
             requirejs.config({
                 baseUrl: '.',
-                map: {
-                    "*": {
-                        "@implab/core": "core"
-                },
                 packages: [{
-                        name: "core",
+                        name: "@implab/core",
-                        location: "build/dist"
+                        location: "build/dist/amd"
                     },
                     {
                         name: "test",
-                        location: "build/test"
+                        location: "build/test/amd"
                     },
                     {
                         name: "dojo",
                         location: "node_modules/dojo"
                     }
                 ],
                 nodeRequire: require
             });
             requirejs(['test/plan']);

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

             define(["tape"], function(tape) {
                 "use strict";
                 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");
                         var count = 0;
                         var h = TraceSource.on(function(x) {
                             if(x.id == sourceId || x.id == sourceId2)
                                 count++;
                         });
                         t.equal(count, 1, "should see created channel immediatelly");
                         t.equal(trace, TraceSource.get(sourceId), "should get same TraceSource from registry");
                         t.equal(count, 1);
                         TraceSource.get(sourceId2);
                         t.equal(count, 2);
                         h.destroy();
                         t.end();
                     });
                 });
             });

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

-            import * as tape from 'tape';
+            import * as tape from "tape";
-            import { ActivatableMixin} from '@implab/core/components/ActivatableMixin';
+            import { MockActivationController } from "./mock/MockActivationController";
-            import { AsyncComponent } from '@implab/core/components/AsyncComponent';
+            import { SimpleActivatable } from "./mock/SimpleActivatable";
-            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;
-                async deactivate() {
+            tape("simple activation", async t => {
-                    if (this._active)
-                        await this._active.deactivate();
-                    this._active = null;
-                async activate(component: IActivatable) {
-                    if (!component || component.isActive())
-                        return;
-                    component.setActivationController(this);
-                    await component.activate();
-                async activating(component: IActivatable, ct: ICancellation = Cancellation.none) {
-                    if (component != this._active)
-                        await this.deactivate();
-                async activated(component: IActivatable, ct: ICancellation = Cancellation.none) {
+                const a = new SimpleActivatable();
-                    this._active = component;
+                t.false(a.isActive());
-                async deactivating(component: IActivatable, ct: ICancellation = Cancellation.none) {
-                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();
+                const a = new SimpleActivatable();
-                let c = new MockActivationController();
+                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.assert(a.getActivationController() == null, "the component doesn't have an activation controller by default");
                 t.comment("Active the component through the controller");
                 await c.activate(a);
                 t.true(a.isActive(), "The component should successfully activate");
                 t.equal(c.getActive(), a, "The controller should point to the activated component");
                 t.equal(a.getActivationController(), c, "The component should point to the controller");
                 t.comment("Deactive the component throug the controller");
                 await c.deactivate();
                 t.false(a.isActive(), "The component should successfully deactivate");
                 t.equal(c.getActive(), null, "The controller shouldn't point to any component");
                 t.equal(a.getActivationController(), c, "The componet should point to it's controller");
                 t.end();
             });
-            tape('handle error in onActivating', async function(t) {
+            tape("handle error in onActivating", async t => {
-                let a = new SimpleActivatable();
+                const a = new SimpleActivatable();
-                a.onActivating = async function() {
+                a.onActivating = async () => {
-                    throw "Should fail";
+                    throw new Error("Should fail");
                 };
                 try {
                     await a.activate();
                     t.fail("activation should fail");
                 } catch {
                 }
                 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 * as tape from "tape";
-            import { Cancellation } from '@implab/core/Cancellation';
+            import { Cancellation } from "@implab/core/Cancellation";
-            import { ICancellation } from '@implab/core/interfaces';
+            import { ICancellation } from "@implab/core/interfaces";
-            import { delay } from './TestTraits';
+            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");
                 ct.throwIfRequested();
                 t.pass("The exception shouldn't be thrown unless the cancellation is requested");
                 ct.register(() => counter++);
                 t.equals(counter, 0, "counter should be zero");
                 ct.register(() => counter++).destroy();
                 doCancel(reason);
                 t.true(ct.isRequested(), "Cancellation should be requested");
                 t.equals(counter, 1, "The registered callback should be triggered");
                 ct.register(() => counter++);
                 t.equals(counter, 2, "The callback should be triggered immediately");
                 let msg;
-                ct.register((e) => msg = e);
+                ct.register(e => msg = e);
                 t.equals(msg, reason, "The cancellation reason should be passed to callback");
                 try {
                     msg = null;
                     ct.throwIfRequested();
                     t.fail("The exception should be thrown");
                 } catch (e) {
                     msg = e;
                 }
                 t.equals(msg, reason, "The cancellation reason should be catched");
                 t.end();
             });
-            tape('async cancellation', async t => {
+            tape("async cancellation", async t => {
-                let ct = new Cancellation(cancel => {
+                const ct = new Cancellation(cancel => {
                     cancel("STOP!");
                 });
                 try {
                     await delay(0, ct);
                     t.fail("Should thow the exception");
                 } catch (e) {
                     t.equals(e, "STOP!", "Should throw the cancellation reason");
                 }
                 t.end();
             });
-            tape('cancel with external event', async t => {
+            tape("cancel with external event", async t => {
-                let ct = new Cancellation((cancel) => {
+                const ct = new Cancellation(cancel => {
-                    setTimeout(x => cancel('STOP!'), 0);
+                    setTimeout(x => cancel("STOP!"), 0);
-                })
+                });
                 try {
                     await delay(10000, ct);
                     t.fail("Should thow the exception");
                 } catch (e) {
                     t.equals(e, "STOP!", "Should throw the cancellation reason");
                 }
                 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);
                 });
                 try {
                     await delay(0, ct);
                     t.pass("Should pass");
                 } finally {
                     clearTimeout(htimeout);
                 }
                 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 { TraceSource, DebugLevel } from "@implab/core/log/TraceSource";
-            import * as tape from 'tape';
+            import * as tape from "tape";
-            import { TapeWriter, delay } from './TestTraits';
+            import { TapeWriter, delay } from "./TestTraits";
-            import { Observable } from '@implab/core/Observable';
+            import { Observable } from "@implab/core/Observable";
-            import { IObservable } from '@implab/core/interfaces';
+            import { IObservable } from "@implab/core/interfaces";
-            let trace = TraceSource.get("ObservableTests");
-            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) => {
+                const done = new Promise<void>(resolve => {
-                    events = new Observable<number>(async (notify, fail, complete) => {
+                    events = new Observable<number>(async (notify, fail, finish) => {
                         for (let i = 0; i < 10; i++) {
                             await delay(0);
                             notify(i);
                         }
-                        complete();
+                        finish();
                         resolve();
                     });
                 });
                 let count = 0;
                 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");
                 await done;
                 t.equals(count, 45, "the summ of the evetns");
                 t.true(complete, "the sequence is complete");
                 t.end();
             });
-            tape('event sequence termination', async t => {
+            tape("event sequence termination", async t => {
-                let events: IObservable<number>
+                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);
                         complete();
                         notify(2);
                         complete();
                         fail("Sequence terminated");
                         resolve();
                     });
                 });
                 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");
                 }
                 await done;
                 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

@@ -1,62 +1,89
1	import { IObservable, ICancellation, IDestroyable } from "@implab/core/interfaces";	1	import { IObservable, ICancellation, IDestroyable } from "@implab/core/interfaces";
2	import { Cancellation } from "@implab/core/Cancellation";	2	import { Cancellation } from "@implab/core/Cancellation";
3	import { TraceEvent, LogLevel, WarnLevel } from "@implab/core/log/TraceSource";	3	import { TraceEvent, LogLevel, WarnLevel, DebugLevel, TraceSource } from "@implab/core/log/TraceSource";
4	import * as tape from ~~'tape'~~;	4	import * as tape from "tape";
5	import { argumentNotNull } from "@implab/core/safe";	5	import { argumentNotNull } from "@implab/core/safe";
6		6
7	export class TapeWriter implements IDestroyable {	7	export class TapeWriter implements IDestroyable {
8	readonly _tape: tape.Test	8	readonly _tape: tape.Test;
9		9
10	_subscriptions = new Array<IDestroyable>();	10	_subscriptions = new Array<IDestroyable>();
11		11
12	constructor(t~~ape~~: tape.Test) {	12	constructor(t: tape.Test) {
13	argumentNotNull(t~~ape~~, "tape");	13	argumentNotNull(t, "tape");
14	this._tape = t~~ape~~;	14	this._tape = t;
15	}	15	}
16		16
17	writeEvents(source: IObservable<TraceEvent>, ct: ICancellation = Cancellation.none) {	17	writeEvents(source: IObservable<TraceEvent>, ct: ICancellation = Cancellation.none) {
18	let subscription = source.on(this.writeEvent.bind(this));	18	const subscription = source.on(this.writeEvent.bind(this));
19	if (ct.isSupported()) {	19	if (ct.isSupported()) {
20	ct.register(subscription.destroy.bind(subscription));	20	ct.register(subscription.destroy.bind(subscription));
21	}	21	}
22	this._subscriptions.push(subscription);	22	this._subscriptions.push(subscription);
23	}	23	}
24		24
25	writeEvent(next: TraceEvent) {	25	writeEvent(next: TraceEvent) {
26	if (next.level >= LogLevel) {	26	if (next.level >= DebugLevel) {
27	this._tape.comment(~~"LOG "~~ + next.arg);	27	this._tape.comment(`DEBUG ${next.source.id} ${next.arg}`);
		28	} else if (next.level >= LogLevel) {
		29	this._tape.comment(`LOG ${next.source.id} ${next.arg}`);
28	} else if (next.level >= WarnLevel) {	30	} else if (next.level >= WarnLevel) {
29	this._tape.comment(~~"WARN "~~ + next.arg);	31	this._tape.comment(`WARN ${next.source.id} ${next.arg}`);
30	} else {	32	} else {
31	this._tape.comment(~~"ERROR "~~ + next.arg);	33	this._tape.comment(`ERROR ${next.source.id} ${next.arg}`);
32	}	34	}
33	}	35	}
34		36
35	destroy() {	37	destroy() {
36	this._subscriptions.forEach(x => x.destroy());	38	this._subscriptions.forEach(x => x.destroy());
37	}	39	}
38	}	40	}
39		41
40	export async function delay(timeout: number, ct: ICancellation = Cancellation.none) {	42	export async function delay(timeout: number, ct: ICancellation = Cancellation.none) {
41	let un: IDestroyable;	43	let un: IDestroyable;
42		44
43	try {	45	try {
44	await new Promise((resolve, reject) => {	46	await new Promise((resolve, reject) => {
45	if (ct.isRequested()) {	47	if (ct.isRequested()) {
46	un = ct.register(reject);	48	un = ct.register(reject);
47	} else {	49	} else {
48	let ht = setTimeout(() => {	50	const ht = setTimeout(() => {
49	resolve();	51	resolve();
50	}, timeout);	52	}, timeout);
51		53
52	un = ct.register(e => {	54	un = ct.register(e => {
53	clearTimeout(ht);	55	clearTimeout(ht);
54	reject(e);	56	reject(e);
55	});	57	});
56	}	58	}
57	});	59	});
58	} finally {	60	} finally {
59	if(un)	61	if (un)
60	un.destroy();	62	un.destroy();
61	};	63	}
62	} No newline at end of file	64	}
		65
		66	export function test(name: string, cb: (t: tape.Test) => any) {
		67	tape(name, async t => {
		68	const writer = new TapeWriter(t);
		69
		70	TraceSource.on(ts => {
		71	ts.level = DebugLevel;
		72	writer.writeEvents(ts.events);
		73	});
		74
		75	try {
		76	await cb(t);
		77	} catch (e) {
		78
		79	// verbose error information
		80	// tslint:disable-next-line
		81	console.error(e);
		82	t.fail(e);
		83
		84	} finally {
		85	t.end();
		86	writer.destroy();
		87	}
		88	});
		89	}

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

-            import { TraceSource, DebugLevel } from '@implab/core/log/TraceSource'
+            import { TraceSource, DebugLevel } from "@implab/core/log/TraceSource";
-            import * as tape from 'tape';
+            import * as tape from "tape";
-            import { TapeWriter } from './TestTraits';
+            import { TapeWriter } from "./TestTraits";
-            const sourceId = 'test/TraceSourceTests';
+            const sourceId = "test/TraceSourceTests";
-            tape('trace message', t => {
+            tape("trace message", t => {
-                let trace = TraceSource.get(sourceId);
+                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");
                     t.end();
                 });
                 trace.debug("Hello, {0}!", "World");
                 h.destroy();
             });
-            tape('trace event', t => {
+            tape("trace event", t => {
-                let trace = TraceSource.get(sourceId);
+                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");
                     t.end();
                 });
                 trace.traceEvent(DebugLevel, event);
                 h.destroy();
             });
-            tape('tape comment writer', async t => {
+            tape("tape comment writer", async t => {
-                let writer = new TapeWriter(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!");
                 writer.destroy();
                 trace.log("You shouldn't see it!");
                 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 tape from "tape";
-            import * as uuid from '@implab/core/Uuid';
+            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.comment(Uuid());
-                    t.ok(uuid() != 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