implab/implabjs-core Commit - r22:93dca6f27f52

Code cleanup,...

cin -

r22:93dca6f27f52 propose observables

parent child

Context file:

r22:93dca6f27f52

Collapse all files

docs/ActivatableMixin/observable.ru.md created 644 +55 0

@@ -0,0 +1,55
	1	# Observable
	2
	3	Универсальный способ организации потока сообщений. Данный механизм может
	4	использоваться для оповещения об изменениях состояний объектов или для доставки
	5	самостоятельных событий, например, связанных с действиями пользователя.
	6
	7	Является реализацией классического наблюдателя с возможность сообщить о коце
	8	потока событий. Данная реализация не содержит никаких дополнительных функций,
	9	таких как фильтрация, канал с состоянием, преобразования сообщений и т.п. Это
	10	сделано специально, чтобы реализация оставалась максимально простой.
	11
	12	Пример того, как можно создать последовательность из 10 событий:
	13
	14	```ts
	15
	16	var events = new Observable(async (notify, error, complete) => {
	17	// цикл в котором возникает событие
	18	for(let i = 0; i < 10; i++) {
	19	await delay(1000);
	20	// в качестве данных передается номер события
	21	notify(i);
	22	}
	23	// по окончании последовательности информируем, что событий больше не будет
	24	compelte();
	25	});
	26
	27	// создаем окно с отображением хода событий
	28	var progress = showProgress({ min: 0, max: 9, current: 0});
	29
	30	// подписываемся на события
	31	events.on(
	32	// обработчик очередного события
	33	msg => {
	34	progress.setValue(msg);
	35	}.
	36	// обработчик ошибки
	37	e => {
	38	progress.showError(e);
	39	},
	40	// обработчик конца потока
	41	() => {
	42	progress.close();
	43	}
	44	);
	45
	46	```
	47
	48	```ts
	49
	50	// превращаем события dom в Observable
	51	var events = new Observable((notify) => {
	52	on(domNode,'mousemove', notify);
	53	});
	54
	55	``` No newline at end of file

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/components/Observable.ts +2 -7

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

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 '../components/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/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/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