implab/implabjs-core Commit - r9:c1c00bfb5487

Async operation cancellation proposal...

cin -

r9:c1c00bfb5487 propose cancellat...

parent child

Context file:

r9:c1c00bfb5487

Collapse all files

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

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

src/ts/EmptyCancellation.ts created 644 +20 0

@@ -0,0 +1,20
	1	import { ICancellation } from "./ICancellation";
	2
	3	export class EmptyCancellation implements ICancellation {
	4	isSupported(): boolean {
	5	return false;
	6	}
	7	throwIfRequested(): void {
	8	}
	9
	10	isRequested(): boolean {
	11	return false;
	12	}
	13
	14	register(_cb: () => void): void {
	15
	16	}
	17
	18	static readonly default : EmptyCancellation = new EmptyCancellation();
	19
	20	} No newline at end of file

src/ts/ICancellation.ts created 644 +6 0

@@ -0,0 +1,6
	1	export interface ICancellation {
	2	throwIfRequested(): void;
	3	isRequested(): boolean;
	4	isSupported(): boolean;
	5	register(cb: () => void): void;
	6	} No newline at end of file

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

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

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

@@ -0,0 +1,47
	1	import { ICancellation } from "../ICancellation";
	2	import { EmptyCancellation } from "../EmptyCancellation";
	3
	4	export class AsyncComponent {
	5	_completion: Promise<void>;
	6
	7	_deferred: {
	8	resolve(): void
	9	reject(reason: any): void
	10	};
	11
	12	getCompletion() { return this._completion };
	13
	14	startOperation(ct: ICancellation = EmptyCancellation.default) {
	15	if (this._deferred)
	16	throw new Error("The async operation is already pending");
	17
	18	this._completion = new Promise<void>((resolve, reject) => {
	19	this._deferred = {
	20	resolve: resolve,
	21	reject: reject
	22	}
	23	});
	24	return ct;
	25	}
	26
	27	completeSuccess() {
	28	this._deferred.resolve();
	29	this._deferred = null;
	30	}
	31
	32	completeFail(reason: any) {
	33	this._deferred.reject(reason);
	34	this._deferred = null;
	35	}
	36
	37	async runOperation(cb: (ct: ICancellation) => Promise<void>, ct: ICancellation = EmptyCancellation.default) {
	38	//safe.argumentNotNull(cb, "cb")
	39	ct = this.startOperation(ct);
	40	try {
	41	await cb(ct);
	42	this.completeSuccess();
	43	} catch(e) {
	44	this.completeFail(e);
	45	}
	46	}
	47	} No newline at end of file

src/ts/components/IActivatable.ts created 644 +39 0

@@ -0,0 +1,39
	1	import { IActivationController } from "./IActivationController";
	2	import { ICancellation } from "../ICancellation";
	3
	4	/**
	5	* Интерфейс поддерживающий асинхронную активацию
	6	*/
	7	export interface IActivatable {
	8	/**
	9	* @returns Boolean indicates the current state
	10	*/
	11	isActive(): boolean;
	12
	13	/**
	14	* Starts the component activation
	15	* @param ct cancellation token for this operation
	16	*/
	17	activate(ct?: ICancellation): Promise<void>;
	18
	19	/**
	20	* Starts the component deactivation
	21	* @param ct cancellation token for this operation
	22	*/
	23	deactivate(ct?: ICancellation): Promise<void>;
	24
	25	/**
	26	* Sets the activation controller for this component
	27	* @param controller The activation controller
	28	*
	29	* Activation controller checks whether this component
	30	* can be activated and manages the active state of the
	31	* component
	32	*/
	33	setActivationController(controller: IActivationController);
	34
	35	/**
	36	* Gets the current activation controller for this component
	37	*/
	38	getActivationController(): IActivationController;
	39	} No newline at end of file

src/ts/components/IActivationController.ts created 644 +19 0

@@ -0,0 +1,19
	1	import { IActivatable } from './IActivatable';
	2	import { ICancellation } from '../ICancellation';
	3	import { EmptyCancellation } from '../EmptyCancellation';
	4
	5	export interface IActivationController {
	6	activating(component: IActivatable, ct?: ICancellation): Promise<void>;
	7
	8	activated(component: IActivatable, ct?: ICancellation): Promise<void>;
	9
	10	deactivating(component: IActivatable, ct?: ICancellation): Promise<void>;
	11
	12	deactivated(component: IActivatable, ct?: ICancellation): Promise<void>;
	13
	14	deactivate(ct?: ICancellation): Promise<void>;
	15
	16	activate(component: IActivatable, ct?: ICancellation): Promise<void>;
	17
	18	getActive(): IActivatable;
	19	} No newline at end of file

src/ts/log/TraceEventArgs.ts created 644 +20 0

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

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

@@ -0,0 +1,116
	1	import * as TraceEventArgs from './TraceEventArgs'
	2	import * as format from '../text/format'
	3
	4	interface Handler {
	5	(arg: TraceEventArgs): void;
	6	}
	7
	8	interface Destroyable {
	9	destroy();
	10	}
	11
	12	class HandlerDescriptor implements Destroyable {
	13	private _target: TraceSource
	14
	15	readonly handler: Handler;
	16
	17	constructor(target: TraceSource, handler: Handler) {
	18	this._target = target;
	19	this.handler = handler;
	20	}
	21
	22	destroy() {
	23	this._target.remove(this);
	24	}
	25	}
	26
	27
	28	class TraceSource {
	29	readonly id: any
	30
	31	private _handlers: Array<HandlerDescriptor>
	32
	33	level: number
	34
	35	constructor(id: any) {
	36	this.id = id \|\| new Object();
	37	this._handlers = new Array<HandlerDescriptor>();
	38	}
	39
	40	on(handler: Handler): Destroyable {
	41	if (!handler)
	42	throw new Error("A handler must be specified");
	43
	44	let d = new HandlerDescriptor(this, handler)
	45
	46	this._handlers.push(d);
	47
	48	return d;
	49	}
	50
	51	remove(cookie: any): void {
	52	let i = this._handlers.indexOf(cookie);
	53	if (i >= 0)
	54	this._handlers.splice(i, 1);
	55	}
	56
	57	protected emit(level: number, msg: string, ...args: any[]) {
	58	if (level <= this.level) {
	59	let event = new TraceEventArgs(this, format(msg, args));
	60
	61	this._handlers.forEach(d => {
	62	try {
	63	d.handler.call(null, event);
	64	} catch {
	65	// suppress error in log handlers
	66	}
	67	});
	68	}
	69	}
	70
	71	isDebugEnabled() {
	72	return this.level >= TraceSource.DebugLevel;
	73	}
	74
	75	debug(msg: string, ...args: any[]): void {
	76	this.emit(TraceSource.DebugLevel, msg, args);
	77	}
	78
	79	isLogEnabled() {
	80	return this.level >= TraceSource.LogLevel;
	81	}
	82
	83	log(msg: string, ...args: any[]): void {
	84	this.emit(TraceSource.LogLevel, msg, args);
	85	}
	86
	87	isWarnEnabled() {
	88	return this.level >= TraceSource.WarnLevel;
	89	}
	90
	91	warn(msg: string, ...args: any[]): void {
	92	this.emit(TraceSource.WarnLevel, msg, args);
	93	}
	94
	95	isErrorEnabled() {
	96	return this.level >= TraceSource.ErrorLevel;
	97	}
	98
	99	error(msg: string, ...args: any[]): void {
	100	this.emit(TraceSource.ErrorLevel, msg, args);
	101	}
	102	}
	103
	104	namespace TraceSource {
	105	export const DebugLevel = 400;
	106
	107	export const LogLevel = 300;
	108
	109	export const WarnLevel = 200;
	110
	111	export const ErrorLevel = 100;
	112
	113	export const SilentLevel = 0;
	114	}
	115
	116	export = TraceSource; No newline at end of file

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

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

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

@@ -0,0 +1,110
	1	import * as tape from 'tape';
	2	import * as ActivatableMixin from '@implab/core/components/ActivatableMixin';
	3	import { AsyncComponent } from '@implab/core/components/AsyncComponent';
	4	import { IActivationController } from '@implab/core/components/IActivationController';
	5	import { IActivatable } from '@implab/core/components/IActivatable';
	6	import { ICancellation } from '@implab/core/ICancellation';
	7	import { EmptyCancellation } from '@implab/core/EmptyCancellation';
	8
	9	class SimpleActivatable extends ActivatableMixin(AsyncComponent) {
	10
	11	}
	12
	13	class MockActivationController implements IActivationController {
	14
	15	_active: IActivatable = null;
	16
	17
	18	getActive() : IActivatable {
	19	return this._active;
	20	}
	21
	22	async deactivate() {
	23	if (this._active)
	24	await this._active.deactivate();
	25	this._active = null;
	26	}
	27
	28	async activate(component: IActivatable) {
	29	if (!component \|\| component.isActive())
	30	return;
	31	component.setActivationController(this);
	32
	33	await component.activate();
	34	}
	35
	36	async activating(component: IActivatable, ct: ICancellation = EmptyCancellation.default) {
	37	if (component != this._active)
	38	await this.deactivate();
	39	}
	40
	41	async activated(component: IActivatable, ct: ICancellation = EmptyCancellation.default) {
	42	this._active = component;
	43	}
	44
	45	async deactivating(component: IActivatable, ct: ICancellation = EmptyCancellation.default) {
	46
	47	}
	48
	49	async deactivated(component: IActivatable, ct: ICancellation = EmptyCancellation.default) {
	50	if (this._active == component)
	51	this._active = null;
	52	}
	53	}
	54
	55	tape('simple activation',async function(t){
	56
	57	let a = new SimpleActivatable();
	58	t.false(a.isActive());
	59
	60	await a.activate();
	61	t.true(a.isActive());
	62
	63	await a.deactivate();
	64	t.false(a.isActive());
	65
	66	t.end();
	67	});
	68
	69	tape('controller activation', async function(t) {
	70
	71	let a = new SimpleActivatable();
	72	let c = new MockActivationController();
	73
	74	t.false(a.isActive(), "the component is not active by default");
	75	t.assert(c.getActive() == null, "the activation controller doesn't have an active component by default");
	76	t.assert(a.getActivationController() == null, "the component doesn't have an activation controller by default");
	77
	78	t.comment("Active the component through the controller");
	79	await c.activate(a);
	80	t.true(a.isActive(), "The component should successfully activate");
	81	t.assert(c.getActive() == a, "The controller should point to the activated component");
	82	t.assert(a.getActivationController() == c, "The component should point to the controller");
	83
	84	t.comment("Deactive the component throug the controller");
	85	await c.deactivate();
	86
	87	t.false(a.isActive(), "The component should successfully deactivate");
	88	t.assert(c.getActive() == null, "The controller shouldn't point to any component");
	89	t.assert(a.getActivationController() == c, "The componet should point to it's controller");
	90
	91	t.end();
	92	});
	93
	94	tape('handle error in onActivating', async function(t) {
	95	let a = new SimpleActivatable();
	96
	97	a.onActivating = async function() {
	98	throw "Should fail";
	99	};
	100
	101	try {
	102	await a.activate();
	103	t.fail("activation should fail");
	104	} catch {
	105	}
	106
	107	t.false(a.isActive(), "the component should remain inactive");
	108
	109	t.end();
	110	}); No newline at end of file

build.gradle +1 0

             println "version: $version"
             def distDir = "$buildDir/dist"
             def testDir = "$buildDir/test"
             task clean {
                 doLast {
                     delete buildDir
+                    delete 'node_modules/@implab'
                 }
             }
             task cleanNpm {
                 doLast {
                     delete 'node_modules'
                 }
             }
             task _npmInstall() {
                 inputs.file("package.json")
                 outputs.dir("node_modules")
                 doLast {
                     exec {
                         commandLine 'npm', 'install'
                     }
                 }
             }
             task _legacyJs(type:Copy) {
                 from 'src/js/'
                 into distDir
             }
             task _buildTs(dependsOn: _npmInstall, type:Exec) {
                 inputs.dir('src/ts')
                 inputs.file('tsc.json')
                 outputs.dir(distDir)
                 commandLine 'node_modules/.bin/tsc', '-p', 'tsc.json'
             }
             task _packageMeta(type: Copy) {
                 inputs.property("version", version)
                 from('.') {
                     include 'package.json', 'readme.md', 'license', 'history.md'
                 }
                 into distDir
                 doLast {
                     exec {
                         workingDir distDir
                         commandLine 'npm', 'version', version
                     }
                 }
             }
             task build(dependsOn: [_npmInstall, _buildTs, _legacyJs, _packageMeta]) {
             }
             task _localInstall(dependsOn: build, type: Exec) {
                 inputs.file("$distDir/package.json")
                 outputs.upToDateWhen {
                     new File("$projectDir/node_modules/@implab/core").exists()
                 }
                 commandLine 'npm', 'install', '--no-save', '--force', distDir
             }
             task copyJsTests(type: Copy) {
                 from 'test/js'
                 into testDir
             }
             task buildTests(dependsOn: _localInstall, type: Exec) {
                 inputs.dir('test/ts')
                 inputs.file('tsc.test.json')
                 outputs.dir(testDir)
                 commandLine 'node_modules/.bin/tsc', '-p', 'tsc.test.json'
             }
             task test(dependsOn: [copyJsTests, buildTests], type: Exec) {
                 commandLine 'node', 'run-amd-tests.js'
             }
             task pack(dependsOn: build, type: Exec) {
                 workingDir = distDir
                 commandLine 'npm', 'pack'
             }

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

             define([
                 "../declare",
                 "../safe",
                 "../Uuid",
                 "../Deferred",
                 "./ActivationContext",
                 "./Descriptor",
                 "./ValueDescriptor",
                 "./ReferenceDescriptor",
                 "./ServiceDescriptor",
                 "./ActivationError"
             ], function (
                 declare,
                 safe,
                 Uuid,
                 Deferred,
                 ActivationContext,
                 Descriptor,
                 Value,
                 Reference,
                 Service,
                 ActivationError) {
                 var Container = declare(null, {
                     _services: null,
                     _cache: null,
                     _cleanup: null,
                     _root: null,
                     _parent: null,
                     constructor: function (parent) {
                         this._parent = parent;
                         this._services = parent ? Object.create(parent._services) : {};
                         this._cache = {};
                         this._cleanup = [];
                         this._root = parent ? parent.getRootContainer() : this;
                         this._services.container = new Value(this, true);
                     },
                     getRootContainer: function () {
                         return this._root;
                     },
                     getParent: function () {
                         return this._parent;
                     },
                     /**
                      *
                      */
                     getService: function (name, def) {
                         var d = this._services[name];
                         if (!d)
                             if (arguments.length > 1)
                                 return def;
                             else
                                 throw new Error("Service '" + name + "' isn't found");
                         if (d.isInstanceCreated())
                             return d.getInstance();
                         var context = new ActivationContext(this, this._services);
                         try {
                             return d.activate(context, name);
                         } catch (error) {
                             throw new ActivationError(name, context.getStack(), error);
                         }
                     },
                     register: function (name, service) {
                         if (arguments.length == 1) {
                             var data = name;
                             for (name in data)
                                 this.register(name, data[name]);
                         } else {
                             if (!(service instanceof Descriptor))
                                 service = new Value(service, true);
                             this._services[name] = service;
                         }
                         return this;
                     },
                     onDispose: function (callback) {
                         if (!(callback instanceof Function))
                             throw new Error("The callback must be a function");
                         this._cleanup.push(callback);
                     },
                     dispose: function () {
                         if (this._cleanup) {
                             for (var i = 0; i < this._cleanup.length; i++)
                                 this._cleanup[i].call(null);
                             this._cleanup = null;
                         }
                     },
                     /**
                      * @param{String|Object} config
                      *  The configuration of the contaier. Can be either a string or an object,
                      *  if the configuration is an object it's treated as a collection of
                      *  services which will be registed in the contaier.
                      *
                      * @param{Function} opts.contextRequire
                      *  The function which will be used to load a configuration or types for services.
                      *
                      */
                     configure: function (config, opts) {
                         var p, me = this,
                             contextRequire = (opts && opts.contextRequire);
                         if (typeof (config) === "string") {
                             p = new Deferred();
                             if (!contextRequire) {
-                                var shim = [config, new Uuid()].join(config.indexOf("/") != -1 ? "-" : "/");
+                                var shim = [config, Uuid()].join(config.indexOf("/") != -1 ? "-" : "/");
                                 define(shim, ["require", config], function (ctx, data) {
                                     p.resolve([data, {
                                         contextRequire: ctx
                                     }]);
                                 });
                                 require([shim]);
                             } else {
                                 // TODO how to get correct contextRequire for the relative config module?
                                 contextRequire([config], function (data) {
                                     p.resolve([data, {
                                         contextRequire: contextRequire
                                     }]);
                                 });
                             }
                             return p.then(function (args) {
                                 return me._configure.apply(me, args);
                             });
                         } else {
                             return me._configure(config, opts);
                         }
                     },
                     createChildContainer: function () {
                         return new Container(this);
                     },
                     has: function (id) {
                         return id in this._cache;
                     },
                     get: function (id) {
                         return this._cache[id];
                     },
                     store: function (id, value) {
                         return (this._cache[id] = value);
                     },
                     _configure: function (data, opts) {
                         var typemap = {},
                             d = new Deferred(),
                             me = this,
                             p,
                             contextRequire = (opts && opts.contextRequire) || require;
                         var services = {};
                         for (p in data) {
                             var service = me._parse(data[p], typemap);
                             if (!(service instanceof Descriptor))
                                 service = new Value(service, false);
                             services[p] = service;
                         }
                         me.register(services);
                         var names = [];
                         for (p in typemap)
                             names.push(p);
                         if (names.length) {
                             contextRequire(names, function () {
                                 for (var i = 0; i < names.length; i++)
                                     typemap[names[i]] = arguments[i];
                                 d.resolve(me);
                             });
                         } else {
                             d.resolve(me);
                         }
                         return d.promise;
                     },
                     _parse: function (data, typemap) {
                         if (safe.isPrimitive(data) || data instanceof Descriptor)
                             return data;
                         if (data.$dependency)
                             return new Reference(
                                 data.$dependency,
                                 data.lazy,
                                 data.optional,
                                 data["default"],
                                 data.services && this._parseObject(data.services, typemap));
                         if (data.$value) {
                             var raw = !data.parse;
                             return new Value(raw ? data.$value : this._parse(
                                 data.$value,
                                 typemap), raw);
                         }
                         if (data.$type || data.$factory)
                             return this._parseService(data, typemap);
                         if (data instanceof Array)
                             return this._parseArray(data, typemap);
                         return this._parseObject(data, typemap);
                     },
                     _parseService: function (data, typemap) {
                         var me = this,
                             opts = {
                                 owner: this
                             };
                         if (data.$type) {
                             opts.type = data.$type;
                             if (typeof (data.$type) === "string") {
                                 typemap[data.$type] = null;
                                 opts.typeMap = typemap;
                             }
                         }
                         if (data.$factory)
                             opts.factory = data.$factory;
                         if (data.services)
                             opts.services = me._parseObject(data.services, typemap);
                         if (data.inject)
                             opts.inject = data.inject instanceof Array ? data.inject.map(function (x) {
                                 return me._parseObject(x, typemap);
                             }) : me._parseObject(data.inject, typemap);
                         if (data.params)
                             opts.params = me._parse(data.params, typemap);
                         if (data.activation) {
                             if (typeof (data.activation) === "string") {
                                 switch (data.activation.toLowerCase()) {
                                     case "singleton":
                                         opts.activation = Service.SINGLETON;
                                         break;
                                     case "container":
                                         opts.activation = Service.CONTAINER;
                                         break;
                                     case "hierarchy":
                                         opts.activation = Service.HIERARCHY;
                                         break;
                                     case "context":
                                         opts.activation = Service.CONTEXT;
                                         break;
                                     case "call":
                                         opts.activation = Service.CALL;
                                         break;
                                     default:
                                         throw new Error("Unknown activation type: " +
                                             data.activation);
                                 }
                             } else {
                                 opts.activation = Number(data.activation);
                             }
                         }
                         if (data.cleanup)
                             opts.cleanup = data.cleanup;
                         return new Service(opts);
                     },
                     _parseObject: function (data, typemap) {
                         if (data.constructor &&
                             data.constructor.prototype !== Object.prototype)
                             return new Value(data, true);
                         var o = {};
                         for (var p in data)
                             o[p] = this._parse(data[p], typemap);
                         return o;
                     },
                     _parseArray: function (data, typemap) {
                         if (data.constructor &&
                             data.constructor.prototype !== Array.prototype)
                             return new Value(data, true);
                         var me = this;
                         return data.map(function (x) {
                             return me._parse(x, typemap);
                         });
                     }
                 });
                 return Container;
             });

src/js/safe.js +7 -5

             define([],
                 function () {
                     var _create = Object.create,
                         _keys = Object.keys;
                     var safe = null;
                     safe = {
                         argumentNotNull: function (arg, name) {
                             if (arg === null || arg === undefined)
                                 throw new Error("The argument " + name + " can't be null or undefined");
                         },
                         argumentNotEmptyString: function (arg, name) {
                             if (typeof (arg) !== "string" || !arg.length)
                                 throw new Error("The argument '" + name + "' must be a not empty string");
                         },
                         argumentNotEmptyArray: function (arg, name) {
                             if (!(arg instanceof Array) || !arg.length)
                                 throw new Error("The argument '" + name + "' must be a not empty array");
                         },
                         argumentOfType: function (arg, type, name) {
                             if (!(arg instanceof type))
                                 throw new Error("The argument '" + name + "' type doesn't match");
                         },
                         isNull: function (arg) {
                             return (arg === null || arg === undefined);
                         },
                         isPrimitive: function (arg) {
                             return (arg === null || arg === undefined || typeof (arg) === "string" ||
                                 typeof (arg) === "number" || typeof (arg) === "boolean");
                         },
                         isInteger: function (arg) {
                             return parseInt(arg) == arg;
                         },
                         isNumber: function (arg) {
                             return parseFloat(arg) == arg;
                         },
                         isString: function (val) {
                             return typeof (val) == "string" || val instanceof String;
                         },
                         isNullOrEmptyString: function (str) {
                             if (str === null || str === undefined ||
                                 ((typeof (str) == "string" || str instanceof String) && str.length === 0))
                                 return true;
                         },
                         isNotEmptyArray: function (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>
                          *          если достигнут конец массива.
                          */
                         each: function (obj, cb, thisArg) {
                             safe.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 = _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;
                                 }
                             }
                         },
                         /**
                          * Копирует свойства одного объекта в другой.
                          *
                          * @param{Any} dest объект в который нужно скопировать значения
                          * @param{Any} src источник из которого будут копироваться значения
                          * @tmpl{Object|Array} tmpl шаблон по которому будет происходить
                          *                     копирование. Если шаблон является массивом
                          *                     (список свойств), тогда значения этого массива
                          *                     являются именами свойсвт которые будут
                          *                     скопированы. Если шаблон является объектом (карта
                          *                     преобразования имен свойств src->dst), тогда
                          *                     копирование будет осуществляться только
                          *                     собственных свойств источника, присутсвующих в
                          *                     шаблоне, при этом значение свойства шаблона
                          *                     является именем свойства в которое будет
                          *                     произведено коприрование
                          */
                         mixin: function (dest, src, tmpl) {
                             safe.argumentNotNull(dest, "dest");
                             if (!src)
                                 return dest;
                             var keys, i, p;
                             if (arguments.length < 3) {
                                 keys = _keys(src);
                                 for (i = 0; i < keys.length; i++) {
                                     p = keys[i];
                                     dest[p] = src[p];
                                 }
                             } else {
                                 if (tmpl instanceof Array) {
                                     for (i = 0; i < tmpl.length; i++) {
                                         p = tmpl[i];
                                         if (p in src)
                                             dest[p] = src[p];
                                     }
                                 } else {
                                     keys = _keys(src);
                                     for (i = 0; i < keys.length; i++) {
                                         p = keys[i];
                                         if (p in tmpl)
                                             dest[tmpl[p]] = src[p];
                                     }
                                 }
                             }
                             return dest;
                         },
                         /** 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.
                          */
                         async: function (fn, thisArg) {
                             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) {
                                 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);
                                             }
                                         }
                                     };
                                 }
                             }
-                            try {
+                            return function() {
-                                return wrapresult(fn.apply(thisArg, arguments));
+                                try {
-                            } catch (e) {
+                                    return wrapresult(fn.apply(thisArg, arguments));
-                                return wrapresult(null, e);
+                                } catch (e) {
+                                    return wrapresult(null, e);
+                                }
+                            };
                         },
                         create: function () {
                             if (console && console.warn)
                                 console.warn("implab/safe::create is deprecated use Object.create instead");
                             _create.apply(this, arguments);
                         },
                         delegate: function (target, method) {
                             if (!(method instanceof Function)) {
                                 this.argumentNotNull(target, "target");
                                 method = target[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
                          */
                         pmap: function (items, cb) {
                             safe.argumentNotNull(cb, "cb");
                             if (items && items.then instanceof Function)
                                 return items.then(function (data) {
                                     return safe.pmap(data, cb);
                                 });
                             if (safe.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();
                         },
                         /**
                          * Для каждого элемента массива вызывает указанную функцию, результаты
                          * не сохраняются
                          *
                          * @remarks cb может выполняться асинхронно, при этом одновременно будет
                          *          только одна операция.
                          * @async
                          */
                         pfor: function (items, cb) {
                             safe.argumentNotNull(cb, "cb");
                             if (items && items.then instanceof Function)
                                 return items.then(function (data) {
                                     return safe.pmap(data, cb);
                                 });
                             if (safe.isNull(items) || !items.length)
                                 return items;
                             var i = 0;
                             function next() {
                                 while (i < items.length) {
                                     var r = cb(items[i], i);
                                     i++;
                                     if (r && r.then)
                                         return r.then(next);
                                 }
                             }
                             return next();
                         },
                         /**
                          * Выбирает первый элемент из последовательности, или обещания, если в
                          * качестве параметра используется обещание, оно должно вернуть массив.
                          *
                          * @param{Function} cb обработчик результата, ему будет передан первый
                          *                  элемент последовательности в случае успеха
                          * @param{Fucntion} err обработчик исключения, если массив пустой, либо
                          *                  не массив
                          *
                          * @remarks Если не указаны ни cb ни err, тогда функция вернет либо
                          *          обещание, либо первый элемент.
                          * @async
                          */
                         first: function (sequence, cb, err) {
                             if (sequence) {
                                 if (sequence.then instanceof Function) {
                                     return sequence.then(function (res) {
                                         return safe.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");
                         }
                     };
                     return safe;
                 });

src/ts/Uuid.ts +2 0

             // Typescript port of the uuid.js
             //  Copyright (c) 2018 Sergey Smirnov
             //  BSD-2-Clause License https://opensource.org/licenses/BSD-2-Clause
             //
             // uuid.js
             //     Copyright (c) 2010-2012 Robert Kieffer
             //     MIT License - http://opensource.org/licenses/mit-license.php
+            declare var window: any;
             let _window : any = 'undefined' !== typeof window ? window : null;
             // Unique ID creation requires a high quality random # generator. We
             // feature
             // detect to determine the best RNG source, normalizing to a function
             // that
             // returns 128-bits of randomness, since that's what's usually required
             let _rng;
             function setupBrowser() {
                 // Allow for MSIE11 msCrypto
                 let _crypto = _window.crypto || _window.msCrypto;
                 if (!_rng && _crypto && _crypto.getRandomValues) {
                     // WHATWG crypto-based RNG - http://wiki.whatwg.org/wiki/Crypto
                     //
                     // Moderately fast, high quality
                     try {
                         let _rnds8 = new Uint8Array(16);
                         _rng = function whatwgRNG() {
                             _crypto.getRandomValues(_rnds8);
                             return _rnds8;
                         };
                         _rng();
                     } catch (e) { /**/ }
                 }
                 if (!_rng) {
                     // Math.random()-based (RNG)
                     //
                     // If all else fails, use Math.random(). It's fast, but is of
                     // unspecified
                     // quality.
                     let  _rnds = new Array(16);
                     _rng = function () {
                         for (var i = 0, r; i < 16; i++) {
                             if ((i & 0x03) === 0) {
                                 r = Math.random() * 0x100000000;
                             }
                             _rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;
                         }
                         return _rnds;
                     };
                     if ('undefined' !== typeof console && console.warn) {
                         console.warn("[SECURITY] node-uuid: crypto not usable, falling back to insecure Math.random()");
                     }
                 }
             }
             function setupNode() {
                 // Node.js crypto-based RNG -
                 // http://nodejs.org/docs/v0.6.2/api/crypto.html
                 //
                 // Moderately fast, high quality
                 if ('function' === typeof require) {
                     try {
                         let _rb = require('crypto').randomBytes;
                         _rng = _rb && function () {
                             return _rb(16);
                         };
                         _rng();
                     } catch (e) { /**/ }
                 }
             }
             if (_window) {
                 setupBrowser();
             } else {
                 setupNode();
             }
             // Buffer class to use
             let BufferClass = ('function' === typeof Buffer) ? Buffer : Array;
             // Maps for number <-> hex string conversion
             let _byteToHex = [];
             let _hexToByte = {};
             for (let i = 0; i < 256; i++) {
                 _byteToHex[i] = (i + 0x100).toString(16).substr(1);
                 _hexToByte[_byteToHex[i]] = i;
             }
             // **`parse()` - Parse a UUID into it's component bytes**
             function parse(s, buf?, offset?) : Array<string> {
                 let i = (buf && offset) || 0,        ii = 0;
                 buf = buf || [];
                 s.toLowerCase().replace(/[0-9a-f]{2}/g, function (oct) {
                     if (ii < 16) { // Don't overflow!
                         buf[i + ii++] = _hexToByte[oct];
                     }
                 });
                 // Zero out remaining bytes if string was short
                 while (ii < 16) {
                     buf[i + ii++] = 0;
                 }
                 return buf;
             }
             // **`unparse()` - Convert UUID byte array (ala parse()) into a string**
             function unparse(buf, offset?) : string {
                 let i = offset || 0,        bth = _byteToHex;
                 return bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]] +
                     bth[buf[i++]] + '-' + bth[buf[i++]] + bth[buf[i++]] + '-' +
                     bth[buf[i++]] + bth[buf[i++]] + '-' + bth[buf[i++]] +
                     bth[buf[i++]] + '-' + bth[buf[i++]] + bth[buf[i++]] +
                     bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]];
             }
             // **`v1()` - Generate time-based UUID**
             //
             // Inspired by https://github.com/LiosK/UUID.js
             // and http://docs.python.org/library/uuid.html
             // random #'s we need to init node and clockseq
             let _seedBytes = _rng();
             // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit =
             // 1)
             let _nodeId = [
                 _seedBytes[0] | 0x01,
                 _seedBytes[1],
                 _seedBytes[2],
                 _seedBytes[3],
                 _seedBytes[4],
                 _seedBytes[5]
             ];
             // Per 4.2.2, randomize (14 bit) clockseq
             let _clockseq = (_seedBytes[6] << 8 | _seedBytes[7]) & 0x3fff;
             // Previous uuid creation time
             let _lastMSecs = 0,    _lastNSecs = 0;
             // See https://github.com/broofa/node-uuid for API details
             function v1(options?, buf?, offset?) : string {
                 let i = buf && offset || 0;
                 let b = buf || [];
                 options = options || {};
                 let clockseq = (options.clockseq != null) ? options.clockseq : _clockseq;
                 // UUID timestamps are 100 nano-second units since the Gregorian
                 // epoch,
                 // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so
                 // time is handled internally as 'msecs' (integer milliseconds) and
                 // 'nsecs'
                 // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01
                 // 00:00.
                 let msecs = (options.msecs != null) ? options.msecs : new Date()
                     .getTime();
                 // Per 4.2.1.2, use count of uuid's generated during the current
                 // clock
                 // cycle to simulate higher resolution clock
                 let nsecs = (options.nsecs != null) ? options.nsecs : _lastNSecs + 1;
                 // Time since last uuid creation (in msecs)
                 let dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs) / 10000;
                 // Per 4.2.1.2, Bump clockseq on clock regression
                 if (dt < 0 && options.clockseq == null) {
                     clockseq = clockseq + 1 & 0x3fff;
                 }
                 // Reset nsecs if clock regresses (new clockseq) or we've moved onto
                 // a new
                 // time interval
                 if ((dt < 0 || msecs > _lastMSecs) && options.nsecs == null) {
                     nsecs = 0;
                 }
                 // Per 4.2.1.2 Throw error if too many uuids are requested
                 if (nsecs >= 10000) {
                     throw new Error(
                         'uuid.v1(): Can\'t create more than 10M uuids/sec');
                 }
                 _lastMSecs = msecs;
                 _lastNSecs = nsecs;
                 _clockseq = clockseq;
                 // Per 4.1.4 - Convert from unix epoch to Gregorian epoch
                 msecs += 12219292800000;
                 // `time_low`
                 let tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
                 b[i++] = tl >>> 24 & 0xff;
                 b[i++] = tl >>> 16 & 0xff;
                 b[i++] = tl >>> 8 & 0xff;
                 b[i++] = tl & 0xff;
                 // `time_mid`
                 let tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;
                 b[i++] = tmh >>> 8 & 0xff;
                 b[i++] = tmh & 0xff;
                 // `time_high_and_version`
                 b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
                 b[i++] = tmh >>> 16 & 0xff;
                 // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
                 b[i++] = clockseq >>> 8 | 0x80;
                 // `clock_seq_low`
                 b[i++] = clockseq & 0xff;
                 // `node`
                 let node = options.node || _nodeId;
                 for (let n = 0; n < 6; n++) {
                     b[i + n] = node[n];
                 }
                 return buf ? buf : unparse(b);
             }
             // **`v4()` - Generate random UUID**
             // See https://github.com/broofa/node-uuid for API details
             function v4(options?, buf?, offset?) : string {
                 // Deprecated - 'format' argument, as supported in v1.2
                 let i = buf && offset || 0;
                 if (typeof (options) === 'string') {
                     buf = (options === 'binary') ? new BufferClass(16) : null;
                     options = null;
                 }
                 options = options || {};
                 let rnds = options.random || (options.rng || _rng)();
                 // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
                 rnds[6] = (rnds[6] & 0x0f) | 0x40;
                 rnds[8] = (rnds[8] & 0x3f) | 0x80;
                 // Copy bytes to buffer, if provided
                 if (buf) {
                     for (let ii = 0; ii < 16; ii++) {
                         buf[i + ii] = rnds[ii];
                     }
                 }
                 return buf || unparse(rnds);
             }
             // Export public API
             const empty = "00000000-0000-0000-0000-000000000000";
             interface uuid {
                 (options?, buf?, offset?) : string;
                 v1(options?, buf?, offset?) : string;
                 v4(options?, buf?, offset?) : string;
                 readonly empty: string;
                 parse(s, buf?, offset?) : Array<string>;
                 unparse(buf, offset?) : string;
             }
             export = <uuid>(() =>{
                 var f : any = function(options?, buf?, offset?) : string {
                     return v4(options, buf, offset);
                 };
                 f.v1 = v1;
                 f.v4 = v4;
                 f.empty = empty;
                 f.parse = parse;
                 f.unparse = unparse;
                 return f;
             })();

test/js/plan.js +1 -1

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

tsc.json +4 -1

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

tsc.test.json +4 -1

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

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

NO CONTENT: file was removed

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

NO CONTENT: file was removed

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