implab/implabjs-core Commit - r29:e0b5fc764f84

Merged in propose observables (pull request #2)...

m407 -

r29:e0b5fc764f84 default

parent child

Context file:

r29:e0b5fc764f84

Collapse all files

docs/en/observable.md created 644 +135 0

@@ -0,0 +1,135
	1	# Observable
	2
	3	Универсальный способ организации потока сообщений. Данный механизм может
	4	использоваться для оповещения об изменениях состояний объектов или для доставки
	5	самостоятельных событий, например, связанных с действиями пользователя.
	6
	7	Является реализацией классического шаблона наблюдателя с возможность сообщить
	8	о коце потока событий. Данная реализация не содержит никаких дополнительных
	9	функций, таких как фильтрация, канал с состоянием, преобразования сообщений и
	10	т.п. Это сделано специально, чтобы реализация оставалась максимально простой.
	11
	12	Пример того, как можно создать последовательность из 10 событий:
	13
	14	```ts
	15	var events = new Observable(async (notify, error, complete) => {
	16	// цикл в котором возникает событие
	17	for(let i = 0; i < 10; i++) {
	18	await delay(1000);
	19	// в качестве данных передается номер события
	20	notify(i);
	21	}
	22	// по окончании последовательности информируем, что событий больше не будет
	23	compelte();
	24	});
	25
	26	// создаем окно с отображением хода событий
	27	var progress = showProgress({ min: 0, max: 9, current: 0});
	28
	29	// подписываемся на события
	30	events.on(
	31	// обработчик очередного события
	32	msg => {
	33	progress.setValue(msg);
	34	}.
	35	// обработчик ошибки
	36	e => {
	37	progress.showError(e);
	38	},
	39	// обработчик конца потока
	40	() => {
	41	progress.close();
	42	}
	43	);
	44
	45	// ожидание следующего события
	46	let firstEvent = await events.next();
	47	```
	48
	49	`Observable` можно создавать из событий другого объекта, например, виджета:
	50
	51	```ts
	52	// клсс
	53	class Canvas {
	54	readonly mouseMove: IObservable<[number,number]>
	55
	56	postCreate() {
	57	// превращаем события виджета в Observable
	58	this.mouseMove = new Observable<[number,number]>((notify) => {
	59	this.mousePad.on('mousemove',(e) => notify([e.clientX, e.clientY]) );
	60	});
	61	}
	62	}
	63
	64	```
	65
	66	Если объект инкапсулирует в себе `Observable`, он также может сохранить методы
	67	для оповещения подписчиков для дальнейшего их использования внутри класса.
	68
	69	```ts
	70	// класс, который будет генерировать события местоположения
	71	class PositionTracker implements IDestroyable {
	72	// _nextPosition и _complete будут связаны с position при создании
	73	// экземпляра PositionTracker.
	74	_nextPosition: (pos: Position) => void
	75	_complete: () => void
	76
	77	readonly position: IObservable<Position>
	78
	79	// конструктор
	80	constructor(...args: any[]) {
	81	super(args);
	82
	83	// создаем Observable
	84	this.position = new Observable<Position>((notify, error, complete) => {
	85	// сохраняем методы для оповещения о новом местоположении
	86	this._nextPosition = notify;
	87	// метод об оповещении конца потока событий
	88	this._complete = complete
	89	});
	90	}
	91
	92	// метод для очистки ресурсов
	93	destroy() {
	94	this._complete();
	95
	96	super();
	97	}
	98	}
	99
	100	```
	101
	102	## Observable и последовательности
	103
	104	Можно сичтать, что `Observable` это некоторая аналогия итератора только в
	105	парадигме событийного (или реактивного) программировния. Следует также понимать,
	106	что при переходе от синхронного процедурного программирования к событийному так
	107	же меняется и направление управления (Inverse Of Control), что означает
	108	следующее:
	109
	110	* при работе с итераторами клиенты сами определяют момент чтения следующего
	111	элемента последовательности.
	112	* при работе с `Observable` клиенты вынуждены обрабатывать эти события по мере
	113	их поступления и не могут на это повлиять.
	114
	115	Последний пункт можно изменить применив, например, буффер или канал с
	116	состоянием, т.е. очередь, но данные механизмы выходят за рамки простого шаблона
	117	наблюдателя.
	118
	119	```ts
	120	while(1) {
	121	// ожидаем следующее событие, по сути это подписка только на одно событие
	122	let next = await events.next();
	123
	124	// такой цикл может пропускать сообщения, поскольку асинхронная операция
	125	// позволит возобновить создание новых событий, на которые мы не подписаны
	126	await processEvent(next);
	127
	128	// не только асинхронные операции могут привести к пропуску события
	129	// например вызов метода, который приводит к созданию события так же
	130	// приведет к тому, что созданное событие не будет обработано в текущем
	131	// цикле
	132	doSmthAndRiseEvent();
	133	}
	134
	135	``` No newline at end of file

docs/ru/observable.md created 644 +186 0

@@ -0,0 +1,186
	1	# Observable
	2
	3	Универсальный способ организации потока сообщений. Данный механизм может
	4	использоваться для оповещения об изменениях состояний объектов или для доставки
	5	самостоятельных событий, например, связанных с действиями пользователя.
	6
	7	Является реализацией классического шаблона наблюдателя с возможность сообщить
	8	о коце потока событий. Данная реализация не содержит никаких дополнительных
	9	функций, таких как фильтрация, канал с состоянием, преобразования сообщений и
	10	т.п. Это сделано специально, чтобы реализация оставалась максимально простой.
	11
	12	Пример того, как можно создать последовательность из 10 событий:
	13
	14	```ts
	15	var events = new Observable(async (notify, error, complete) => {
	16	// цикл в котором возникает событие
	17	for(let i = 0; i < 10; i++) {
	18	await delay(1000);
	19	// в качестве данных передается номер события
	20	notify(i);
	21	}
	22	// по окончании последовательности информируем, что событий больше не будет
	23	compelte();
	24	});
	25
	26	// создаем окно с отображением хода событий
	27	var progress = showProgress({ min: 0, max: 9, current: 0});
	28
	29	// подписываемся на события
	30	events.on(
	31	// обработчик очередного события
	32	msg => {
	33	progress.setValue(msg);
	34	}.
	35	// обработчик ошибки
	36	e => {
	37	progress.showError(e);
	38	},
	39	// обработчик конца потока
	40	() => {
	41	progress.close();
	42	}
	43	);
	44
	45	// ожидание следующего события
	46	let firstEvent = await events.next();
	47	```
	48
	49	`Observable` можно создавать из событий другого объекта, например, виджета:
	50
	51	```ts
	52	// клсс
	53	class Canvas {
	54	readonly mouseMove: IObservable<[number,number]>
	55
	56	postCreate() {
	57	// превращаем события виджета в Observable
	58	this.mouseMove = new Observable<[number,number]>((notify) => {
	59	this.mousePad.on('mousemove',(e) => notify([e.clientX, e.clientY]) );
	60	});
	61	}
	62	}
	63
	64	```
	65
	66	Если объект инкапсулирует в себе `Observable`, он также может сохранить методы
	67	для оповещения подписчиков для дальнейшего их использования внутри класса.
	68
	69	```ts
	70	// класс, который будет генерировать события местоположения
	71	class PositionTracker implements IDestroyable {
	72	// _nextPosition и _complete будут связаны с position при создании
	73	// экземпляра PositionTracker.
	74	_nextPosition: (pos: Position) => void
	75	_complete: () => void
	76
	77	readonly position: IObservable<Position>
	78
	79	// конструктор
	80	constructor(...args: any[]) {
	81	super(args);
	82
	83	// создаем Observable
	84	this.position = new Observable<Position>((notify, error, complete) => {
	85	// сохраняем методы для оповещения о новом местоположении
	86	this._nextPosition = notify;
	87	// метод об оповещении конца потока событий
	88	this._complete = complete
	89	});
	90	}
	91
	92	// метод для очистки ресурсов
	93	destroy() {
	94	this._complete();
	95
	96	super();
	97	}
	98	}
	99	```
	100
	101	Существует также несколько варинатов получения сообщений
	102
	103	```ts
	104	// регистрация метода для получений событий
	105	let subscription = pushEvents.on((msg) => {
	106	displayPopup(msg);
	107	});
	108
	109	// подписку можно отменить, после чего обработчики больше не будут вызываться
	110	subcription.destroy();
	111
	112	// если требуется получить только одно сообщение можно использовать
	113	// асинхронный метод next(ct?: ICancellation)
	114
	115	let msg = await pushEvents.next();
	116
	117	// пример метода для получения координат с карты, который использует
	118	// событие нажатия мышью для определения координат.
	119
	120	class Map {
	121	/**
	122
	123	Получает координаты по щелчку мыши.
	124
	125	@async
	126
	127	@returns [lon,lat]
	128
	129	*/
	130	async peekCoordinates(ct: ICancellation = Cancellation.none) {
	131	// получаем событие клика
	132	let evt = this.viewport.click.next(ct);
	133
	134	// преобразуем позицию на экране в координаты карты
	135	return this.clientToCoodinates([evt.clientx,evt.clientY]);
	136	}
	137	}
	138
	139
	140	let map : Map; // где-то объявлено
	141
	142	// пример получения координат с карты
	143	let coords = await map.peekCoordinates();
	144
	145	```
	146
	147	## Observable и последовательности
	148
	149	Можно сичтать, что `Observable` это некоторая аналогия итератора только в
	150	парадигме событийного (или реактивного) программировния. Следует также понимать,
	151	что при переходе от синхронного процедурного программирования к событийному так
	152	же меняется и направление управления (Inverse Of Control), что означает
	153	следующее:
	154
	155	* при работе с итераторами клиенты сами определяют момент чтения следующего
	156	элемента последовательности.
	157	* при работе с `Observable` клиенты вынуждены обрабатывать эти события по мере
	158	их поступления и не могут на это повлиять.
	159
	160	Последний пункт можно изменить применив, например, буффер или канал с
	161	состоянием, т.е. очередь, но данные механизмы выходят за рамки простого шаблона
	162	наблюдателя.
	163
	164	```ts
	165	// обработка в цикле не гарантирует получения всех сообщений
	166	while(1) {
	167	// ожидаем следующее событие, по сути это подписка только на одно событие
	168	let next = await events.next();
	169
	170	// такой цикл может пропускать сообщения, поскольку асинхронная операция
	171	// позволит возобновить создание новых событий, на которые мы не подписаны
	172	await processEvent(next);
	173
	174	// не только асинхронные операции могут привести к пропуску события
	175	// например вызов метода, который приводит к созданию события так же
	176	// приведет к тому, что созданное событие не будет обработано в текущем
	177	// цикле
	178	doSmthAndRiseEvent();
	179	}
	180
	181	// для получения всех сообщений нужно регистрировать подписчика
	182	events.on((data) => {
	183	// будет вызван для всех сообщений
	184	processEvent(data);
	185	});
	186	``` No newline at end of file

src/ts/Observable.ts created 644 +195 0

@@ -0,0 +1,195
	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	export 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	this._complete = true;
	180	}
	181
	182	protected _notifyCompleted() {
	183	let guard = (observer: IObserver<T>) => {
	184	try {
	185	observer.complete();
	186	} catch (e) {
	187	this.onObserverException(e);
	188	}
	189	}
	190
	191	this._notify(guard);
	192	this._observers = [];
	193	this._complete = true;
	194	}
	195	} No newline at end of file

test/ts/ObservableTests.ts created 644 +74 0

@@ -0,0 +1,74
	1	import { TraceSource, DebugLevel } from '@implab/core/log/TraceSource'
	2	import * as tape from 'tape';
	3	import { TapeWriter, delay } from './TestTraits';
	4	import { Observable } from '@implab/core/Observable';
	5	import { IObservable } from '@implab/core/interfaces';
	6
	7	let trace = TraceSource.get("ObservableTests");
	8
	9	tape('events sequence example', async t => {
	10
	11
	12	let events: IObservable<number>
	13
	14	let done = new Promise<void>((resolve) => {
	15	events = new Observable<number>(async (notify, fail, complete) => {
	16	for (let i = 0; i < 10; i++) {
	17	await delay(0);
	18	notify(i);
	19	}
	20	complete();
	21	resolve();
	22	});
	23	});
	24
	25	let count = 0;
	26	let complete = false;
	27	events.on(x => count = count + x, null, () => complete = true);
	28
	29	let first = await events.next();
	30
	31	t.equals(first, 0, "the first event");
	32	t.false(complete, "the sequence is not complete");
	33
	34	await done;
	35
	36	t.equals(count, 45, "the summ of the evetns");
	37	t.true(complete, "the sequence is complete");
	38
	39	t.end();
	40	});
	41
	42	tape('event sequence termination', async t => {
	43	let events: IObservable<number>
	44
	45	let done = new Promise<void>((resolve) => {
	46	events = new Observable<number>(async (notify, fail, complete) => {
	47	await delay(0);
	48	notify(1);
	49	complete();
	50	notify(2);
	51	complete();
	52	fail("Sequence terminated");
	53	resolve();
	54	});
	55	});
	56
	57	let count = 0;
	58	events.on(() => {}, (e) => count++, () => count++);
	59
	60	let first = await events.next();
	61	t.equals(first, 1, "the first message");
	62	try {
	63	await events.next();
	64	t.fail("shoud throw an exception");
	65	} catch(e) {
	66	t.pass("the sequence is terminated");
	67	}
	68
	69	await done;
	70
	71	t.equals(count, 1, "the sequence must be terminated once");
	72
	73	t.end();
	74	}); No newline at end of file

docs/en/cancellations.md ~~docs/cancellations.ru.md~~ renamed 0 0

NO CONTENT: file renamed from docs/cancellations.ru.md to docs/en/cancellations.md

docs/ru/cancellations.md docs/cancellations.ru.md copied 0 0

NO CONTENT: file copied from docs/cancellations.ru.md to docs/ru/cancellations.md

src/js/log/trace.js +3 -1

-            define(["./TraceSource"], function (TraceSource) {
+            define(["./TraceSource"], function (TraceSource_1) {
                 'use strict';
+                var TraceSource = TraceSource_1.TraceSource;
                 return {
                     on: function (filter, cb) {
                         if (arguments.length == 1) {
                             cb = filter;
                             filter = undefined;
                         }
                         var test;
                         if (filter instanceof RegExp) {
                             test = function (chId) {
                                 return filter.test(chId);
                             };
                         } else if (filter instanceof Function) {
                             test = filter;
                         } else if (filter) {
                             test = function (chId) {
                                 return chId == filter;
                             };
                         }
                         if (test) {
                             TraceSource.on(function (source) {
                                 if (test(source.id))
                                     source.on(cb);
                             });
                         } else {
                             TraceSource.on(function (source) {
                                 source.on(cb);
                             });
                         }
                     },
                     load: function (id, require, cb) {
                         if (id) {
                             cb(TraceSource.get(id));
                         } else if (require.module && require.module.mid) {
                             cb(TraceSource.get(require.module.mid));
                         } else {
                             require(['module'], function (module) {
                                 cb(TraceSource.get(module && module.id));
                             });
                         }
                     },
                     dynamic: true,
                 };
             });

src/ts/components/ActivatableMixin.ts +3 -7

             import { IActivationController, IActivatable, ICancellation } from '../interfaces';
             import { AsyncComponent } from './AsyncComponent';
             import { Cancellation } from '../Cancellation';
-            import * as TraceSource from '../log/TraceSource';
+            import { TraceSource } from '../log/TraceSource';
             type Constructor<T = {}> = new (...args: any[]) => T;
             const log = TraceSource.get('@implab/core/components/ActivatableMixin');
-            function ActivatableMixin<TBase extends Constructor<AsyncComponent>>(Base: TBase) {
+            export function ActivatableMixin<TBase extends Constructor<AsyncComponent>>(Base: TBase) {
                 return class extends Base implements IActivatable {
                     _controller: IActivationController;
                     _active: boolean;
                     isActive() {
                         return this._active;
                     }
                     getActivationController() {
                         return this._controller;
                     }
                     setActivationController(controller: IActivationController) {
                         this._controller = controller;
                     }
                     async onActivating(ct: ICancellation) {
                         if (this._controller)
                             await this._controller.activating(this, ct);
                     }
                     async onActivated(ct: ICancellation) {
                         if (this._controller)
                             await this._controller.activated(this, ct);
                     }
                     activate(ct: ICancellation = Cancellation.none) {
                         return this.runOperation(this._activateAsync.bind(this), ct);
                     }
                     async _activateAsync(ct: ICancellation) {
                         if (this.isActive())
                             return;
                         await this.onActivating(ct);
                         this._active = true;
                         try {
                             await this.onActivated(ct);
                         } catch (e) {
                             log.error("Suppressed onActivated error: {0}", e);
                         }
                     }
                     async onDeactivating(ct: ICancellation) {
                         if (this._controller)
                             await this._controller.deactivating(this, ct);
                     }
                     async onDeactivated(ct: ICancellation) {
                         if (this._controller)
                             await this._controller.deactivated(this, ct);
                     }
                     deactivate(ct: ICancellation = Cancellation.none) {
                         return this.runOperation(this._deactivateAsync.bind(this), ct);
                     }
                     async _deactivateAsync(ct: ICancellation) {
                         if (!this.isActive())
                             return;
                         await this.onDeactivating(ct);
                         this._active = false;
                         try {
                             await this.onDeactivated(ct);
                         } catch (e) {
                             log.error("Suppressed onDeactivated error: {0}", e);
                         }
                     }
                 }
             }
-            namespace ActivatableMixin {
+            export const traceSource = log;
  No newline at end of file
-                export const traceSource = log;
-            export = ActivatableMixin;
  No newline at end of file

src/ts/components/AsyncComponent.ts +27 -4

@@ -1,17 +1,40
1	import { Cancellation } from "../Cancellation";	1	import { Cancellation } from "../Cancellation";
2	import { IAsyncComponent, ICancellation } from "../interfaces";	2	import { IAsyncComponent, ICancellation, ICancellable, IDestroyable } from "../interfaces";
		3	import { destroy } from "../safe";
3		4
4	export class AsyncComponent implements IAsyncComponent {	5	export class AsyncComponent implements IAsyncComponent, ICancellable {
		6	_cancel: (e) => void;
		7
5	_completion: Promise<void> = Promise.resolve();	8	_completion: Promise<void> = Promise.resolve();
6		9
7	getCompletion() { return this._completion };	10	getCompletion() { return this._completion };
8		11
9	runOperation(op: (ct: ICancellation) => any, ct: ICancellation = Cancellation.none) {	12	runOperation(op: (ct: ICancellation) => any, ct: ICancellation = Cancellation.none) {
		13	// create inner cancellation bound to the passed cancellation token
		14	let h: IDestroyable;
		15	let inner = new Cancellation(cancel => {
		16
		17	this._cancel = cancel;
		18	h = ct.register(cancel);
		19	});
		20
10	// TODO create cancellation source here	21	// TODO create cancellation source here
11	async function guard() {	22	let guard = async () => {
12	~~awai~~t op(ct);	23	try {
		24	await op(inner);
		25	} finally {
		26	// after the operation is complete we need to cleanup the
		27	// resources
		28	destroy(h);
		29	this._cancel = null;
		30	}
13	}	31	}
14		32
15	return this._completion = guard();	33	return this._completion = guard();
16	}	34	}
		35
		36	cancel(reason) {
		37	if (this._cancel)
		38	this._cancel(reason);
		39	}
17	} No newline at end of file	40	}

src/ts/log/TraceSource.ts +46 -29

             import * as format from '../text/format'
             import { argumentNotNull } from '../safe';
-            import * as Observable from '../components/Observable'
+            import { Observable } from '../Observable'
             import { IDestroyable } from '../interfaces';
-            import * as TraceEvent from './TraceEvent'
+            export const DebugLevel = 400;
+            export const LogLevel = 300;
+            export const WarnLevel = 200;
+            export const ErrorLevel = 100;
+            export const SilentLevel = 0;
+            export class TraceEvent {
+                readonly source: TraceSource;
+                readonly level: Number;
+                readonly arg: any;
+                constructor(source: TraceSource, level: Number, arg: any) {
+                    this.source = source;
+                    this.level = level;
+                    this.arg = arg;
+                }
+            }
             class Registry {
                 static readonly instance = new Registry();
                 private _registry: object = new Object();
                 private _listeners: object = new Object();
                 private _nextCookie: number = 1;
                 get(id: any): TraceSource {
                     argumentNotNull(id, "id");
                     if (this._registry[id])
                         return this._registry[id];
                     var source = new TraceSource(id);
                     this._registry[id] = source;
                     this._onNewSource(source);
                     return source;
                 }
                 add(id: any, source: TraceSource) {
                     argumentNotNull(id, "id");
                     argumentNotNull(source, "source");
                     this._registry[id] = source;
                     this._onNewSource(source);
                 }
                 _onNewSource(source: TraceSource) {
                     for (let i in this._listeners)
                         this._listeners[i].call(null, source);
                 }
                 on(handler: (source: TraceSource) => void): IDestroyable {
                     argumentNotNull(handler, "handler");
                     var me = this;
                     var cookie = this._nextCookie++;
                     this._listeners[cookie] = handler;
                     for (let i in this._registry)
                         handler(this._registry[i]);
                     return {
                         destroy() {
                             delete me._listeners[cookie];
                         }
                     };
                 }
             }
-            class TraceSource extends Observable<TraceEvent> {
+            export class TraceSource {
                 readonly id: any
                 level: number
+                readonly events: Observable<TraceEvent>
+                _notifyNext: (arg: TraceEvent) => void
                 constructor(id: any) {
-                    super();
                     this.id = id || new Object();
+                    this.events = new Observable((next) => {
+                        this._notifyNext = next;
+                    })
                 }
                 protected emit(level: number, arg: any) {
                     this._notifyNext(new TraceEvent(this, level, arg));
                 }
                 isDebugEnabled() {
-                    return this.level >= TraceSource.DebugLevel;
+                    return this.level >= DebugLevel;
                 }
                 debug(msg: string, ...args: any[]) {
-                    if (this.isEnabled(TraceSource.DebugLevel))
+                    if (this.isEnabled(DebugLevel))
-                        this.emit(TraceSource.DebugLevel, format(msg, args));
+                        this.emit(DebugLevel, format(msg, args));
                 }
                 isLogEnabled() {
-                    return this.level >= TraceSource.LogLevel;
+                    return this.level >= LogLevel;
                 }
                 log(msg: string, ...args: any[]) {
-                    if (this.isEnabled(TraceSource.LogLevel))
+                    if (this.isEnabled(LogLevel))
-                        this.emit(TraceSource.LogLevel, format(msg, args));
+                        this.emit(LogLevel, format(msg, args));
                 }
                 isWarnEnabled() {
-                    return this.level >= TraceSource.WarnLevel;
+                    return this.level >= WarnLevel;
                 }
                 warn(msg: string, ...args: any[]) {
-                    if (this.isEnabled(TraceSource.WarnLevel))
+                    if (this.isEnabled(WarnLevel))
-                        this.emit(TraceSource.WarnLevel, format(msg, args));
+                        this.emit(WarnLevel, format(msg, args));
                 }
                 /**
                  * returns true if errors will be recorded.
                  */
                 isErrorEnabled() {
-                    return this.level >= TraceSource.ErrorLevel;
+                    return this.level >= ErrorLevel;
                 }
                 /**
                  * Traces a error.
                  *
                  * @param msg the message.
                  * @param args parameters which will be substituted in the message.
                  */
                 error(msg: string, ...args: any[]) {
-                    if (this.isEnabled(TraceSource.ErrorLevel))
+                    if (this.isEnabled(ErrorLevel))
-                        this.emit(TraceSource.ErrorLevel, format(msg, args));
+                        this.emit(ErrorLevel, format(msg, args));
                 }
                 /**
                  * Checks whether the specified level is enabled for this
                  * trace source.
                  *
                  * @param level the trace level which should be checked.
                  */
                 isEnabled(level: number) {
                     return (this.level >= level);
                 }
                 /**
                  * Traces a raw event, passing data as it is to the underlying listeners
                  *
                  * @param level the level of the event
                  * @param arg the data of the event, can be a simple string or any object.
                  */
                 traceEvent(level: number, arg: any) {
                     if (this.isEnabled(level))
                         this.emit(level, arg);
                 }
                 /**
                  * Register the specified handler to be called for every new and already
                  * created trace source.
                  *
                  * @param handler the handler which will be called for each trace source
                  */
                 static on(handler: (source: TraceSource) => void) {
                     return Registry.instance.on(handler);
                 }
                 /**
                  * Creates or returns already created trace source for the specified id.
                  *
                  * @param id the id for the trace source
                  */
                 static get(id: any) {
                     return Registry.instance.get(id);
                 }
             }
-            namespace TraceSource {
-                export const DebugLevel = 400;
-                export const LogLevel = 300;
-                export const WarnLevel = 200;
-                export const ErrorLevel = 100;
-                export const SilentLevel = 0;
-            export = TraceSource;
  No newline at end of file

src/ts/log/writers/ConsoleWriter.ts +5 -11

             import { IObservable, IDestroyable, ICancellation } from "../../interfaces";
-            import * as TraceEvent from '../TraceEvent';
             import { Cancellation } from "../../Cancellation";
-            import * as TraceSource from "../TraceSource";
+            import { TraceEvent, LogLevel, WarnLevel } from "../TraceSource";
-            class ConsoleWriter implements IDestroyable {
+            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));
                     if (ct.isSupported()) {
                         ct.register(subscription.destroy.bind(subscription));
                     }
                     this._subscriptions.push(subscription);
                 }
                 writeEvent(next: TraceEvent) {
-                    if (next.level >= TraceSource.LogLevel) {
+                    if (next.level >= LogLevel) {
                         console.log(next.source.id.toString(), next.arg);
-                    } else if(next.level >= TraceSource.WarnLevel) {
+                    } else if(next.level >= WarnLevel) {
                         console.warn(next.source.id.toString(), next.arg);
                     } else {
                         console.error(next.source.id.toString(), next.arg);
                     }
                 }
                 destroy() {
                     this._subscriptions.forEach(x => x.destroy());
                 }
+            }
  No newline at end of file
-            namespace ConsoleWriter {
-            export = ConsoleWriter;
  No newline at end of file

src/ts/safe.ts +5 0

             export function argumentNotNull(arg, name) {
                 if (arg === null || arg === undefined)
                     throw new Error("The argument " + name + " can't be null or undefined");
             }
             export function argumentNotEmptyString(arg, name) {
                 if (typeof (arg) !== "string" || !arg.length)
                     throw new Error("The argument '" + name + "' must be a not empty string");
             }
             export function argumentNotEmptyArray(arg, name) {
                 if (!(arg instanceof Array) || !arg.length)
                     throw new Error("The argument '" + name + "' must be a not empty array");
             }
             export function argumentOfType(arg, type, name) {
                 if (!(arg instanceof type))
                     throw new Error("The argument '" + name + "' type doesn't match");
             }
             export function isNull(arg) {
                 return (arg === null || arg === undefined);
             }
             export function isPrimitive(arg) {
                 return (arg === null || arg === undefined || typeof (arg) === "string" ||
                     typeof (arg) === "number" || typeof (arg) === "boolean");
             }
             export function isInteger(arg) {
                 return parseInt(arg) == arg;
             }
             export function isNumber(arg) {
                 return parseFloat(arg) == arg;
             }
             export function isString(val) {
                 return typeof (val) == "string" || val instanceof String;
             }
             export function isNullOrEmptyString(str) {
                 if (str === null || str === undefined ||
                     ((typeof (str) == "string" || str instanceof String) && str.length === 0))
                     return true;
             }
             export function isNotEmptyArray(arg) {
                 return (arg instanceof Array && arg.length > 0);
             }
             /**
              * Выполняет метод для каждого элемента массива, останавливается, когда
              * либо достигнут конец массива, либо функция <c>cb</c> вернула
              * значение.
              *
              * @param {Array | Object} obj массив элементов для просмотра
              * @param {Function} cb функция, вызываемая для каждого элемента
              * @param {Object} thisArg значение, которое будет передано в качестве
              *                <c>this</c> в <c>cb</c>.
              * @returns Результат вызова функции <c>cb</c>, либо <c>undefined</c>
              *          если достигнут конец массива.
              */
             export function each(obj, cb, thisArg) {
                 argumentNotNull(cb, "cb");
                 var i, x;
                 if (obj instanceof Array) {
                     for (i = 0; i < obj.length; i++) {
                         x = cb.call(thisArg, obj[i], i);
                         if (x !== undefined)
                             return x;
                     }
                 } else {
                     var keys = Object.keys(obj);
                     for (i = 0; i < keys.length; i++) {
                         var k = keys[i];
                         x = cb.call(thisArg, obj[k], k);
                         if (x !== undefined)
                             return x;
                     }
                 }
             }
             /** 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))
                     fn = thisArg[fn];
                 if (fn == null)
                     throw new Error("The function must be specified");
                 function wrapresult(x, e?) : PromiseLike<any> {
                     if (e) {
                         return {
                             then: function (cb, eb) {
                                 try {
                                     return eb ? wrapresult(eb(e)) : this;
                                 } catch (e2) {
                                     return wrapresult(null, e2);
                                 }
                             }
                         };
                     } else {
                         if (x && x.then)
                             return x;
                         return {
                             then: function (cb) {
                                 try {
                                     return cb ? wrapresult(cb(x)) : this;
                                 } catch (e2) {
                                     return wrapresult(e2);
                                 }
                             }
                         };
                     }
                 }
                 return function () {
                     try {
                         return wrapresult(fn.apply(thisArg, arguments));
                     } catch (e) {
                         return wrapresult(null, e);
                     }
                 };
             }
             export function delegate(target, _method: (string | Function)) {
                 let method : Function;
                 if (!(_method instanceof Function)) {
                     argumentNotNull(target, "target");
                     method = target[_method];
                 } else {
                     method = _method;
                 }
                 if (!(method instanceof Function))
                     throw new Error("'method' argument must be a Function or a method name");
                 return function () {
                     return method.apply(target, arguments);
                 };
             }
             /**
              * Для каждого элемента массива вызывает указанную функцию и сохраняет
              * возвращенное значение в массиве результатов.
              *
              * @remarks cb может выполняться асинхронно, при этом одновременно будет
              *          только одна операция.
              *
              * @async
              */
             export function pmap(items, cb) {
                 argumentNotNull(cb, "cb");
                 if (items && items.then instanceof Function)
                     return items.then(function (data) {
                         return pmap(data, cb);
                     });
                 if (isNull(items) || !items.length)
                     return items;
                 var i = 0,
                     result = [];
                 function next() {
                     var r, ri;
                     function chain(x) {
                         result[ri] = x;
                         return next();
                     }
                     while (i < items.length) {
                         r = cb(items[i], i);
                         ri = i;
                         i++;
                         if (r && r.then) {
                             return r.then(chain);
                         } else {
                             result[ri] = r;
                         }
                     }
                     return result;
                 }
                 return next();
             }
             /**
              * Выбирает первый элемент из последовательности, или обещания, если в
              * качестве параметра используется обещание, оно должно вернуть массив.
              *
              * @param {Function} cb обработчик результата, ему будет передан первый
              *                  элемент последовательности в случае успеха
              * @param {Function} err обработчик исключения, если массив пустой, либо
              *                  не массив
              *
              * @remarks Если не указаны ни cb ни err, тогда функция вернет либо
              *          обещание, либо первый элемент.
              * @async
              */
             export function first(sequence: any, cb: Function, err: Function) {
                 if (sequence) {
                     if (sequence.then instanceof Function) {
                         return sequence.then(function (res) {
                             return first(res, cb, err);
                         }, err);
                     } else if (sequence && "length" in sequence) {
                         if (sequence.length === 0) {
                             if (err)
                                 return err(new Error("The sequence is empty"));
                             else
                                 throw new Error("The sequence is empty");
                         }
                         return cb ? cb(sequence[0]) : sequence[0];
                     }
                 }
                 if (err)
                     return err(new Error("The sequence is required"));
                 else
                     throw new Error("The sequence is required");
+            }
+            export function destroy(d: any) {
+                if (d && 'destroy' in d)
+                    d.destroy();
             }

test/js/plan.js +3 -2

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

test/js/trace-test.js +2 -1

             define(["tape"], function(tape) {
                 "use strict";
                 var sourceId = '73a633f3-eab8-49b0-8601-07cae710f234';
                 var sourceId2 = '3ba9c7cd-ed77-437b-9a2f-1cbeb1226b5b';
                 tape('Load TraceSource for the module', function(t) {
-                    require(["core/log/trace!" + sourceId, "core/log/TraceSource"], function(trace, TraceSource) {
+                    require(["core/log/trace!" + sourceId, "core/log/TraceSource"], function(trace, TraceSource_1) {
+                        var TraceSource = TraceSource_1.TraceSource;
                         t.equal(trace && trace.id, sourceId, "trace should be taken from the loader plugin parameter");
                         var count = 0;
                         var h = TraceSource.on(function(x) {
                             if(x.id == sourceId || x.id == sourceId2)
                                 count++;
                         });
                         t.equal(count, 1, "should see created channel immediatelly");
                         t.equal(trace, TraceSource.get(sourceId), "should get same TraceSource from registry");
                         t.equal(count, 1);
                         TraceSource.get(sourceId2);
                         t.equal(count, 2);
                         h.destroy();
                         t.end();
                     });
                 });
             });

test/ts/ActivatableTests.ts +1 -1

             import * as tape from 'tape';
-            import * as ActivatableMixin from '@implab/core/components/ActivatableMixin';
+            import { ActivatableMixin} from '@implab/core/components/ActivatableMixin';
             import { AsyncComponent } from '@implab/core/components/AsyncComponent';
             import { IActivationController, IActivatable, ICancellation } from '@implab/core/interfaces';
             import { Cancellation } from '@implab/core/Cancellation';
             class SimpleActivatable extends ActivatableMixin(AsyncComponent) {
             }
             class MockActivationController implements IActivationController {
                 _active: IActivatable = null;
                 getActive() : IActivatable {
                     return this._active;
                 }
                 async deactivate() {
                     if (this._active)
                         await this._active.deactivate();
                     this._active = null;
                 }
                 async activate(component: IActivatable) {
                     if (!component || component.isActive())
                         return;
                     component.setActivationController(this);
                     await component.activate();
                 }
                 async activating(component: IActivatable, ct: ICancellation = Cancellation.none) {
                     if (component != this._active)
                         await this.deactivate();
                 }
                 async activated(component: IActivatable, ct: ICancellation = Cancellation.none) {
                     this._active = component;
                 }
                 async deactivating(component: IActivatable, ct: ICancellation = Cancellation.none) {
                 }
                 async deactivated(component: IActivatable, ct: ICancellation = Cancellation.none) {
                     if (this._active == component)
                         this._active = null;
                 }
             }
             tape('simple activation',async function(t){
                 let a = new SimpleActivatable();
                 t.false(a.isActive());
                 await a.activate();
                 t.true(a.isActive());
                 await a.deactivate();
                 t.false(a.isActive());
                 t.end();
             });
             tape('controller activation', async function(t) {
                 let a = new SimpleActivatable();
                 let c = new MockActivationController();
                 t.false(a.isActive(), "the component is not active by default");
                 t.assert(c.getActive() == null, "the activation controller doesn't have an active component by default");
                 t.assert(a.getActivationController() == null, "the component doesn't have an activation controller by default");
                 t.comment("Active the component through the controller");
                 await c.activate(a);
                 t.true(a.isActive(), "The component should successfully activate");
                 t.equal(c.getActive(), a, "The controller should point to the activated component");
                 t.equal(a.getActivationController(), c, "The component should point to the controller");
                 t.comment("Deactive the component throug the controller");
                 await c.deactivate();
                 t.false(a.isActive(), "The component should successfully deactivate");
                 t.equal(c.getActive(), null, "The controller shouldn't point to any component");
                 t.equal(a.getActivationController(), c, "The componet should point to it's controller");
                 t.end();
             });
             tape('handle error in onActivating', async function(t) {
                 let a = new SimpleActivatable();
                 a.onActivating = async function() {
                     throw "Should fail";
                 };
                 try {
                     await a.activate();
                     t.fail("activation should fail");
                 } catch {
                 }
                 t.false(a.isActive(), "the component should remain inactive");
                 t.end();
             });

test/ts/TestTraits.ts +6 -7

-            import { IObservable, ICancellation, IDestroyable } from "../../build/dist/interfaces";
+            import { IObservable, ICancellation, IDestroyable } from "@implab/core/interfaces";
-            import * as TraceEvent from '../../build/dist/log/TraceEvent';
+            import { Cancellation } from "@implab/core/Cancellation";
-            import { Cancellation } from "../../build/dist/Cancellation";
+            import { TraceEvent, LogLevel, WarnLevel } from "@implab/core/log/TraceSource";
-            import * as TraceSource from "../../build/dist/log/TraceSource";
             import * as tape from 'tape';
-            import { argumentNotNull } from "../../build/dist/safe";
+            import { argumentNotNull } from "@implab/core/safe";
             export class TapeWriter implements IDestroyable {
                 readonly _tape: tape.Test
                 _subscriptions = new Array<IDestroyable>();
                 constructor(tape: tape.Test) {
                     argumentNotNull(tape, "tape");
                     this._tape = tape;
                 }
                 writeEvents(source: IObservable<TraceEvent>, ct: ICancellation = Cancellation.none) {
                     let subscription = source.on(this.writeEvent.bind(this));
                     if (ct.isSupported()) {
                         ct.register(subscription.destroy.bind(subscription));
                     }
                     this._subscriptions.push(subscription);
                 }
                 writeEvent(next: TraceEvent) {
-                    if (next.level >= TraceSource.LogLevel) {
+                    if (next.level >= LogLevel) {
                         this._tape.comment("LOG " + next.arg);
-                    } else if (next.level >= TraceSource.WarnLevel) {
+                    } else if (next.level >= WarnLevel) {
                         this._tape.comment("WARN " + next.arg);
                     } else {
                         this._tape.comment("ERROR " + next.arg);
                     }
                 }
                 destroy() {
                     this._subscriptions.forEach(x => x.destroy());
                 }
             }
             export async function delay(timeout: number, ct: ICancellation = Cancellation.none) {
                 let un: IDestroyable;
                 try {
             	await new Promise((resolve, reject) => {
                         if (ct.isRequested()) {
             	        un = ct.register(reject);
                 	    } else {
                 		let ht = setTimeout(() => {
                 		    resolve();
                     	    }, timeout);
             	    	un = ct.register(e => {
                 	    	    clearTimeout(ht);
                 		    reject(e);
                 	        });
                 	    }
             	});
                 } finally {
             	if(un)
             	    un.destroy();
                 };
             }

test/ts/TraceSourceTests.ts +10 -10

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

src/ts/components/Observable.ts removed 0 -198

NO CONTENT: file was removed

src/ts/log/TraceEvent.ts removed 0 -21

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