implab/implabjs-core Commit - r21:dd8f8dfcd934

Merged in propose cancellations (pull request #1)...

m407 -

r21:dd8f8dfcd934 default

parent child

Context file:

r21:dd8f8dfcd934

Expand all files

.npmignore created 644 +1 0

			@@ -0,0 +1,1
		1	*.tgz No newline at end of file

docs/ActivatableMixin/activate.puml created 644 +25 0

			@@ -0,0 +1,25
		1	@startuml
		2
		3	participant Component as a
		4	participant Other as b
		5
		6	[-> a : activate(ct)
		7	activate a
		8	<-- a : promise
		9	a -> a : onActivating(ct)
		10	activate a
		11	a -> b : doAsyncWork(ct)
		12	deactivate a
		13	deactivate a
		14	activate b
		15
		16	[-> b : ct.cancel
		17	b --> a : reject(Cancelled)
		18	deactivate b
		19	activate a
		20
		21	a -> a : setFailState()
		22
		23	[<-- a : reject(Cancelled)
		24
		25	@enduml No newline at end of file

docs/cancellations.ru.md created 644 +257 0

			@@ -0,0 +1,257
		1	# Cancellations. Отмена асинхронных операций
		2
		3	Использование Promise позволяет организовать обработку результатов работы
		4	асинхронных фукнций. Ключевые слова async/await позволяют работать с
		5	асинхронными вызовами в стиле процедурного программирования, хотя по сути это
		6	событиный подход. При всей своей красоте даннго подхода в нем умышленно
		7	отсутсвует механизм отмены асинхронной операции, т.е. ее можно начать, но нельзя
		8	отказаться от результатов ее выполнения, даже если это уже не требуется.
		9
		10	Примером того, когда может потребоваться отмена является загрузка большого
		11	файла, при которой пользователю отображается окно хода операции с возможностью
		12	ее отмены.
		13
		14	```ts
		15	// имеется некоторый HTTP клиент
		16	let client = new HttpClient();
		17
		18	// загружается большой файл, с использованием медленного канала
		19	let data = await client.getJsonAsync('http://host/large-file.json');
		20
		21	```
		22
		23	Как поступить в данной ситуации, прежде всего нужно, чтобы сама операция
		24	поддерживала возможность отмены, предположим, что для этого есть метод
		25	`client.abort()`.
		26
		27	```ts
		28
		29	// имеется некоторый HTTP клиент
		30	let client = new HttpClient();
		31
		32	// отображаем окно с информацией о ходе операции
		33	let progressView = showProgress("Downloading, please wait...");
		34
		35	// код оборачивается в try/finally поскольку созданную форму нужно закрыть
		36	try {
		37	// загружается большой файл, с использованием медленного канала
		38	// здесь, в отличии от предыдущего примера, мы не дожидаемся результата,
		39	// а запоминаем обещание в переменную downloadTask
		40	let downloadTask = client.getJsonAsync('http://host/large-file.json');
		41
		42	// связываем событие нажатия кнопки с отменой загрузки
		43	progressView.once('cancel', () => client.abort());
		44
		45	// ожидаем окончания загрузки данных
		46
		47	let data = await downloadTask;
		48	} finally {
		49	// независимот от результата закрываем форму
		50	// при этом также происходит ануллирование подписок на события
		51	progressView.close();
		52	}
		53
		54	```
		55
		56	Технические приведенное решение выглядит не плохо, но проблемы появляются, когда
		57	требуется организовать отмену нескольких операций, особенно если они вложенные.
		58
		59	```ts
		60	// обновление информации о человеке на форме
		61	async function updatePersonInfo(info) {
		62	let client = new RestApiClient();
		63
		64	// выплнение нескольких асинхронных операций
		65	let org = await client.getOrgAsync(info.orgId);
		66	let city = await client.getCityAsync(info.cityId);
		67
		68	// обновление содержимого представления
		69	renderContent({
		70	person: info,
		71	org: org,
		72	city: city
		73	});
		74	}
		75
		76	```
		77
		78	Чтобы реализовать возможность отмены такой операции требуется, чтобы в логике
		79	самой операции была реализована поддержка отмены. Для реализации этого
		80	потребуется чтобы у операции была информация о запросе отмены, причем данная
		81	информация относится именно к текущей операции.
		82
		83	Информацию о состоянии запроса на отмену назовём **маркер отмены (cancellation
		84	token)**. Поскольку маркер отмены тесно связан с операцией, его удобно
		85	передавать в виде параметра, тогда код операции будет выглядеть так:
		86
		87	```ts
		88	// обновление информации о человеке на форме
		89	// ct - маркер отмены
		90	async function updatePersonInfo(info, ct) {
		91	let client = new RestApiClient();
		92
		93	// выплнение нескольких асинхронных операций
		94	// маркер отмены просто передается далее по цепочке вызовов, без
		95	// дополнительных действий
		96	let org = await client.getOrg(info.orgId, ct);
		97	let city = await client.getCity(info.cityId, ct);
		98
		99	// обновление содержимого представления
		100	renderContent({
		101	person: info,
		102	org: org,
		103	city: city
		104	});
		105	}
		106
		107	///////////////////////////////////////////////////////////////////////////////
		108	// ... где-то в другом месте
		109	///////////////////////////////////////////////////////////////////////////////
		110
		111	// отображаем окно с информацией о хоже операции
		112	let progressView = showProgress("Loading, please wait...");
		113
		114	// создаем маркер отмены для операции на основе события 'cancel'.
		115	let ct = new Cancellation(cancel => progressView.on('cancel', cancel));
		116
		117	// код оборачивается в try/finally поскольку созданную форму нужно закрыть
		118	try {
		119	// асинхронно получаем информацию о человеке
		120	let data = await getPersonInfo(personId, ct);
		121
		122	// асинхронно обновляем представление
		123	await updatePersonInfo(data, ct);
		124	} finally {
		125	// независимот от результата закрываем форму
		126	// при этом также происходит ануллирование подписок на события
		127	progressView.close();
		128	}
		129
		130	```
		131
		132	Таким образом тот, кто начинает асинхронную операцию заранее определяет как эта
		133	опреция будет отменена.
		134
		135	Важно понимать, что для реализации отмены операции
		136	могут выделаться ресурсы требующие явного освобождения (DOM, таймеры, события),
		137	об их освобождении по окончанию операции (успешном или нет) должен позаботиться
		138	инициатор этой операции. `Cancellation` выступает только в роли посредника для
		139	доставки события отмены операции до конечного получателя, он не отслеживает и
		140	не освобождает ресурсы, кроме того, асинхронная операция может его попросту
		141	проигнорировать.
		142
		143	## `ICancellation` Маркер отмены операции
		144
		145	Интерфейс маркера отмены операции. Используется асинхронными операциями, чтобы
		146	получить оповещение о требуемой отмене.
		147
		148	### `isSupported(): boolean`
		149
		150	Определяет, может ли быть запрошена отмена операции через данный маркер.
		151
		152	### `isRequested(): boolean`
		153
		154	Возвращает текущее состояние запроса на отмену.
		155
		156	### `throwIfRequested(): void`
		157
		158	Если отмена была запрошена, бросает в качестве исключения причину отмены.
		159
		160	### `register(cb: (e:any) => void): IDestroyable`
		161
		162	Метод, зарегистрировать обработчик на запрос отмены. Если отмена была запрошена
		163	зарегистрированный обработчик будет вызван ровно один раз, независимо от того,
		164	был ли он зарегистрирован до или после запроса отмены.
		165
		166	Если отмена уже была запрошена, обработчик будет вызван сразу при регистрации,
		167	при этом исключения, которые могу возникнуть в обработчике не будут обработаны,
		168	а передадуться наверх.
		169
		170	Вызов данного метода приводит к выделению ресурсов, поэтому операция,
		171	зарегистрировавшая обработчик должна освободить подписку, которую вернет метод.
		172
		173	```ts
		174	async function getAsync(url: string, ct: ICancellation = Cancellation.none) {
		175	// переменная в которой будет запомнена подписка на запрос отмены
		176	let reg;
		177	try {
		178	// оборачиваем операцию загрузки в Promise
		179	return await new Promise<string>((resolve, reject) => {
		180	// объект Xhr
		181	const xhr = new XMLHttpRequest();
		182	xhr.open("GET", url);
		183
		184	// регистрируем обработчики Promise
		185	xhr.onload = () => resolve(xhr.responseText);
		186	xhr.onerror = () => reject(xhr.statusText);
		187
		188	// отправляем запрос
		189	xhr.send();
		190
		191	// подписываемся на запрос отмены
		192	reg = ct.register((e) => {
		193	reject(e);
		194	xhr.abort();
		195	});
		196	});
		197	} finally {
		198	if (reg)
		199	reg.destroy();
		200	}
		201	}
		202
		203	```
		204
		205	Использование метода `register()` предполагается для организации отмены операций
		206	не поддерживающих маркеры отмены.
		207
		208	## `Cancellation` Источник отмены
		209
		210	Класс используется для создания маркеров отмены. Позволяет создать маркер при
		211	начале асинхронной операции и связать его, например, с событием DOM.
		212
		213	Также маркер можно создавать, когда требуется сложное условие отмены текущей и
		214	всех нижележещих операций.
		215
		216	Как правило в большинстве операций достаточно маркера переданного в параметрах,
		217	этот же маркер может передаваться ниже.
		218
		219	### `constructor(exec: (cancel: (reason:any) => void ) => void )`
		220
		221	Создает новый маркер, при помощи параметра и инициализирует его при помощи
		222	фукнции, переданной в параметре `exec`.
		223
		224	```ts
		225
		226	let htimer;
		227	let ct = new Cancellation(cancel => {
		228	htimer = setTimeout(() => cancel("The request is timed out."), 1000);
		229	});
		230
		231	try {
		232	let text = await getAsync(url, ct);
		233	} finally {
		234	// инициатор должен освобождать ресурсы
		235	// передача недействительного htimer не приводит ни к каким последствиям
		236	clearTimeout(htimer);
		237	}
		238
		239	```
		240
		241	## `Cancellation.none: ICancellation`
		242
		243	Статическое свойство только для чтения, в котором находится специальный токен
		244	запроса отмены. Этот токен означает, что отмена никогда не может произойти.
		245
		246	Данный токен рекомендуется использовать как значение по-умолчанию для
		247	параметров, принимающих токен отмены.
		248
		249	```ts
		250
		251	async function load(url: string, ct: ICancellation = Cancellation.none) {
		252	ct.throwIfRequested();
		253
		254	// ... the rest of method
		255	}
		256
		257	``` No newline at end of file

src/ts/Cancellation.ts created 644 +89 0

			@@ -0,0 +1,89
		1	import { ICancellation, IDestroyable } from "./interfaces";
		2	import { argumentNotNull } from "./safe";
		3
		4	const destroyed = {
		5	destroy() {
		6	}
		7	};
		8
		9	export class Cancellation implements ICancellation {
		10	private _reason: any;
		11	private _cbs: Array<(e) => void>;
		12
		13	constructor(action: (cancel: (e) => void) => void) {
		14	argumentNotNull(action, "action");
		15
		16	action(this._cancel.bind(this));
		17	}
		18
		19	isSupported(): boolean {
		20	return true;
		21	}
		22	throwIfRequested(): void {
		23	if (this._reason)
		24	throw this._reason;
		25	}
		26
		27	isRequested(): boolean {
		28	return !!this._reason;
		29	}
		30
		31	register(cb: (e: any) => void): IDestroyable {
		32	argumentNotNull(cb, "cb");
		33
		34	if (this._reason) {
		35	cb(this._reason);
		36	return destroyed;
		37	} else {
		38	if (!this._cbs)
		39	this._cbs = [cb];
		40	else
		41	this._cbs.push(cb);
		42
		43	let me = this;
		44	return {
		45	destroy() {
		46	me._unregister(cb);
		47	}
		48	};
		49	}
		50	}
		51
		52	private _unregister(cb) {
		53	if(this._cbs) {
		54	let i = this._cbs.indexOf(cb);
		55	if ( i>=0 )
		56	this._cbs.splice(i,1);
		57	}
		58	}
		59
		60	private _cancel(reason) {
		61	if (this._reason)
		62	return;
		63
		64	this._reason = (reason = reason \|\| new Error("Operation cancelled"));
		65
		66
		67	if (this._cbs) {
		68	this._cbs.forEach(cb => cb(reason));
		69	this._cbs = null;
		70	}
		71	}
		72
		73	static readonly none: ICancellation = {
		74	isSupported(): boolean {
		75	return false;
		76	},
		77
		78	throwIfRequested(): void {
		79	},
		80
		81	isRequested(): boolean {
		82	return false;
		83	},
		84
		85	register(_cb: (e: any) => void): IDestroyable {
		86	return destroyed;
		87	}
		88	};
		89	} No newline at end of file

src/ts/components/ActivatableMixin.ts created 644 +87 0

			@@ -0,0 +1,87
		1	import { IActivationController, IActivatable, ICancellation } from '../interfaces';
		2	import { AsyncComponent } from './AsyncComponent';
		3	import { Cancellation } from '../Cancellation';
		4	import * as TraceSource from '../log/TraceSource';
		5
		6	type Constructor<T = {}> = new (...args: any[]) => T;
		7
		8	const log = TraceSource.get('@implab/core/components/ActivatableMixin');
		9
		10	function ActivatableMixin<TBase extends Constructor<AsyncComponent>>(Base: TBase) {
		11	return class extends Base implements IActivatable {
		12	_controller: IActivationController;
		13
		14	_active: boolean;
		15
		16	isActive() {
		17	return this._active;
		18	}
		19
		20	getActivationController() {
		21	return this._controller;
		22	}
		23
		24	setActivationController(controller: IActivationController) {
		25	this._controller = controller;
		26	}
		27
		28	async onActivating(ct: ICancellation) {
		29	if (this._controller)
		30	await this._controller.activating(this, ct);
		31	}
		32
		33	async onActivated(ct: ICancellation) {
		34	if (this._controller)
		35	await this._controller.activated(this, ct);
		36	}
		37
		38	activate(ct: ICancellation = Cancellation.none) {
		39	return this.runOperation(this._activateAsync.bind(this), ct);
		40	}
		41
		42	async _activateAsync(ct: ICancellation) {
		43	if (this.isActive())
		44	return;
		45
		46	await this.onActivating(ct);
		47	this._active = true;
		48	try {
		49	await this.onActivated(ct);
		50	} catch (e) {
		51	log.error("Suppressed onActivated error: {0}", e);
		52	}
		53	}
		54
		55	async onDeactivating(ct: ICancellation) {
		56	if (this._controller)
		57	await this._controller.deactivating(this, ct);
		58	}
		59
		60	async onDeactivated(ct: ICancellation) {
		61	if (this._controller)
		62	await this._controller.deactivated(this, ct);
		63	}
		64
		65	deactivate(ct: ICancellation = Cancellation.none) {
		66	return this.runOperation(this._deactivateAsync.bind(this), ct);
		67	}
		68
		69	async _deactivateAsync(ct: ICancellation) {
		70	if (!this.isActive())
		71	return;
		72	await this.onDeactivating(ct);
		73	this._active = false;
		74	try {
		75	await this.onDeactivated(ct);
		76	} catch (e) {
		77	log.error("Suppressed onDeactivated error: {0}", e);
		78	}
		79	}
		80	}
		81	}
		82
		83	namespace ActivatableMixin {
		84	export const traceSource = log;
		85	}
		86
		87	export = ActivatableMixin; No newline at end of file

src/ts/components/AsyncComponent.ts created 644 +17 0

			@@ -0,0 +1,17
		1	import { Cancellation } from "../Cancellation";
		2	import { IAsyncComponent, ICancellation } from "../interfaces";
		3
		4	export class AsyncComponent implements IAsyncComponent {
		5	_completion: Promise<void> = Promise.resolve();
		6
		7	getCompletion() { return this._completion };
		8
		9	runOperation(op: (ct: ICancellation) => any, ct: ICancellation = Cancellation.none) {
		10	// TODO create cancellation source here
		11	async function guard() {
		12	await op(ct);
		13	}
		14
		15	return this._completion = guard();
		16	}
		17	} No newline at end of file

src/ts/components/Observable.ts created 644 +198 0

			@@ -0,0 +1,198
		1	import { IObservable, IDestroyable, ICancellation } from '../interfaces';
		2	import { Cancellation } from '../Cancellation'
		3	import { argumentNotNull } from '../safe';
		4
		5
		6	interface Handler<T> {
		7	(x: T): void
		8	}
		9
		10	interface Initializer<T> {
		11	(notify: Handler<T>, error?: (e: any) => void, complete?: () => void): void;
		12	}
		13
		14	// TODO: think about to move this interfaces.ts and make it public
		15	interface IObserver<T> {
		16	next(event: T): void
		17
		18	error(e: any): void
		19
		20	complete(): void
		21	}
		22
		23	const noop = () => {};
		24
		25	class Observable<T> implements IObservable<T> {
		26	private _once = new Array<IObserver<T>>();
		27
		28	private _observers = new Array<IObserver<T>>();
		29
		30
		31	private _complete: boolean
		32
		33	private _error: any
		34
		35	constructor(func?: Initializer<T>) {
		36	if (func)
		37	func(
		38	this._notifyNext.bind(this),
		39	this._notifyError.bind(this),
		40	this._notifyCompleted.bind(this)
		41	);
		42	}
		43
		44	/**
		45	* Registers handlers for the current observable object.
		46	*
		47	* @param next the handler for events
		48	* @param error the handler for a error
		49	* @param complete the handler for a completion
		50	* @returns {IDestroyable} the handler for the current subscription, this
		51	* handler can be used to unsubscribe from events.
		52	*
		53	*/
		54	on(next: Handler<T>, error?: Handler<any>, complete?: () => void): IDestroyable {
		55	argumentNotNull(next, "next");
		56
		57	let me = this;
		58
		59	let observer: IObserver<T> & IDestroyable = {
		60	next: next,
		61	error: error ? error.bind(null) : noop,
		62	complete: complete ? complete.bind(null) : noop,
		63
		64	destroy() {
		65	me._removeObserver(this);
		66	}
		67	}
		68
		69	this._addObserver(observer);
		70
		71
		72	return observer;
		73	}
		74
		75	private _addObserver(observer: IObserver<T>) {
		76	if (this._complete) {
		77	try {
		78	if (this._error)
		79	observer.error(this._error);
		80	else
		81	observer.complete();
		82	} catch (e) {
		83	this.onObserverException(e);
		84	}
		85	} else {
		86	this._observers.push(observer);
		87	}
		88	}
		89
		90	/**
		91	* Waits for the next event. This method can't be used to read messages
		92	* as a sequence since it can skip some messages between calls.
		93	*
		94	* @param ct a cancellation token
		95	*/
		96	next(ct: ICancellation = Cancellation.none): Promise<T> {
		97	return new Promise<T>((resolve, reject) => {
		98	let observer: IObserver<T> = {
		99	next: resolve,
		100	error: reject,
		101	complete: () => reject("No more events are available")
		102	};
		103
		104	if (this._addOnce(observer) && ct.isSupported()) {
		105	ct.register((e) => {
		106	this._removeOnce(observer);
		107	reject(e);
		108	});
		109	}
		110	});
		111	}
		112
		113	private _addOnce(observer: IObserver<T>) {
		114	if (this._complete) {
		115	try {
		116	if (this._error)
		117	observer.error(this._error);
		118	else
		119	observer.complete();
		120	} catch (e) {
		121	this.onObserverException(e);
		122	}
		123	return false;
		124	}
		125
		126	this._once.push(observer);
		127	return true;
		128	}
		129
		130	protected onObserverException(e: any) {
		131	}
		132
		133	private _removeOnce(d: IObserver<T>) {
		134	let i = this._once.indexOf(d);
		135	if (i >= 0)
		136	this._once.splice(i, 1);
		137	}
		138
		139	private _removeObserver(d: IObserver<T>) {
		140	let i = this._observers.indexOf(d);
		141	if (i >= 0)
		142	this._observers.splice(i, 1);
		143	}
		144
		145	private _notify(guard: (observer: IObserver<T>) => void) {
		146	if (this._once.length) {
		147	for (let i = 0; i < this._once.length; i++)
		148	guard(this._once[i]);
		149	this._once = [];
		150	}
		151
		152	for (let i = 0; i < this._observers.length; i++)
		153	guard(this._observers[i]);
		154	}
		155
		156	protected _notifyNext(evt: T) {
		157	let guard = (observer: IObserver<T>) => {
		158	try {
		159	observer.next(evt);
		160	} catch (e) {
		161	this.onObserverException(e);
		162	}
		163	}
		164
		165	this._notify(guard);
		166	}
		167
		168	protected _notifyError(e: any) {
		169	let guard = (observer: IObserver<T>) => {
		170	try {
		171	observer.error(e);
		172	} catch (e) {
		173	this.onObserverException(e);
		174	}
		175	}
		176
		177	this._notify(guard);
		178	this._observers = [];
		179	}
		180
		181	protected _notifyCompleted() {
		182	let guard = (observer: IObserver<T>) => {
		183	try {
		184	observer.complete();
		185	} catch (e) {
		186	this.onObserverException(e);
		187	}
		188	}
		189
		190	this._notify(guard);
		191	this._observers = [];
		192	}
		193	}
		194
		195	namespace Observable {
		196	}
		197
		198	export = Observable; No newline at end of file

src/ts/interfaces.ts created 644 +76 0

			@@ -0,0 +1,76
		1	export interface IDestroyable {
		2	destroy();
		3	}
		4
		5	export interface ICancellation {
		6	throwIfRequested(): void;
		7	isRequested(): boolean;
		8	isSupported(): boolean;
		9	register(cb: (e: any) => void): IDestroyable;
		10	}
		11
		12	/**
		13	* Интерфейс поддерживающий асинхронную активацию
		14	*/
		15	export interface IActivatable {
		16	/**
		17	* @returns Boolean indicates the current state
		18	*/
		19	isActive(): boolean;
		20
		21	/**
		22	* Starts the component activation
		23	* @param ct cancellation token for this operation
		24	*/
		25	activate(ct?: ICancellation) : Promise<void>;
		26
		27	/**
		28	* Starts the component deactivation
		29	* @param ct cancellation token for this operation
		30	*/
		31	deactivate(ct?: ICancellation) : Promise<void>;
		32
		33	/**
		34	* Sets the activation controller for this component
		35	* @param controller The activation controller
		36	*
		37	* Activation controller checks whether this component
		38	* can be activated and manages the active state of the
		39	* component
		40	*/
		41	setActivationController(controller: IActivationController);
		42
		43	/**
		44	* Gets the current activation controller for this component
		45	*/
		46	getActivationController(): IActivationController;
		47	}
		48
		49	export interface IActivationController {
		50	activating(component: IActivatable, ct?: ICancellation): Promise<void>;
		51
		52	activated(component: IActivatable, ct?: ICancellation): Promise<void>;
		53
		54	deactivating(component: IActivatable, ct?: ICancellation): Promise<void>;
		55
		56	deactivated(component: IActivatable, ct?: ICancellation): Promise<void>;
		57
		58	deactivate(ct?: ICancellation): Promise<void>;
		59
		60	activate(component: IActivatable, ct?: ICancellation): Promise<void>;
		61
		62	getActive(): IActivatable;
		63	}
		64
		65	export interface IAsyncComponent {
		66	getCompletion(): Promise<void>;
		67	}
		68
		69	export interface ICancellable {
		70	cancel(reason?: any): void;
		71	}
		72
		73	export interface IObservable<T> {
		74	on(next: (x:T) => void, error?: (e:any) => void, complete?:() => void): IDestroyable;
		75	next(ct?: ICancellation) : Promise<T>;
		76	} No newline at end of file

src/ts/log/TraceEvent.ts created 644 +21 0

			@@ -0,0 +1,21
		1	import * as TraceSource from './TraceSource'
		2
		3	class TraceEvent {
		4	readonly source: TraceSource;
		5
		6	readonly level: Number;
		7
		8	readonly arg: any;
		9
		10	constructor(source: TraceSource, level: Number, arg: any) {
		11	this.source = source;
		12	this.level = level;
		13	this.arg = arg;
		14	}
		15	}
		16
		17	namespace TraceEvent {
		18
		19	}
		20
		21	export = TraceEvent No newline at end of file

src/ts/log/TraceSource.ts created 644 +171 0

			@@ -0,0 +1,171
		1	import * as format from '../text/format'
		2	import { argumentNotNull } from '../safe';
		3	import * as Observable from '../components/Observable'
		4	import { IDestroyable } from '../interfaces';
		5	import * as TraceEvent from './TraceEvent'
		6
		7	class Registry {
		8	static readonly instance = new Registry();
		9
		10	private _registry: object = new Object();
		11	private _listeners: object = new Object();
		12	private _nextCookie: number = 1;
		13
		14	get(id: any): TraceSource {
		15	argumentNotNull(id, "id");
		16
		17	if (this._registry[id])
		18	return this._registry[id];
		19
		20	var source = new TraceSource(id);
		21	this._registry[id] = source;
		22	this._onNewSource(source);
		23
		24	return source;
		25	}
		26
		27	add(id: any, source: TraceSource) {
		28	argumentNotNull(id, "id");
		29	argumentNotNull(source, "source");
		30
		31	this._registry[id] = source;
		32	this._onNewSource(source);
		33	}
		34
		35	_onNewSource(source: TraceSource) {
		36	for (let i in this._listeners)
		37	this._listeners[i].call(null, source);
		38	}
		39
		40	on(handler: (source: TraceSource) => void): IDestroyable {
		41	argumentNotNull(handler, "handler");
		42	var me = this;
		43
		44	var cookie = this._nextCookie++;
		45
		46	this._listeners[cookie] = handler;
		47
		48	for (let i in this._registry)
		49	handler(this._registry[i]);
		50
		51	return {
		52	destroy() {
		53	delete me._listeners[cookie];
		54	}
		55	};
		56	}
		57	}
		58
		59	class TraceSource extends Observable<TraceEvent> {
		60	readonly id: any
		61
		62	level: number
		63
		64	constructor(id: any) {
		65	super();
		66	this.id = id \|\| new Object();
		67	}
		68
		69	protected emit(level: number, arg: any) {
		70	this._notifyNext(new TraceEvent(this, level, arg));
		71	}
		72
		73	isDebugEnabled() {
		74	return this.level >= TraceSource.DebugLevel;
		75	}
		76
		77	debug(msg: string, ...args: any[]) {
		78	if (this.isEnabled(TraceSource.DebugLevel))
		79	this.emit(TraceSource.DebugLevel, format(msg, args));
		80	}
		81
		82	isLogEnabled() {
		83	return this.level >= TraceSource.LogLevel;
		84	}
		85
		86	log(msg: string, ...args: any[]) {
		87	if (this.isEnabled(TraceSource.LogLevel))
		88	this.emit(TraceSource.LogLevel, format(msg, args));
		89	}
		90
		91	isWarnEnabled() {
		92	return this.level >= TraceSource.WarnLevel;
		93	}
		94
		95	warn(msg: string, ...args: any[]) {
		96	if (this.isEnabled(TraceSource.WarnLevel))
		97	this.emit(TraceSource.WarnLevel, format(msg, args));
		98	}
		99
		100	/**
		101	* returns true if errors will be recorded.
		102	*/
		103	isErrorEnabled() {
		104	return this.level >= TraceSource.ErrorLevel;
		105	}
		106
		107	/**
		108	* Traces a error.
		109	*
		110	* @param msg the message.
		111	* @param args parameters which will be substituted in the message.
		112	*/
		113	error(msg: string, ...args: any[]) {
		114	if (this.isEnabled(TraceSource.ErrorLevel))
		115	this.emit(TraceSource.ErrorLevel, format(msg, args));
		116	}
		117
		118	/**
		119	* Checks whether the specified level is enabled for this
		120	* trace source.
		121	*
		122	* @param level the trace level which should be checked.
		123	*/
		124	isEnabled(level: number) {
		125	return (this.level >= level);
		126	}
		127
		128	/**
		129	* Traces a raw event, passing data as it is to the underlying listeners
		130	*
		131	* @param level the level of the event
		132	* @param arg the data of the event, can be a simple string or any object.
		133	*/
		134	traceEvent(level: number, arg: any) {
		135	if (this.isEnabled(level))
		136	this.emit(level, arg);
		137	}
		138
		139	/**
		140	* Register the specified handler to be called for every new and already
		141	* created trace source.
		142	*
		143	* @param handler the handler which will be called for each trace source
		144	*/
		145	static on(handler: (source: TraceSource) => void) {
		146	return Registry.instance.on(handler);
		147	}
		148
		149	/**
		150	* Creates or returns already created trace source for the specified id.
		151	*
		152	* @param id the id for the trace source
		153	*/
		154	static get(id: any) {
		155	return Registry.instance.get(id);
		156	}
		157	}
		158
		159	namespace TraceSource {
		160	export const DebugLevel = 400;
		161
		162	export const LogLevel = 300;
		163
		164	export const WarnLevel = 200;
		165
		166	export const ErrorLevel = 100;
		167
		168	export const SilentLevel = 0;
		169	}
		170
		171	export = TraceSource; No newline at end of file

src/ts/log/writers/ConsoleWriter.ts created 644 +35 0

			@@ -0,0 +1,35
		1	import { IObservable, IDestroyable, ICancellation } from "../../interfaces";
		2	import * as TraceEvent from '../TraceEvent';
		3	import { Cancellation } from "../../Cancellation";
		4	import * as TraceSource from "../TraceSource";
		5
		6	class ConsoleWriter implements IDestroyable {
		7	readonly _subscriptions = new Array<IDestroyable>();
		8
		9	writeEvents(source: IObservable<TraceEvent>, ct: ICancellation = Cancellation.none) {
		10	var subscription = source.on(this.writeEvent.bind(this));
		11	if (ct.isSupported()) {
		12	ct.register(subscription.destroy.bind(subscription));
		13	}
		14	this._subscriptions.push(subscription);
		15	}
		16
		17	writeEvent(next: TraceEvent) {
		18	if (next.level >= TraceSource.LogLevel) {
		19	console.log(next.source.id.toString(), next.arg);
		20	} else if(next.level >= TraceSource.WarnLevel) {
		21	console.warn(next.source.id.toString(), next.arg);
		22	} else {
		23	console.error(next.source.id.toString(), next.arg);
		24	}
		25	}
		26
		27	destroy() {
		28	this._subscriptions.forEach(x => x.destroy());
		29	}
		30	}
		31
		32	namespace ConsoleWriter {
		33	}
		34
		35	export = ConsoleWriter; No newline at end of file

src/ts/safe.ts created 644 +231 0

			@@ -0,0 +1,231
		1	export function argumentNotNull(arg, name) {
		2	if (arg === null \|\| arg === undefined)
		3	throw new Error("The argument " + name + " can't be null or undefined");
		4	}
		5
		6	export function argumentNotEmptyString(arg, name) {
		7	if (typeof (arg) !== "string" \|\| !arg.length)
		8	throw new Error("The argument '" + name + "' must be a not empty string");
		9	}
		10
		11	export function argumentNotEmptyArray(arg, name) {
		12	if (!(arg instanceof Array) \|\| !arg.length)
		13	throw new Error("The argument '" + name + "' must be a not empty array");
		14	}
		15
		16	export function argumentOfType(arg, type, name) {
		17	if (!(arg instanceof type))
		18	throw new Error("The argument '" + name + "' type doesn't match");
		19	}
		20
		21	export function isNull(arg) {
		22	return (arg === null \|\| arg === undefined);
		23	}
		24
		25	export function isPrimitive(arg) {
		26	return (arg === null \|\| arg === undefined \|\| typeof (arg) === "string" \|\|
		27	typeof (arg) === "number" \|\| typeof (arg) === "boolean");
		28	}
		29
		30	export function isInteger(arg) {
		31	return parseInt(arg) == arg;
		32	}
		33
		34	export function isNumber(arg) {
		35	return parseFloat(arg) == arg;
		36	}
		37
		38	export function isString(val) {
		39	return typeof (val) == "string" \|\| val instanceof String;
		40	}
		41
		42	export function isNullOrEmptyString(str) {
		43	if (str === null \|\| str === undefined \|\|
		44	((typeof (str) == "string" \|\| str instanceof String) && str.length === 0))
		45	return true;
		46	}
		47
		48	export function isNotEmptyArray(arg) {
		49	return (arg instanceof Array && arg.length > 0);
		50	}
		51
		52	/**
		53	* Выполняет метод для каждого элемента массива, останавливается, когда
		54	* либо достигнут конец массива, либо функция <c>cb</c> вернула
		55	* значение.
		56	*
		57	* @param {Array \| Object} obj массив элементов для просмотра
		58	* @param {Function} cb функция, вызываемая для каждого элемента
		59	* @param {Object} thisArg значение, которое будет передано в качестве
		60	* <c>this</c> в <c>cb</c>.
		61	* @returns Результат вызова функции <c>cb</c>, либо <c>undefined</c>
		62	* если достигнут конец массива.
		63	*/
		64	export function each(obj, cb, thisArg) {
		65	argumentNotNull(cb, "cb");
		66	var i, x;
		67	if (obj instanceof Array) {
		68	for (i = 0; i < obj.length; i++) {
		69	x = cb.call(thisArg, obj[i], i);
		70	if (x !== undefined)
		71	return x;
		72	}
		73	} else {
		74	var keys = Object.keys(obj);
		75	for (i = 0; i < keys.length; i++) {
		76	var k = keys[i];
		77	x = cb.call(thisArg, obj[k], k);
		78	if (x !== undefined)
		79	return x;
		80	}
		81	}
		82	}
		83
		84	/** Wraps the specified function to emulate an asynchronous execution.
		85	* @param{Object} thisArg [Optional] Object which will be passed as 'this' to the function.
		86	* @param{Function\|String} fn [Required] Function wich will be wrapped.
		87	*/
		88	export function async(_fn: (...args: any[]) => any, thisArg) : (...args: any[]) => PromiseLike<any> {
		89	let fn = _fn;
		90
		91	if (arguments.length == 2 && !(fn instanceof Function))
		92	fn = thisArg[fn];
		93
		94	if (fn == null)
		95	throw new Error("The function must be specified");
		96
		97	function wrapresult(x, e?) : PromiseLike<any> {
		98	if (e) {
		99	return {
		100	then: function (cb, eb) {
		101	try {
		102	return eb ? wrapresult(eb(e)) : this;
		103	} catch (e2) {
		104	return wrapresult(null, e2);
		105	}
		106	}
		107	};
		108	} else {
		109	if (x && x.then)
		110	return x;
		111	return {
		112	then: function (cb) {
		113	try {
		114	return cb ? wrapresult(cb(x)) : this;
		115	} catch (e2) {
		116	return wrapresult(e2);
		117	}
		118	}
		119	};
		120	}
		121	}
		122
		123	return function () {
		124	try {
		125	return wrapresult(fn.apply(thisArg, arguments));
		126	} catch (e) {
		127	return wrapresult(null, e);
		128	}
		129	};
		130	}
		131
		132	export function delegate(target, _method: (string \| Function)) {
		133	let method : Function;
		134
		135	if (!(_method instanceof Function)) {
		136	argumentNotNull(target, "target");
		137	method = target[_method];
		138	} else {
		139	method = _method;
		140	}
		141
		142	if (!(method instanceof Function))
		143	throw new Error("'method' argument must be a Function or a method name");
		144
		145	return function () {
		146	return method.apply(target, arguments);
		147	};
		148	}
		149
		150	/**
		151	* Для каждого элемента массива вызывает указанную функцию и сохраняет
		152	* возвращенное значение в массиве результатов.
		153	*
		154	* @remarks cb может выполняться асинхронно, при этом одновременно будет
		155	* только одна операция.
		156	*
		157	* @async
		158	*/
		159	export function pmap(items, cb) {
		160	argumentNotNull(cb, "cb");
		161
		162	if (items && items.then instanceof Function)
		163	return items.then(function (data) {
		164	return pmap(data, cb);
		165	});
		166
		167	if (isNull(items) \|\| !items.length)
		168	return items;
		169
		170	var i = 0,
		171	result = [];
		172
		173	function next() {
		174	var r, ri;
		175
		176	function chain(x) {
		177	result[ri] = x;
		178	return next();
		179	}
		180
		181	while (i < items.length) {
		182	r = cb(items[i], i);
		183	ri = i;
		184	i++;
		185	if (r && r.then) {
		186	return r.then(chain);
		187	} else {
		188	result[ri] = r;
		189	}
		190	}
		191	return result;
		192	}
		193
		194	return next();
		195	}
		196
		197	/**
		198	* Выбирает первый элемент из последовательности, или обещания, если в
		199	* качестве параметра используется обещание, оно должно вернуть массив.
		200	*
		201	* @param {Function} cb обработчик результата, ему будет передан первый
		202	* элемент последовательности в случае успеха
		203	* @param {Function} err обработчик исключения, если массив пустой, либо
		204	* не массив
		205	*
		206	* @remarks Если не указаны ни cb ни err, тогда функция вернет либо
		207	* обещание, либо первый элемент.
		208	* @async
		209	*/
		210	export function first(sequence: any, cb: Function, err: Function) {
		211	if (sequence) {
		212	if (sequence.then instanceof Function) {
		213	return sequence.then(function (res) {
		214	return first(res, cb, err);
		215	}, err);
		216	} else if (sequence && "length" in sequence) {
		217	if (sequence.length === 0) {
		218	if (err)
		219	return err(new Error("The sequence is empty"));
		220	else
		221	throw new Error("The sequence is empty");
		222	}
		223	return cb ? cb(sequence[0]) : sequence[0];
		224	}
		225	}
		226
		227	if (err)
		228	return err(new Error("The sequence is required"));
		229	else
		230	throw new Error("The sequence is required");
		231	} No newline at end of file

src/ts/text/format.d.ts created 644 +7 0

			@@ -0,0 +1,7
		1	declare function format(format: string, ...args: any[]): string;
		2
		3	declare namespace format {
		4
		5	}
		6
		7	export = format; No newline at end of file

test/js/trace-test.js created 644 +29 0

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

test/ts/ActivatableTests.ts created 644 +108 0

			@@ -0,0 +1,108
		1	import * as tape from 'tape';
		2	import * as ActivatableMixin from '@implab/core/components/ActivatableMixin';
		3	import { AsyncComponent } from '@implab/core/components/AsyncComponent';
		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
		26	async activate(component: IActivatable) {
		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
		39	async activated(component: IActivatable, ct: ICancellation = Cancellation.none) {
		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());
		57
		58	await a.activate();
		59	t.true(a.isActive());
		60
		61	await a.deactivate();
		62	t.false(a.isActive());
		63
		64	t.end();
		65	});
		66
		67	tape('controller activation', async function(t) {
		68
		69	let a = new SimpleActivatable();
		70	let c = new MockActivationController();
		71
		72	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");
		74	t.assert(a.getActivationController() == null, "the component doesn't have an activation controller by default");
		75
		76	t.comment("Active the component through the controller");
		77	await c.activate(a);
		78	t.true(a.isActive(), "The component should successfully activate");
		79	t.equal(c.getActive(), a, "The controller should point to the activated component");
		80	t.equal(a.getActivationController(), c, "The component should point to the controller");
		81
		82	t.comment("Deactive the component throug the controller");
		83	await c.deactivate();
		84
		85	t.false(a.isActive(), "The component should successfully deactivate");
		86	t.equal(c.getActive(), null, "The controller shouldn't point to any component");
		87	t.equal(a.getActivationController(), c, "The componet should point to it's controller");
		88
		89	t.end();
		90	});
		91
		92	tape('handle error in onActivating', async function(t) {
		93	let a = new SimpleActivatable();
		94
		95	a.onActivating = async function() {
		96	throw "Should fail";
		97	};
		98
		99	try {
		100	await a.activate();
		101	t.fail("activation should fail");
		102	} catch {
		103	}
		104
		105	t.false(a.isActive(), "the component should remain inactive");
		106
		107	t.end();
		108	}); No newline at end of file

test/ts/CancellationTests.ts created 644 +97 0

			@@ -0,0 +1,97
		1	import * as tape from 'tape';
		2	import { Cancellation } from '@implab/core/Cancellation';
		3	import { ICancellation } from '@implab/core/interfaces';
		4	import { delay } from './TestTraits';
		5
		6	tape('standalone cancellation', async t => {
		7
		8	let doCancel: (e) => void;
		9
		10	let ct = new Cancellation(cancel => {
		11	doCancel = cancel;
		12	});
		13
		14	let counter = 0;
		15	let reason = "BILL";
		16
		17	t.true(ct.isSupported(), "Cancellation must be supported");
		18	t.false(ct.isRequested(), "Cancellation shouldn't be requested");
		19	ct.throwIfRequested();
		20	t.pass("The exception shouldn't be thrown unless the cancellation is requested");
		21
		22	ct.register(() => counter++);
		23	t.equals(counter, 0, "counter should be zero");
		24
		25	ct.register(() => counter++).destroy();
		26
		27	doCancel(reason);
		28
		29	t.true(ct.isRequested(), "Cancellation should be requested");
		30	t.equals(counter, 1, "The registered callback should be triggered");
		31
		32	ct.register(() => counter++);
		33	t.equals(counter, 2, "The callback should be triggered immediately");
		34
		35	let msg;
		36	ct.register((e) => msg = e);
		37	t.equals(msg, reason, "The cancellation reason should be passed to callback");
		38
		39	try {
		40	msg = null;
		41	ct.throwIfRequested();
		42	t.fail("The exception should be thrown");
		43	} catch (e) {
		44	msg = e;
		45	}
		46	t.equals(msg, reason, "The cancellation reason should be catched");
		47
		48	t.end();
		49	});
		50
		51	tape('async cancellation', async t => {
		52
		53	let ct = new Cancellation(cancel => {
		54	cancel("STOP!");
		55	});
		56
		57	try {
		58	await delay(0, ct);
		59	t.fail("Should thow the exception");
		60	} catch (e) {
		61	t.equals(e, "STOP!", "Should throw the cancellation reason");
		62	}
		63
		64	t.end();
		65	});
		66
		67	tape('cancel with external event', async t => {
		68	let ct = new Cancellation((cancel) => {
		69	setTimeout(x => cancel('STOP!'), 0);
		70	})
		71
		72	try {
		73	await delay(10000, ct);
		74	t.fail("Should thow the exception");
		75	} catch (e) {
		76	t.equals(e, "STOP!", "Should throw the cancellation reason");
		77	}
		78
		79	t.end();
		80	});
		81
		82	tape('operation normal flow', async t => {
		83
		84	let htimeout;
		85	let ct = new Cancellation((cancel) => {
		86	htimeout = setTimeout(() => cancel("STOP!"), 1000);
		87	});
		88
		89	try {
		90	await delay(0, ct);
		91	t.pass("Should pass");
		92	} finally {
		93	clearTimeout(htimeout);
		94	}
		95
		96	t.end();
		97	}); No newline at end of file

test/ts/TestTraits.ts created 644 +63 0

			@@ -0,0 +1,63
		1	import { IObservable, ICancellation, IDestroyable } from "../../build/dist/interfaces";
		2	import * as TraceEvent from '../../build/dist/log/TraceEvent';
		3	import { Cancellation } from "../../build/dist/Cancellation";
		4	import * as TraceSource from "../../build/dist/log/TraceSource";
		5	import * as tape from 'tape';
		6	import { argumentNotNull } from "../../build/dist/safe";
		7
		8	export class TapeWriter implements IDestroyable {
		9	readonly _tape: tape.Test
		10
		11	_subscriptions = new Array<IDestroyable>();
		12
		13	constructor(tape: tape.Test) {
		14	argumentNotNull(tape, "tape");
		15	this._tape = tape;
		16	}
		17
		18	writeEvents(source: IObservable<TraceEvent>, ct: ICancellation = Cancellation.none) {
		19	let subscription = source.on(this.writeEvent.bind(this));
		20	if (ct.isSupported()) {
		21	ct.register(subscription.destroy.bind(subscription));
		22	}
		23	this._subscriptions.push(subscription);
		24	}
		25
		26	writeEvent(next: TraceEvent) {
		27	if (next.level >= TraceSource.LogLevel) {
		28	this._tape.comment("LOG " + next.arg);
		29	} else if (next.level >= TraceSource.WarnLevel) {
		30	this._tape.comment("WARN " + next.arg);
		31	} else {
		32	this._tape.comment("ERROR " + next.arg);
		33	}
		34	}
		35
		36	destroy() {
		37	this._subscriptions.forEach(x => x.destroy());
		38	}
		39	}
		40
		41	export async function delay(timeout: number, ct: ICancellation = Cancellation.none) {
		42	let un: IDestroyable;
		43
		44	try {
		45	await new Promise((resolve, reject) => {
		46	if (ct.isRequested()) {
		47	un = ct.register(reject);
		48	} else {
		49	let ht = setTimeout(() => {
		50	resolve();
		51	}, timeout);
		52
		53	un = ct.register(e => {
		54	clearTimeout(ht);
		55	reject(e);
		56	});
		57	}
		58	});
		59	} finally {
		60	if(un)
		61	un.destroy();
		62	};
		63	} No newline at end of file

test/ts/TraceSourceTests.ts created 644 +69 0

			@@ -0,0 +1,69
		1	import * as TraceSource from '@implab/core/log/TraceSource'
		2	import * as tape from 'tape';
		3	import { TapeWriter } from './TestTraits';
		4
		5	const sourceId = 'test/TraceSourceTests';
		6
		7	tape('trace message', t => {
		8	let trace = TraceSource.get(sourceId);
		9
		10	trace.level = TraceSource.DebugLevel;
		11
		12	let h = trace.on((ev) => {
		13	t.equal(ev.source, trace, "sender should be the current trace source");
		14	t.equal(ev.level, TraceSource.DebugLevel, "level should be debug level");
		15	t.equal(ev.arg, "Hello, World!", "The message should be a formatted message");
		16
		17	t.end();
		18	});
		19
		20	trace.debug("Hello, {0}!", "World");
		21
		22	h.destroy();
		23	});
		24
		25	tape('trace event', t => {
		26	let trace = TraceSource.get(sourceId);
		27
		28	trace.level = TraceSource.DebugLevel;
		29
		30	let event = {
		31	name: "custom event"
		32	};
		33
		34	let h = trace.on((ev) => {
		35	t.equal(ev.source, trace, "sender should be the current trace source");
		36	t.equal(ev.level, TraceSource.DebugLevel, "level should be debug level");
		37	t.equal(ev.arg, event, "The message should be the specified object");
		38
		39	t.end();
		40	});
		41
		42	trace.traceEvent(TraceSource.DebugLevel, event);
		43
		44	h.destroy();
		45	});
		46
		47	tape('tape comment writer', async t => {
		48	let writer = new TapeWriter(t);
		49
		50	TraceSource.on(ts => {
		51	writer.writeEvents(ts);
		52	});
		53
		54	let trace = TraceSource.get(sourceId);
		55	trace.level = TraceSource.DebugLevel;
		56
		57	trace.log("Hello, {0}!", 'World');
		58	trace.log("Multi\n line");
		59	trace.warn("Look at me!");
		60	trace.error("DIE!");
		61
		62	writer.destroy();
		63
		64	trace.log("You shouldn't see it!");
		65
		66	t.comment("DONE");
		67
		68	t.end();
		69	}); No newline at end of file

build.gradle +2 -1

              task clean {
                  doLast {
                      delete buildDir
+                     delete 'node_modules/@implab'
                  }
              }
              task _packageMeta(type: Copy) {
                  inputs.property("version", version)
                  from('.') {
-                     include 'package.json', 'readme.md', 'license', 'history.md'
+                     include 'package.json', '.npmignore', 'readme.md', 'license', 'history.md'
                  }
                  into distDir
                  doLast {

package-lock.json +7 -7

                      },
                      "minimist": {
                        "version": "0.0.5",
-                       "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.5.tgz",
+                       "resolved": "http://registry.npmjs.org/minimist/-/minimist-0.0.5.tgz",
                        "integrity": "sha1-16oye87PUY+RBqxrjwA/o7zqhWY=",
                        "dev": true
                      },
                    }
                  },
                  "requirejs": {
-                   "version": "2.3.5",
-                   "resolved": "https://registry.npmjs.org/requirejs/-/requirejs-2.3.5.tgz",
-                   "integrity": "sha512-svnO+aNcR/an9Dpi44C7KSAy5fFGLtmPbaaCeQaklUz8BQhS64tWWIIlvEA5jrWICzlO/X9KSzSeXFnZdBu8nw==",
+                   "version": "2.3.6",
+                   "resolved": "https://registry.npmjs.org/requirejs/-/requirejs-2.3.6.tgz",
+                   "integrity": "sha512-ipEzlWQe6RK3jkzikgCupiTbTvm4S0/CAU5GlgptkN5SO6F3u0UD0K18wy6ErDqiCyP4J4YYe1HuAShvsxePLg==",
                    "dev": true
                  },
                  "resolve": {
                    }
                  },
                  "typescript": {
-                   "version": "2.9.2",
-                   "resolved": "https://registry.npmjs.org/typescript/-/typescript-2.9.2.tgz",
-                   "integrity": "sha512-Gr4p6nFNaoufRIY4NMdpQRNmgxVIGMs4Fcu/ujdYk3nAZqk7supzBE9idmvfZIlH/Cuj//dvi+019qEue9lV0w==",
+                   "version": "3.0.3",
+                   "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.0.3.tgz",
+                   "integrity": "sha512-kk80vLW9iGtjMnIv11qyxLqZm20UklzuR2tL0QAnDIygIUIemcZMxlMWudl9OOt76H3ntVzcTiddQ1/pAAJMYg==",
                    "dev": true
                  },
                  "wrappy": {

run-amd-tests.js +4 0

                      {
                          name: "test",
                          location: "build/test"
+                     },
+                     {
+                         name: "dojo",
+                         location: "node_modules/dojo"
                      }
                  ],
                  nodeRequire: require

src/js/di/Container.js +1 -1

                          if (typeof (config) === "string") {
                              p = new Deferred();
                              if (!contextRequire) {
-                                 var shim = [config, new Uuid()].join(config.indexOf("/") != -1 ? "-" : "/");
+                                 var shim = [config, Uuid()].join(config.indexOf("/") != -1 ? "-" : "/");
                                  define(shim, ["require", config], function (ctx, data) {
                                      p.resolve([data, {
                                          contextRequire: ctx

src/js/log/trace.js +23 -89

		@@ -1,74 +1,14
1		define([".~~./text/format~~"], function (~~format~~) {
	1	define(["./TraceSource"], function (TraceSource) {
2	2	'use strict';
3	3
4		var listeners = [];
5		var channels = {};
6
7		var Trace = function (name) {
8		this.name = name;
9		this._subscribers = [];
10		};
11
12		Trace.prototype.debug = function () {
13		if (Trace.level >= 4)
14		this.notify("debug", format.apply(null, arguments));
15		};
16
17		Trace.prototype.log = function () {
18		if (Trace.level >= 3)
19		this.notify("log", format.apply(null, arguments));
20		};
21
22		Trace.prototype.warn = function () {
23		if (Trace.level >= 2)
24		this.notify("warn", format.apply(null, arguments));
25
26		};
27
28		Trace.prototype.error = function () {
29		if (Trace.level >= 1)
30		this.notify("error", format.apply(null, arguments));
31		};
	4	return {
32	5
33		Trace.prototype.notify = function (name, msg) {
34		var me = this;
35		me._subscribers.forEach(function (cb) {
36		cb(me, name, msg);
37		});
38		};
39
40		Trace.prototype.subscribe = function (cb) {
41		this._subscribers.push(cb);
42		};
43
44		Trace.prototype.toString = function () {
45		return this.name;
46		};
47
48		Trace.createChannel = function (type, name, cb) {
49		var chId = name;
50		if (channels[chId])
51		return channels[chId];
52
53		var channel = new type(chId);
54		channels[chId] = channel;
55
56		Trace._onNewChannel(chId, channel);
57		cb(channel);
58		};
59
60		Trace._onNewChannel = function (chId, ch) {
61		listeners.forEach(function (listener) {
62		listener(chId, ch);
63		});
64		};
65
66		Trace.on = function (filter, cb) {
	6	on: function (filter, cb) {
67	7	if (arguments.length == 1) {
68	8	cb = filter;
69	9	filter = undefined;
70	10	}
71		var d, test;
	11	var test;
72	12	if (filter instanceof RegExp) {
73	13	test = function (chId) {
74	14	return filter.test(chId);
		@@ -82,35 +22,29 define(["../text/format"], function (for
82	22	}
83	23
84	24	if (test) {
85		d = ~~function~~(~~chId~~, ch) {
86		if(test(~~chI~~d))
87		ch.~~subscribe~~(cb);
88		};
	25	TraceSource.on(function (source) {
	26	if (test(source.id))
	27	source.on(cb);
	28	});
89	29	} else {
90		d = ~~function~~(~~chId~~, ch) {
91		ch.~~subscribe~~(cb);
92		};
	30	TraceSource.on(function (source) {
	31	source.on(cb);
	32	});
93	33	}
94		listeners.push(d);
95
96		for(var chId in channels)
97		d(chId,channels[chId]);
98		};
	34	},
99	35
100		~~Trace~~.load = function (id, require, cb) {
101		if (id)
102		Trace.createChannel(Trace, id, cb);
103		else if (require.module && require.module.mid)
104		Trace.~~createChannel~~(~~Trace~~, require.module.mid, cb);
105		else
	36	load: function (id, require, cb) {
	37	if (id) {
	38	cb(TraceSource.get(id));
	39	} else if (require.module && require.module.mid) {
	40	cb(TraceSource.get(require.module.mid));
	41	} else {
106	42	require(['module'], function (module) {
107		Trace.~~createChannel~~(~~Trace~~, module && module.id, cb);
	43	cb(TraceSource.get(module && module.id));
108	44	});
109		};
110
111		Trace.dynamic = true;
	45	}
	46	},
112	47
113		Trace.level = 4;
114
115		return Trace;
	48	dynamic: true,
	49	};
116	50	}); No newline at end of file

src/js/text/format-compile.js +2 -2

                      var espaceString = function(s) {
                          if (!s)
                              return s;
-                         return "'" + s.replace(/('|\\)/g, "\\$1") + "'";
+                         return "'" + s.replace(/('|\\)/g, "\\$1").replace("\n","\\n") + "'";
                      };
                      var encode = function(s) {
                          if (!s)
                              return s;
-                         return s.replace(/\\{|\\}|&|\\:/g, function(m) {
+                         return s.replace(/\\{|\\}|&|\\:|\n/g, function(m) {
                              return map[m] || m;
                          });
                      };

src/ts/Uuid.ts +2 0

              //     Copyright (c) 2010-2012 Robert Kieffer
              //     MIT License - http://opensource.org/licenses/mit-license.php
+             declare var window: any;
              let _window : any = 'undefined' !== typeof window ? window : null;
              // Unique ID creation requires a high quality random # generator. We

test/js/plan.js +2 -1

		@@ -1,1 +1,2
1		define(["./dummy", "./example"]); No newline at end of file
	1	define(["./ActivatableTests", "./trace-test", "./TraceSourceTests", "./CancellationTests"]);
	2	//define(["./CancellationTests"]); No newline at end of file

tsc.json +4 -1

                      "module": "amd",
                      "sourceMap": true,
                      "outDir" : "build/dist",
-                     "declaration": true
+                     "declaration": true,
+                     "lib": [
+                         "ES2015"
+                     ]
                  },
                  "include" : [
                      "src/ts/**/*.ts"

tsc.test.json +4 -1

                      "module": "amd",
                      "sourceMap": true,
                      "outDir" : "build/test",
-                     "moduleResolution": "node"
+                     "moduleResolution": "node",
+                     "lib": [
+                         "ES2015"
+                     ]
                  },
                  "include" : [
                      "test/ts/**/*.ts"

src/js/components/ActivationController.js removed 0 -120

NO CONTENT: file was removed

src/js/components/StateMachine.js removed 0 -34

NO CONTENT: file was removed

src/js/components/_ActivatableMixin.js removed 0 -153

NO CONTENT: file was removed

src/js/log/ConsoleLogChannel.js removed 0 -30

NO CONTENT: file was removed

src/js/log/_LogMixin.js removed 0 -67

NO CONTENT: file was removed

src/js/log/listeners/console.js removed 0 -25

NO CONTENT: file was removed

src/js/safe.js removed 0 -323

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