implab/implabjs-core Commit - r57:c981b10db77f

Merge with di-typescript

cin -

r57:c981b10db77f default

parent child

Context file:

r57:c981b10db77f

Expand all files

.project created 644 +17 0

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

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

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

.vscode/settings.json created 644 +15 0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

NO CONTENT: new file 100644

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

src/main/tsconfig.json created 644 +9 0

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

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

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

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

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

src/test/ts/ContainerTests.ts created 644 +94 0

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

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

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

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

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

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

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

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

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

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

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

src/tsconfig.json created 644 +18 0

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

tslint.json created 644 +40 0

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

.hgignore +1 0

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

.hgtags +1 0

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

build.gradle +80 -40

@@ -2,15 +2,41 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
@@ -30,65 +56,79 task _npmInstall() {
30	}	56	}
31	}	57	}
32		58
33	task _legacyJs(type:Copy) {	59	sourceSets.each {
34	from 'src/js/'	60	def setName = it.capitalize();
		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"
35	into distDir	68	into distDir
36	}	69	}
37		70
38	task ~~_buildTs~~(dependsOn: _npmInstall, type:Exec) {	71	task "_compileTs$setName"(dependsOn: _npmInstall, type:Exec) {
39	inputs.dir(~~'src/ts'~~)	72	inputs.dir("$setDir/ts")
40	inputs.file(~~'tsc.json'~~)	73	inputs.file("$srcDir/tsconfig.json")
41	outputs.dir(distDir)	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	}
42		84
43	commandLine 'node_modules/.bin/tsc', '-p', 'tsc.json'	85	task "_buildTs$setName"(dependsOn: "_compileTs$setName", type:Copy) {
		86	from tasks.getByPath("_compileTs$setName");
		87	into distDir
		88	}
		89	}
		90
		91	_compileTsAmd {
		92	dependsOn _buildTsMain
		93	}
		94
		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:

package-lock.json +159 -142

               "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": {
                   "integrity": "sha512-xil0KO5wkPoixdBWGIGolPv9dekf6dVkjjJLAFYchfKcd4DICou67rgGCIO7wAh3i5Ff/6j9IDgZz+GU9cMaqQ==",
                   "dev": true,
                   "requires": {
-                    "@types/node": "10.5.1"
+                    "@types/node": "*"
                   }
                 },
                 "balanced-match": {
                   "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
                   "dev": true,
                   "requires": {
-                    "balanced-match": "1.0.0",
+                    "balanced-match": "^1.0.0",
                     "concat-map": "0.0.1"
                   }
                 },
                   "dev": true
                 },
                 "deep-equal": {
-                  "version": "1.0.1",
+                  "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
                 },
                   "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": {
                   "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"
                       }
                     }
                   }
                   "integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==",
                   "dev": true,
                   "requires": {
-                    "is-callable": "1.1.3"
+                    "is-callable": "^1.1.3"
                   }
                 },
-                "foreach": {
-                  "version": "2.0.5",
-                  "resolved": "https://registry.npmjs.org/foreach/-/foreach-2.0.5.tgz",
-                  "integrity": "sha1-C+4AUBiusmDQo6865ljdATbsG5k=",
-                  "dev": true
-                },
                 "fs.realpath": {
                   "version": "1.0.0",
                   "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
                   "dev": true
                 },
                 "glob": {
-                  "version": "7.1.2",
+                  "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": {
                   "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": {
                   "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": {
                   "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",
                   "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": {
                   "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": {
                   "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": {
                 },
                 "resolve": {
                   "version": "1.7.1",
-                  "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.7.1.tgz",
+                  "resolved": "http://registry.npmjs.org/resolve/-/resolve-1.7.1.tgz",
                   "integrity": "sha512-c7rwLofp8g1U+h1KNyHL/jicrKg1Ek4q+Lr33AL65uZTinUZHe30D5HlyN5V9NW0JX1D5dXQ4jqW5l7Sy/kGfw==",
                   "dev": true,
                   "requires": {
-                    "path-parse": "1.0.5"
+                    "path-parse": "^1.0.5"
                   }
                 },
                 "resumer": {
                   "integrity": "sha1-8ej0YeQGS6Oegq883CqMiT0HZ1k=",
                   "dev": true,
                   "requires": {
-                    "through": "2.3.8"
+                    "through": "~2.3.4"
                   }
                 },
                 "sprintf": {
                   "integrity": "sha1-0E3iyJ4Tf019IG8Ia17S+ua+jOo=",
                   "dev": true,
                   "requires": {
-                    "define-properties": "1.1.2",
+                    "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
                 },
                   "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": {
                   "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": {
                   "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

               "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

@@ -12,4 +12,4
12		12
13	//include 'sub-project-name'	13	//include 'sub-project-name'
14		14
15	rootProject.name = '~~implab-~~core' No newline at end of file	15	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 +3 -4

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

src/main/ts/Observable.ts ~~src/ts/Observable.ts~~ renamed +26 -37

-            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 = () => { };
                 private _observers = new Array<IObserver<T>>();
+                private _complete: boolean;
-                private _complete: boolean
+                private _error: any;
-                private _error: any
                 constructor(func?: Initializer<T>) {
                     if (func)
                 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,
                     this._addObserver(observer);
                     return observer;
                 }
                  */
                 next(ct: ICancellation = Cancellation.none): Promise<T> {
                     return new Promise<T>((resolve, reject) => {
-                        let observer: IObserver<T> = {
+                        const observer: IObserver<T> = {
                             next: resolve,
                             error: reject,
                             complete: () => reject("No more events are available")
                         };
                         if (this._addOnce(observer) && ct.isSupported()) {
-                            ct.register((e) => {
+                            ct.register(e => {
                                 this._removeOnce(observer);
                                 reject(e);
                             });
                 }
                 private _removeOnce(d: IObserver<T>) {
-                    let i = this._once.indexOf(d);
+                    const i = this._once.indexOf(d);
                     if (i >= 0)
                         this._once.splice(i, 1);
                 }
                 private _removeObserver(d: IObserver<T>) {
-                    let i = this._observers.indexOf(d);
+                    const i = this._observers.indexOf(d);
                     if (i >= 0)
                         this._observers.splice(i, 1);
                 }
                 private _notify(guard: (observer: IObserver<T>) => void) {
-                    if (this._once.length) {
+                    this._once.forEach(guard);
-                        for (let i = 0; i < this._once.length; i++)
-                            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 = [];
                 }
                 protected _notifyCompleted() {
-                    let guard = (observer: IObserver<T>) => {
+                    const guard = (observer: IObserver<T>) => {
                         try {
                             observer.complete();
                         } catch (e) {
                             this.onObserverException(e);
                         }
+                    };
                     this._notify(guard);
                     this._observers = [];
                     this._complete = true;
                 }
-            }
  No newline at end of file

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

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

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

                 _completion: Promise<void> = Promise.resolve();
-                getCompletion() { return this._completion };
+                getCompletion() { return this._completion; }
                 runOperation(op: (ct: ICancellation) => any, ct: ICancellation = Cancellation.none) {
                     // create inner cancellation bound to the passed cancellation token
                     let h: IDestroyable;
-                    let inner = new Cancellation(cancel => {
+                    const inner = new Cancellation(cancel => {
                         this._cancel = cancel;
                         h = ct.register(cancel);
                     });
                     // TODO create cancellation source here
-                    let guard = async () => {
+                    const guard = async () => {
                         try {
                             await op(inner);
                         } finally {
                             destroy(h);
                             this._cancel = null;
                         }
+                    };
                     return this._completion = guard();
                 }
                     if (this._cancel)
                         this._cancel(reason);
                 }
-            }
  No newline at end of file

src/main/ts/interfaces.ts ~~src/ts/interfaces.ts~~ renamed +9 -1

@@ -1,3 +1,11
		1	export type Constructor<T = {}> = new (...args: any[]) => T;
		2
		3	export type Factory<T = {}> = (...args: any[]) => T;
		4
		5	export interface MapOf<T> {
		6	[key: string]: T;
		7	}
		8
1	export interface IDestroyable {	9	export interface IDestroyable {
2	destroy();	10	destroy();
3	}	11	}
@@ -73,4 +81,4 export interface ICancellable {
73	export interface IObservable<T> {	81	export interface IObservable<T> {
74	on(next: (x:T) => void, error?: (e:any) => void, complete?:() => void): IDestroyable;	82	on(next: (x: T) => void, error?: (e: any) => void, complete?: () => void): IDestroyable;
75	next(ct?: ICancellation) : Promise<T>;	83	next(ct?: ICancellation): Promise<T>;
76	} No newline at end of file	84	}

src/main/ts/log/TraceSource.ts ~~src/ts/log/TraceSource.ts~~ renamed +15 -75

@@ -1,7 +1,6
1	import * as format from '../text/format'	1	import { Observable } from "../Observable";
2	import { argumentNotNull } from '../safe';	2	import { Registry } from "./Registry";
3	import { Observable } from '../Observable'	3	import { format } from "../text/StringFormat";
4	import { IDestroyable } from '../interfaces';
5		4
6	export const DebugLevel = 400;	5	export const DebugLevel = 400;
7		6
@@ -13,91 +12,33 export const ErrorLevel = 100;
13		12
14	export const SilentLevel = 0;	13	export const SilentLevel = 0;
15		14
16	export ~~class~~ TraceEvent {	15	export interface TraceEvent {
17	readonly source: TraceSource;	16	readonly source: TraceSource;
18		17
19	readonly level: Number;	18	readonly level: number;
20		19
21	readonly arg: any;	20	readonly arg: any;
22
23	constructor(source: TraceSource, level: Number, arg: any) {
24	this.source = source;
25	this.level = level;
26	this.arg = arg;
27	}
28	}
29
30	class Registry {
31	static readonly instance = new Registry();
32
33	private _registry: object = new Object();
34	private _listeners: object = new Object();
35	private _nextCookie: number = 1;
36
37	get(id: any): TraceSource {
38	argumentNotNull(id, "id");
39
40	if (this._registry[id])
41	return this._registry[id];
42
43	var source = new TraceSource(id);
44	this._registry[id] = source;
45	this._onNewSource(source);
46
47	return source;
48	}
49
50	add(id: any, source: TraceSource) {
51	argumentNotNull(id, "id");
52	argumentNotNull(source, "source");
53
54	this._registry[id] = source;
55	this._onNewSource(source);
56	}
57
58	_onNewSource(source: TraceSource) {
59	for (let i in this._listeners)
60	this._listeners[i].call(null, source);
61	}
62
63	on(handler: (source: TraceSource) => void): IDestroyable {
64	argumentNotNull(handler, "handler");
65	var me = this;
66
67	var cookie = this._nextCookie++;
68
69	this._listeners[cookie] = handler;
70
71	for (let i in this._registry)
72	handler(this._registry[i]);
73
74	return {
75	destroy() {
76	delete me._listeners[cookie];
77	}
78	};
79	}
80	}	21	}
81		22
82	export class TraceSource {	23	export class TraceSource {
83	readonly id: any	24	readonly id: any;
84		25
85	level: number	26	level: number;
86		27
87	readonly events: Observable<TraceEvent>	28	readonly events: Observable<TraceEvent>;
88		29
89	_notifyNext: (arg: TraceEvent) => void	30	_notifyNext: (arg: TraceEvent) => void;
90		31
91	constructor(id: any) {	32	constructor(id: any) {
92		33
93	this.id = id \|\| new Object();	34	this.id = id \|\| new Object();
94	this.events = new Observable((next) => {	35	this.events = new Observable(next => {
95	this._notifyNext = next;	36	this._notifyNext = next;
96	})	37	});
97	}	38	}
98		39
99	protected emit(level: number, arg: any) {	40	protected emit(level: number, arg: any) {
100	this._notifyNext(~~new~~ ~~TraceEvent~~(this, level, arg));	41	this._notifyNext({ source: this, level, arg });
101	}	42	}
102		43
103	isDebugEnabled() {	44	isDebugEnabled() {
@@ -106,7 +47,7 export class TraceSource {
106		47
107	debug(msg: string, ...args: any[]) {	48	debug(msg: string, ...args: any[]) {
108	if (this.isEnabled(DebugLevel))	49	if (this.isEnabled(DebugLevel))
109	this.emit(DebugLevel, format.~~apply~~(~~null~~, arg~~ument~~s));	50	this.emit(DebugLevel, format(msg, args));
110	}	51	}
111		52
112	isLogEnabled() {	53	isLogEnabled() {
@@ -115,7 +56,7 export class TraceSource {
115		56
116	log(msg: string, ...args: any[]) {	57	log(msg: string, ...args: any[]) {
117	if (this.isEnabled(LogLevel))	58	if (this.isEnabled(LogLevel))
118	this.emit(LogLevel, format.~~apply~~(~~null~~, arg~~ument~~s));	59	this.emit(LogLevel, format(msg, args));
119	}	60	}
120		61
121	isWarnEnabled() {	62	isWarnEnabled() {
@@ -124,7 +65,7 export class TraceSource {
124		65
125	warn(msg: string, ...args: any[]) {	66	warn(msg: string, ...args: any[]) {
126	if (this.isEnabled(WarnLevel))	67	if (this.isEnabled(WarnLevel))
127	this.emit(WarnLevel, format.~~apply~~(~~null~~, arg~~ument~~s));	68	this.emit(WarnLevel, format(msg, args));
128	}	69	}
129		70
130	/**	71	/**
@@ -185,4 +126,3 export class TraceSource {
185	return Registry.instance.get(id);	126	return Registry.instance.get(id);
186	}	127	}
187	}	128	}
188

src/main/ts/log/writers/ConsoleWriter.ts ~~src/ts/log/writers/ConsoleWriter.ts~~ renamed +12 -5

             import { IObservable, IDestroyable, ICancellation } from "../../interfaces";
+            import { TraceEvent, LogLevel, WarnLevel, DebugLevel } from "../TraceSource";
             import { Cancellation } from "../../Cancellation";
-            import { TraceEvent, LogLevel, WarnLevel } from "../TraceSource";
+            import { destroy } from "../../safe";
             export class ConsoleWriter implements IDestroyable {
                 readonly _subscriptions = new Array<IDestroyable>();
                 writeEvents(source: IObservable<TraceEvent>, ct: ICancellation = Cancellation.none) {
-                    var subscription = source.on(this.writeEvent.bind(this));
+                    const subscription = source.on(this.writeEvent.bind(this));
                     if (ct.isSupported()) {
                         ct.register(subscription.destroy.bind(subscription));
                     }
                 }
                 writeEvent(next: TraceEvent) {
-                    if (next.level >= LogLevel) {
+                    if (next.level >= DebugLevel) {
+                        // tslint:disable-next-line
+                        console.debug(next.source.id.toString(), next.arg);
+                    } else if (next.level >= LogLevel) {
+                        // tslint:disable-next-line
                         console.log(next.source.id.toString(), next.arg);
                     } else if (next.level >= WarnLevel) {
+                        // 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 +113 -41

+            let _nextOid = 0;
+            const _oid = typeof Symbol === "function" ?
+                Symbol("__implab__oid__") :
+                "__implab__oid__";
+            export function oid(instance: object): string {
+                if (isNull(instance))
+                    return null;
+                if (_oid in instance)
+                    return instance[_oid];
+                else
+                    return (instance[_oid] = "oid_" + (++_nextOid));
+            }
             export function argumentNotNull(arg, name) {
                 if (arg === null || arg === undefined)
                     throw new Error("The argument " + name + " can't be null or undefined");
             }
             export function isInteger(arg) {
-                return parseInt(arg) == arg;
+                return parseInt(arg, 10) === arg;
             }
             export function isNumber(arg) {
-                return parseFloat(arg) == arg;
+                return parseFloat(arg) === arg;
             }
             export function isString(val) {
-                return typeof (val) == "string" || val instanceof String;
+                return typeof (val) === "string" || val instanceof String;
+            }
+            export function isPromise(val): val is PromiseLike<any> {
+                return "then" in val && val.then instanceof Function;
             }
             export function isNullOrEmptyString(str) {
                 if (str === null || str === undefined ||
-                    ((typeof (str) == "string" || str instanceof String) && str.length === 0))
+                    ((typeof (str) === "string" || str instanceof String) && str.length === 0))
                     return true;
             }
-            export function isNotEmptyArray(arg) {
+            export function isNotEmptyArray(arg): arg is Array<any> {
                 return (arg instanceof Array && arg.length > 0);
             }
+            export function getGlobal() {
+                return this;
+            }
+            export function get(member: string, context?: object) {
+                argumentNotEmptyString(member, "member");
+                let that = context || getGlobal();
+                const parts = member.split(".");
+                for (const m of parts) {
+                    if (!m)
+                        continue;
+                    if (isNull(that = that[m]))
+                        break;
+                }
+                return that;
+            }
             /**
              * Выполняет метод для каждого элемента массива, останавливается, когда
              * либо достигнут конец массива, либо функция <c>cb</c> вернула
              * @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> {
                 let fn = _fn;
-                if (arguments.length == 2 && !(fn instanceof Function))
+                if (arguments.length === 2 && !(fn instanceof Function))
                     fn = thisArg[fn];
                 if (fn == null)
                 function wrapresult(x, e?): PromiseLike<any> {
                     if (e) {
                         return {
-                            then: function (cb, eb) {
+                            then(cb, eb) {
                                 try {
                                     return eb ? wrapresult(eb(e)) : this;
                                 } catch (e2) {
                         if (x && x.then)
                             return x;
                         return {
-                            then: function (cb) {
+                            then(cb) {
                                 try {
                                     return cb ? wrapresult(cb(x)) : this;
                                 } catch (e2) {
                     }
                 }
-                return function () {
+                return (...args) => {
                     try {
-                        return wrapresult(fn.apply(thisArg, arguments));
+                        return wrapresult(fn.apply(thisArg, args));
                     } catch (e) {
                         return wrapresult(null, e);
                     }
                 };
             }
-            export function delegate(target, _method: (string | Function)) {
+            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);
                 };
             }
             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;
                         r = cb(items[i], i);
                         ri = i;
                         i++;
-                        if (r && r.then) {
+                        if (isPromise(r)) {
                             return r.then(chain);
                         } else {
                             result[ri] = r;
              *          обещание, либо первый элемент.
              * @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)
                     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

             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",

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

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

src/test/ts/ActivatableTests.ts ~~test/ts/ActivatableTests.ts~~ renamed +13 -61

@@ -1,58 +1,10
1	import * as tape from ~~'tape'~~;	1	import * as tape from "tape";
2	import { ActivatableMixin} from '@implab/core/components/ActivatableMixin';	2	import { MockActivationController } from "./mock/MockActivationController";
3	import { AsyncComponent } from '@implab/core/components/AsyncComponent';	3	import { SimpleActivatable } from "./mock/SimpleActivatable";
4	import { IActivationController, IActivatable, ICancellation } from '@implab/core/interfaces';
5	import { Cancellation } from '@implab/core/Cancellation';
6
7	class SimpleActivatable extends ActivatableMixin(AsyncComponent) {
8
9	}
10
11	class MockActivationController implements IActivationController {
12
13	_active: IActivatable = null;
14
15
16	getActive() : IActivatable {
17	return this._active;
18	}
19
20	async deactivate() {
21	if (this._active)
22	await this._active.deactivate();
23	this._active = null;
24	}
25		4
26	async activate(component: IActivatable) {	5	tape("simple activation", async t => {
27	if (!component \|\| component.isActive())
28	return;
29	component.setActivationController(this);
30
31	await component.activate();
32	}
33
34	async activating(component: IActivatable, ct: ICancellation = Cancellation.none) {
35	if (component != this._active)
36	await this.deactivate();
37	}
38		6
39	async activated(component: IActivatable, ct: ICancellation = Cancellation.none) {	7	const a = new SimpleActivatable();
40	this._active = component;
41	}
42
43	async deactivating(component: IActivatable, ct: ICancellation = Cancellation.none) {
44
45	}
46
47	async deactivated(component: IActivatable, ct: ICancellation = Cancellation.none) {
48	if (this._active == component)
49	this._active = null;
50	}
51	}
52
53	tape('simple activation',async function(t){
54
55	let a = new SimpleActivatable();
56	t.false(a.isActive());	8	t.false(a.isActive());
57		9
58	await a.activate();	10	await a.activate();
@@ -64,10 +16,10 tape('simple activation',async function(
64	t.end();	16	t.end();
65	});	17	});
66		18
67	tape('controller activation', async ~~function~~(t) {	19	tape("controller activation", async t => {
68		20
69	let a = new SimpleActivatable();	21	const a = new SimpleActivatable();
70	let c = new MockActivationController();	22	const c = new MockActivationController();
71		23
72	t.false(a.isActive(), "the component is not active by default");	24	t.false(a.isActive(), "the component is not active by default");
73	t.assert(c.getActive() == null, "the activation controller doesn't have an active component by default");	25	t.assert(c.getActive() == null, "the activation controller doesn't have an active component by default");
@@ -89,11 +41,11 tape('controller activation', async func
89	t.end();	41	t.end();
90	});	42	});
91		43
92	tape('handle error in onActivating', async ~~function~~(t) {	44	tape("handle error in onActivating", async t => {
93	let a = new SimpleActivatable();	45	const a = new SimpleActivatable();
94		46
95	a.onActivating = async ~~function~~() {	47	a.onActivating = async () => {
96	throw "Should fail";	48	throw new Error("Should fail");
97	};	49	};
98		50
99	try {	51	try {
@@ -105,4 +57,4 tape('handle error in onActivating', asy
105	t.false(a.isActive(), "the component should remain inactive");	57	t.false(a.isActive(), "the component should remain inactive");
106		58
107	t.end();	59	t.end();
108	}); No newline at end of file	60	});

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");
                 t.equals(counter, 2, "The callback should be triggered immediately");
                 let msg;
-                ct.register((e) => msg = e);
+                ct.register(e => msg = e);
                 t.equals(msg, reason, "The cancellation reason should be passed to callback");
                 try {
                 t.end();
             });
-            tape('async cancellation', async t => {
+            tape("async cancellation", async t => {
-                let ct = new Cancellation(cancel => {
+                const ct = new Cancellation(cancel => {
                     cancel("STOP!");
                 });
                 t.end();
             });
-            tape('cancel with external event', async t => {
+            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.end();
             });
-            tape('operation normal flow', async t => {
+            tape("operation normal flow", async t => {
                 let htimeout;
-                let ct = new Cancellation((cancel) => {
+                const ct = new Cancellation(cancel => {
                     htimeout = setTimeout(() => cancel("STOP!"), 1000);
                 });
                 }
                 t.end();
-            });
  No newline at end of file
+            });

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

-            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 complete = false;
                 events.on(x => count = count + x, null, () => complete = true);
-                let first = await events.next();
+                const first = await events.next();
                 t.equals(first, 0, "the first event");
                 t.false(complete, "the sequence is not complete");
                 t.end();
             });
-            tape('event sequence termination', async t => {
+            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);
                 });
                 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.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 +41 -14

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

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

-            import { TraceSource, DebugLevel } from '@implab/core/log/TraceSource'
+            import { 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");
                 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");
                 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!");
                 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