implab/implabjs-core Commit - r34:bf1098a8d031

ported IoC container to typescript...

cin -

r34:bf1098a8d031 di-typescript

parent child

Context file:

r34:bf1098a8d031

Expand all files

src/ts/di/ActivationError.ts created 644 +37 0

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

src/ts/di/AggregateDescriptor.ts created 644 +24 0

@@ -0,0 +1,24
	1	import { Descriptor } from "./interfaces";
	2	import { ActivationContext } from "./ActivationContext";
	3
	4	export class AggregateDescriptor<T> implements Descriptor {
	5	_value: T
	6
	7	constructor(value: T) {
	8
	9	}
	10
	11	activate(context: ActivationContext, name: string) {
	12	context.enter(name);
	13	let v = context.parse(this._value, ".params");
	14	context.leave();
	15	return v;
	16	}
	17
	18	isInstanceCreated(): boolean {
	19	return false;
	20	}
	21	getInstance(): T {
	22	throw new Error("Not supported exception");
	23	}
	24	}

src/ts/di/ModuleResolverBase.ts created 644 +17 0

@@ -0,0 +1,17
	1	import { argumentNotEmptyString, get } from "../safe";
	2
	3	export abstract class ModuleResolverBase {
	4
	5
	6	async resolve(typeName: string) {
	7	argumentNotEmptyString(typeName, "typeName");
	8	let [moduleName, localName] = typeName.split("#", 2);
	9
	10	let moduleObject = await this.loadModule(moduleName);
	11	return localName ? get(localName, moduleObject) : moduleObject;
	12	}
	13
	14	abstract loadModule(moduleName: string): PromiseLike<Object>
	15
	16	abstract createResolver(moduleName: string): PromiseLike<ModuleResolverBase>
	17	} No newline at end of file

src/ts/di/RequireJsResolver.ts created 644 +75 0

@@ -0,0 +1,75
	1	import { ModuleResolverBase } from "./ModuleResolverBase";
	2	import { Uuid } from "../Uuid";
	3	import { argumentNotEmptyString } from "../safe";
	4	import { TraceSource } from "../log/TraceSource";
	5
	6	declare function require(modules: string[], cb?: (...args: any[]) => any): void;
	7
	8	declare function define(name: string, modules: string[], cb?: (...args: any[]) => any): void;
	9
	10	class RequireJsResolverParams {
	11	contextRequire: (modules: string[], cb?: (...args: any[]) => any) => void
	12
	13	base: string
	14	}
	15
	16	TraceSource.get("RequireJsResolver");
	17
	18	export class RequireJsResolver extends ModuleResolverBase {
	19	_contextRequire = require
	20
	21	_base: string
	22
	23	constructor(opts) {
	24	super();
	25
	26	if (opts) {
	27
	28	if (opts.contextRequire)
	29	this._contextRequire = opts.contextRequire;
	30
	31	if (opts.base) {
	32	if (opts.base.indexOf("./") == 0)
	33	throw new Error(`A module id should be an absolute: '${opts.base}'`);
	34	this._base = opts.base;
	35	}
	36	}
	37
	38	}
	39
	40	async createResolver(moduleName: string): Promise<ModuleResolverBase> {
	41	argumentNotEmptyString(moduleName, "moduleName");
	42
	43	let parts = moduleName.split("/");
	44	if (parts[0] == ".") {
	45	if (this._base)
	46	parts[0] = this._base;
	47	else
	48	throw new Error(`Can't resolve a relative module '${moduleName}'`);
	49	}
	50
	51	if(parts.length > 1)
	52	parts.splice(-1,1,Uuid());
	53	else
	54	parts.push(Uuid());
	55
	56	var shim = parts.join('/');
	57
	58	let contextRequire = await new Promise((resolve, reject) => {
	59	define(shim, ["require"], function (ctx) {
	60	resolve(ctx);
	61	})
	62	});
	63
	64	return new RequireJsResolver({
	65	base: parts.slice(0,-1).join('/'),
	66	contextRequire: contextRequire
	67	});
	68	}
	69
	70	async loadModule(moduleName: string): Promise<Object> {
	71	return new Promise<Object>((resolve) => this._contextRequire.call(null, [moduleName], resolve)
	72	);
	73	}
	74
	75	} No newline at end of file

src/ts/di/ServiceDescriptor.ts created 644 +275 0

@@ -0,0 +1,275
	1	import { ActivationContext } from "./ActivationContext";
	2	import { Descriptor, ActivationType, ServiceMap, Constructor, Factory } from "./interfaces";
	3	import { Container } from "./Container";
	4	import { argumentNotNull, isPrimitive, oid } from "../safe";
	5
	6	let cacheId = 0;
	7
	8	function injectMethod(target, method, context, args) {
	9	var m = target[method];
	10	if (!m)
	11	throw new Error("Method '" + method + "' not found");
	12
	13	if (args instanceof Array)
	14	m.apply(target, context.parse(args, "." + method));
	15	else
	16	m.call(target, context.parse(args, "." + method));
	17	};
	18
	19	function makeClenupCallback(target, method) {
	20	if (typeof (method) === "string") {
	21	return function () {
	22	target[method]();
	23	};
	24	} else {
	25	return function () {
	26	method(target);
	27	};
	28	}
	29	};
	30
	31	export interface ServiceDescriptorParams<T> {
	32	activation: ActivationType
	33
	34	owner: Container
	35
	36	type: Constructor<T>
	37
	38	factory: Factory<T>
	39
	40	params
	41
	42	inject
	43
	44	services: ServiceMap
	45
	46	cleanup: (instance: T) => void
	47	}
	48
	49	export class ServiceDescriptor<T> implements Descriptor {
	50	_instance: T = null
	51
	52	_hasInstance = false
	53
	54	_activationType = ActivationType.CALL
	55
	56	_services: ServiceMap
	57
	58	_type: Constructor<T> = null
	59
	60	_factory: Factory<T> = null
	61
	62	_params
	63
	64	_inject: Array<Object>
	65
	66	_cleanup: (instance: T) => void
	67
	68	_cacheId: any
	69
	70	_owner: Container
	71
	72	constructor(opts: ServiceDescriptorParams<T>) {
	73	argumentNotNull(opts, "opts");
	74	argumentNotNull(opts.owner, "owner");
	75
	76	this._owner = opts.owner;
	77
	78	if (!(opts.type \|\| opts.factory))
	79	throw new Error(
	80	"Either a type or a factory must be specified");
	81
	82	if (opts.activation)
	83	this._activationType = opts.activation;
	84
	85	if (opts.type)
	86	this._type = opts.type;
	87
	88	if (opts.params)
	89	this._params = opts.params;
	90
	91	if (opts.inject)
	92	this._inject = opts.inject instanceof Array ? opts.inject : [opts.inject];
	93
	94	if (opts.services)
	95	this._services = opts.services;
	96
	97	if (opts.factory)
	98	this._factory = opts.factory;
	99
	100	if (opts.cleanup) {
	101	if (!(typeof (opts.cleanup) === "string" \|\| opts.cleanup instanceof Function))
	102	throw new Error(
	103	"The cleanup parameter must be either a function or a function name");
	104
	105	this._cleanup = opts.cleanup;
	106	}
	107
	108	if (this._activationType == ActivationType.SINGLETON) {
	109	let tof = this._type \|\| this._factory;
	110
	111	// create the persistent cache identifier for the type
	112	if (isPrimitive(tof))
	113	this._cacheId = tof;
	114	else
	115	this._cacheId = oid(tof);
	116	} else {
	117	this._cacheId = ++cacheId;
	118	}
	119	}
	120
	121	activate(context: ActivationContext, name: string) {
	122	// if we have a local service records, register them first
	123	let instance;
	124
	125	switch (this._activationType) {
	126	case ActivationType.SINGLETON: // SINGLETON
	127	// if the value is cached return it
	128	if (this._hasInstance)
	129	return this._instance;
	130
	131	// singletons are bound to the root container
	132	let container = context.container.getRootContainer();
	133
	134	if (container.has(this._cacheId)) {
	135	instance = container.get(this._cacheId);
	136	} else {
	137	instance = this._create(context, name);
	138	container.store(this._cacheId, instance);
	139	if (this._cleanup)
	140	container.onDispose(
	141	makeClenupCallback(instance, this._cleanup));
	142	}
	143
	144	this._hasInstance = true;
	145	return (this._instance = instance);
	146
	147	case ActivationType.CONTAINER: // CONTAINER
	148	//return a cached value
	149	if (this._hasInstance)
	150	return this._instance;
	151
	152	// create an instance
	153	instance = this._create(context, name);
	154
	155	// the instance is bound to the container
	156	if (this._cleanup)
	157	this._owner.onDispose(
	158	makeClenupCallback(instance, this._cleanup));
	159
	160	// cache and return the instance
	161	this._hasInstance = true;
	162	return (this._instance = instance);
	163	case ActivationType.CONTEXT: // CONTEXT
	164	//return a cached value if one exists
	165	if (context.has(this._cacheId))
	166	return context.get(this._cacheId);
	167	// context context activated instances are controlled by callers
	168	return context.store(this._cacheId, this._create(
	169	context,
	170	name));
	171	case ActivationType.CALL: // CALL
	172	// per-call created instances are controlled by callers
	173	return this._create(context, name);
	174	case ActivationType.HIERARCHY: // HIERARCHY
	175	// hierarchy activated instances are behave much like container activated
	176	// except they are created and bound to the child container
	177
	178	// return a cached value
	179	if (context.container.has(this._cacheId))
	180	return context.container.get(this._cacheId);
	181
	182	instance = this._create(context, name);
	183
	184	if (this._cleanup)
	185	context.container.onDispose(makeClenupCallback(
	186	instance,
	187	this._cleanup));
	188
	189	return context.container.store(this._cacheId, instance);
	190	default:
	191	throw "Invalid activation type: " + this._activationType;
	192	}
	193	}
	194
	195	isInstanceCreated() {
	196	return this._hasInstance;
	197	}
	198
	199	getInstance() {
	200	return this._instance;
	201	}
	202
	203	_create(context, name) {
	204	context.enter(name, this, Boolean(this._services));
	205
	206	if (this._activationType != ActivationType.CALL &&
	207	context.visit(this._cacheId) > 0)
	208	throw new Error("Recursion detected");
	209
	210	if (this._services) {
	211	for (var p in this._services)
	212	context.register(p, this._services[p]);
	213	}
	214
	215	var instance;
	216
	217	if (!this._factory) {
	218	var ctor = this._type;
	219
	220	if (this._params === undefined) {
	221	this._factory = function () {
	222	return new ctor();
	223	};
	224	} else if (this._params instanceof Array) {
	225	this._factory = function () {
	226	var inst = Object.create(ctor.prototype);
	227	var ret = ctor.apply(inst, arguments);
	228	return typeof (ret) === "object" ? ret : inst;
	229	};
	230	} else {
	231	this._factory = function (param) {
	232	return new ctor(param);
	233	};
	234	}
	235	}
	236
	237	if (this._params === undefined) {
	238	instance = this._factory();
	239	} else if (this._params instanceof Array) {
	240	instance = this._factory.apply(this, context.parse(
	241	this._params,
	242	".params"));
	243	} else {
	244	instance = this._factory(context.parse(
	245	this._params,
	246	".params"));
	247	}
	248
	249	if (this._inject) {
	250	this._inject.forEach(function (spec) {
	251	for (var m in spec)
	252	injectMethod(instance, m, context, spec[m]);
	253	});
	254	}
	255
	256	context.leave();
	257
	258	return instance;
	259	}
	260
	261	// @constructor {singleton} foo/bar/Baz
	262	// @factory {singleton}
	263	toString() {
	264	var parts = [];
	265
	266	parts.push(this._type ? "@constructor" : "@factory");
	267
	268	parts.push(ActivationType[this._activationType]);
	269
	270	if (typeof (this._type) === "string")
	271	parts.push(this._type);
	272
	273	return parts.join(" ");
	274	}
	275	} No newline at end of file

src/ts/di/ValueDescriptor.ts created 644 +23 0

@@ -0,0 +1,23
	1	import { Descriptor } from "./interfaces";
	2	import { ActivationContext } from "./ActivationContext";
	3
	4	export class ValueDescriptor<T> implements Descriptor {
	5	_value: T
	6
	7	constructor(value: T) {
	8	this._value = value;
	9	}
	10
	11	activate(context: ActivationContext, name: string) {
	12	context.enter(name);
	13	let v = this._value;
	14	context.leave();
	15	return v;
	16	}
	17	isInstanceCreated(): boolean {
	18	return true;
	19	}
	20	getInstance(): T {
	21	return this._value;
	22	}
	23	} No newline at end of file

src/ts/di/interfaces.ts created 644 +28 0

@@ -0,0 +1,28
	1	import { isNull } from "../safe";
	2	import { ActivationContext } from "./ActivationContext";
	3
	4	export interface Descriptor {
	5	activate(context: ActivationContext, name?: string);
	6	}
	7
	8	export type Constructor<T = {}> = new (...args: any[]) => T;
	9
	10
	11	export type Factory<T = {}> = (...args: any[]) => T;
	12
	13	export function isDescriptor(instance): instance is Descriptor {
	14	return (!isNull(instance)) &&
	15	('activate' in instance);
	16	}
	17
	18	export interface ServiceMap {
	19	[s: string] : Descriptor
	20	}
	21
	22	export enum ActivationType {
	23	SINGLETON,
	24	CONTAINER,
	25	HIERARCHY,
	26	CONTEXT,
	27	CALL
	28	} No newline at end of file

tslint.json created 644 +40 0

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

build.gradle +1 -1

             if (release != 'rtm') {
                 version += "-$release"
             }
             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', 'tsconfig.json'
             }
             task _packageMeta(type: Copy) {
                 inputs.property("version", version)
                 from('.') {
                     include 'package.json', '.npmignore', 'readme.md', 'license', 'history.md'
                 }
                 into distDir
                 doLast {
                     exec {
                         workingDir distDir
                         commandLine 'npm', 'version', version
                     }
                 }
             }
-            task build(dependsOn: [_npmInstall, _buildTs, _legacyJs, _packageMeta]) {
+            task build(dependsOn: [_legacyJs, _npmInstall, _buildTs, _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', 'tsconfig.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/ts/Uuid.ts +1 -1

             // 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 function Uuid() {
+                return _v4();
             }
             export namespace Uuid {
                 export const v4 = _v4;
                 export const v1 = _v1;
                 export const empty = "00000000-0000-0000-0000-000000000000";
                 export const parse = _parse;
                 export const unparse = _unparse;
             }

src/ts/di.ts 0 -126

	@@ -1,126 +0,0
	1	import { TraceSource } from "./log/TraceSource";
	2	import { argumentNotNull, argumentNotEmptyString, isPrimitive, each, isNull } from "./safe";
	3	import { Uuid } from './Uuid';
	4	import {ActivationContext} from "./di/ActivationContext";
	5
	6	let trace = TraceSource.get("di");
	7
	8	export interface Descriptor {
	9	activate(context: ActivationContext, name: string): any
	10	}
	11
	12	export function isDescriptor(value: any): value is Descriptor {
	13	return ("activate" in value);
	14	}
	15
	16	export interface ServiceMap {
	17	[s: string] : Descriptor
	18	}
	19
	20	export class ActivationContextInfo {
	21	name: string
	22
	23	service: string
	24
	25	scope: ServiceMap
	26	}
	27
	28	export class ActivationError {
	29	activationStack: ActivationContextInfo[]
	30
	31	service: string
	32
	33	innerException: any
	34
	35	message: string
	36
	37	constructor(service: string, activationStack: ActivationContextInfo[], innerException) {
	38	this.message = "Failed to activate the service";
	39	this.activationStack = activationStack;
	40	this.service = service;
	41	this.innerException = innerException;
	42	}
	43
	44	toString() {
	45	var parts = [this.message];
	46	if (this.service)
	47	parts.push("when activating: " + this.service.toString());
	48
	49	if (this.innerException)
	50	parts.push("caused by: " + this.innerException.toString());
	51
	52	if (this.activationStack) {
	53	parts.push("at");
	54	this.activationStack.forEach(function (x) {
	55	parts.push(" " + x.name + " " +
	56	(x.service ? x.service.toString() : ""));
	57	});
	58	}
	59
	60	return parts.join("\n");
	61	}
	62	}
	63
	64
	65	export enum ActivationType {
	66	SINGLETON,
	67	CONTAINER,
	68	HIERARCHY,
	69	CONTEXT,
	70	CALL
	71	}
	72
	73
	74
	75	interface ServiceDescriptorParams {
	76
	77	}
	78
	79	class ServiceDescriptor extends Descriptor {
	80	constructor(opts: ServiceDescriptorParams) {
	81	super();
	82	}
	83
	84	activate(context: ActivationContext, name: string) {
	85	throw new Error("Method not implemented.");
	86	}
	87	isInstanceCreated(): boolean {
	88	throw new Error("Method not implemented.");
	89	}
	90	getInstance() {
	91	throw new Error("Method not implemented.");
	92	}
	93	}
	94
	95
	96
	97	class AggregateDescriptor<T> extends Descriptor {
	98	constructor(value: T) {
	99	super();
	100	}
	101
	102	activate(context: ActivationContext, name: string) {
	103	throw new Error("Method not implemented.");
	104	}
	105	isInstanceCreated(): boolean {
	106	throw new Error("Method not implemented.");
	107	}
	108	getInstance(): T {
	109	throw new Error("Method not implemented.");
	110	}
	111	}
	112
	113	class ValueDescriptor<T> implements Descriptor {
	114	activate(context: ActivationContext, name: string) {
	115	throw new Error("Method not implemented.");
	116	}
	117	isInstanceCreated(): boolean {
	118	throw new Error("Method not implemented.");
	119	}
	120	getInstance(): T {
	121	throw new Error("Method not implemented.");
	122	}
	123	constructor(value: T) {
	124
	125	}
	126	} No newline at end of file

src/ts/di/ActivationContext.ts +10 -2

             import { TraceSource } from "../log/TraceSource";
             import { argumentNotNull, argumentNotEmptyString, isPrimitive, each, isNull } from "../safe";
-            import { Uuid } from '../Uuid';
+            import { Descriptor, ServiceMap, isDescriptor } from "./interfaces";
-            import { Container, ActivationContextInfo, ServiceMap, Descriptor, isDescriptor } from "../di";
+            import { Container } from "./Container";
             let trace = TraceSource.get("di");
+            export class ActivationContextInfo {
+                name: string
+                service: string
+                scope: ServiceMap
+            }
             export class ActivationContext {
                 _cache: object
                 _services: ServiceMap
                 _stack: ActivationContextInfo[]
                 _visited: any
                 container: any
                 constructor(container: Container, services: ServiceMap, cache?: object, visited?) {
                     argumentNotNull(container, "container");
                     argumentNotNull(services, "services");
                     this._visited = visited || {};
                     this._stack = [];
                     this._cache = cache || {};
                     this._services = services;
                     this.container = container;
                 }
                 getService(name, def?): any {
                     let d = this._services[name];
                     if (!d)
                         if (arguments.length > 1)
                             return def;
                         else
                             throw new Error("Service '" + name + "' not found");
                     return d.activate(this, name);
                 }
                 /**
                  * registers services local to the the activation context
                  *
                  * @name{string} the name of the service
                  * @service{string} the service descriptor to register
                  */
                 register(name: string, service: Descriptor) {
                     argumentNotEmptyString(name, "name");
                     this._services[name] = service;
                 }
                 clone() {
                     return new ActivationContext(
                         this.container,
                         Object.create(this._services),
                         this._cache,
                         this._visited
                     );
                 }
                 has(id) {
                     return id in this._cache;
                 }
                 get(id) {
                     return this._cache[id];
                 }
                 store(id, value) {
                     return (this._cache[id] = value);
                 }
                 parse(data: any, name) {
                     var me = this;
                     if (isPrimitive(data))
                         return data;
                     if (isDescriptor(data)) {
                         return data.activate(this, name);
                     } else if (data instanceof Array) {
                         me.enter(name);
                         var v = data.map(function (x, i) {
                             return me.parse(x, "." + i);
                         });
                         me.leave();
                         return v;
                     } else {
                         me.enter(name);
                         var result = {};
                         for (var p in data)
                             result[p] = me.parse(data[p], "." + p);
                         me.leave();
                         return result;
                     }
                 }
                 visit(id) {
                     var count = this._visited[id] || 0;
                     this._visited[id] = count + 1;
                     return count;
                 }
                 getStack() {
                     return this._stack.slice().reverse();
                 }
                 enter(name, d?, localize?) {
                     if (trace.isLogEnabled())
                         trace.log("enter " + name + " " + (d || "") +
                             (localize ? " localize" : ""));
                     this._stack.push({
                         name: name,
                         service: d,
                         scope: this._services
                     });
                     if (localize)
                         this._services = Object.create(this._services);
                 }
                 leave() {
                     var ctx = this._stack.pop();
                     this._services = ctx.scope;
                     if (trace.isLogEnabled())
                         trace.log("leave " + ctx.name + " " + (ctx.service || ""));
                 }
             }

src/ts/di/Container.ts +14 -4

+            declare function require(modules: string[], cb?: (...args: any[]) => any) : void;
+            declare function define(name:string, modules: string[], cb?: (...args: any[]) => any) : void;
             import { Uuid } from "../Uuid";
             import { ActivationContext } from "./ActivationContext";
-            import { ActivationError } from "../di";
+            import { ValueDescriptor } from "./ValueDescriptor";
+            import { ActivationError } from "./ActivationError";
+            import { isDescriptor, ActivationType } from "./interfaces";
+            import { AggregateDescriptor } from "./AggregateDescriptor";
+            import { isPrimitive } from "../safe";
+            import { ReferenceDescriptor } from "./ReferenceDescriptor";
+            import { ServiceDescriptor } from "./ServiceDescriptor";
             export class Container {
                 _services
                 _cache
                 _cleanup: any[]
                 _root: Container
                 _parent: Container
                 constructor(parent?: Container) {
                     this._parent = parent;
                     this._services = parent ? Object.create(parent._services) : {};
                     this._cache = {};
                     this._cleanup = [];
                     this._root = parent ? parent.getRootContainer() : this;
                     this._services.container = new ValueDescriptor(this);
                 }
                 getRootContainer() {
                     return this._root;
                 }
                 getParent() {
                     return this._parent;
                 }
                 getService<T = any>(name: string, def?: T) {
                     let 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(nameOrCollection, service?) {
                     if (arguments.length == 1) {
                         var data = nameOrCollection;
                         for (let name in data)
                             this.register(name, data[name]);
                     } else {
-                        if (!(service instanceof Descriptor))
+                        if (!(isDescriptor(service)))
                             service = new ValueDescriptor(service);
                         this._services[nameOrCollection] = service;
                     }
                     return this;
                 }
                 onDispose(callback) {
                     if (!(callback instanceof Function))
                         throw new Error("The callback must be a function");
                     this._cleanup.push(callback);
                 }
                 dispose() {
                     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.
                  *
                  */
                 async configure(config, opts) {
                     var me = this,
                         contextRequire = (opts && opts.contextRequire);
                     if (typeof (config) === "string") {
                         let args;
                         if (!contextRequire) {
                             var shim = [config, Uuid()].join(config.indexOf("/") != -1 ? "-" : "/");
                             args = await new Promise((resolve, reject) => {
                                 define(shim, ["require", config], function (ctx, data) {
                                     resolve([data, {
                                         contextRequire: ctx
                                     }]);
                                 })
                             });
                             require([shim]);
                         } else {
                             // TODO how to get correct contextRequire for the relative config module?
                             args = await new Promise((resolve, reject) => {
                                 contextRequire([config], function (data) {
                                     resolve([data, {
                                         contextRequire: contextRequire
                                     }]);
                                 });
                             });
                         }
                         return me._configure.apply(me, args);
                     } else {
                         return me._configure(config, opts);
                     }
                 }
                 createChildContainer() {
                     return new Container(this);
                 }
                 has(id) {
                     return id in this._cache;
                 }
                 get(id) {
                     return this._cache[id];
                 }
                 store(id, value) {
                     return (this._cache[id] = value);
                 }
                 async _configure(data, opts) {
                     var typemap = {},
                         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))
+                        if (!(isDescriptor(service)))
                             service = new AggregateDescriptor(service);
                         services[p] = service;
                     }
                     me.register(services);
                     var names = [];
                     for (p in typemap)
                         names.push(p);
                     return new Promise((resolve, reject) => {
                         if (names.length) {
                             contextRequire(names, function () {
                                 for (var i = 0; i < names.length; i++)
                                     typemap[names[i]] = arguments[i];
                                 resolve(me);
                             });
                         } else {
                             resolve(me);
                         }
                     });
                 }
                 _parse(data, typemap) {
-                    if (isPrimitive(data) || data instanceof Descriptor)
+                    if (isPrimitive(data) || isDescriptor(data))
                         return data;
                     if (data.$dependency) {
                         return new ReferenceDescriptor(
                             data.$dependency,
                             data.lazy,
                             data.optional,
                             data["default"],
                             data.services && this._parseObject(data.services, typemap));
                     } else if (data.$value) {
                         return !data.parse ?
                             new ValueDescriptor(data.$value) :
                             new AggregateDescriptor(this._parse(data.$value, typemap));
                     } else if (data.$type || data.$factory) {
                         return this._parseService(data, typemap);
                     } else if (data instanceof Array) {
                         return this._parseArray(data, typemap);
                     }
                     return this._parseObject(data, typemap);
                 }
                 _parseService(data, typemap) {
                     var me = this,
                         opts: any = {
                             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 = ActivationType.SINGLETON;
                                     break;
                                 case "container":
                                     opts.activation = ActivationType.CONTAINER;
                                     break;
                                 case "hierarchy":
                                     opts.activation = ActivationType.HIERARCHY;
                                     break;
                                 case "context":
                                     opts.activation = ActivationType.CONTEXT;
                                     break;
                                 case "call":
                                     opts.activation = ActivationType.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 ServiceDescriptor(opts);
                 }
                 _parseObject(data, typemap) {
                     if (data.constructor &&
                         data.constructor.prototype !== Object.prototype)
                         return new ValueDescriptor(data);
                     var o = {};
                     for (var p in data)
                         o[p] = this._parse(data[p], typemap);
                     return o;
                 }
                 _parseArray(data, typemap) {
                     if (data.constructor &&
                         data.constructor.prototype !== Array.prototype)
                         return new ValueDescriptor(data);
                     var me = this;
                     return data.map(function (x) {
                         return me._parse(x, typemap);
                     });
                 }
             }

src/ts/di/ReferenceDescriptor.ts +11 -9

             import { isNull, argumentNotEmptyString, each } from "../safe";
+            import { ActivationContext } from "./ActivationContext";
+            import { ServiceMap, Descriptor } from "./interfaces";
+            import { ActivationError } from "./ActivationError";
-            class ReferenceDescriptor extends Descriptor {
+            export class ReferenceDescriptor implements Descriptor {
                 _name: string
                 _lazy = false
                 _optional = false
                 _default: any
-                _services: object
+                _services: ServiceMap
-                constructor(name: string, lazy: boolean, optional: boolean, def, services: object) {
+                constructor(name: string, lazy: boolean, optional: boolean, def, services: ServiceMap) {
-                    super();
                     argumentNotEmptyString(name, "name");
                     this._name = name;
                     this._lazy = Boolean(lazy);
                     this._optional = Boolean(optional);
                     this._default = def;
                     this._services = services;
                 }
                 activate(context: ActivationContext, name: string) {
                     var me = this;
                     context.enter(name, this, true);
                     // добавляем сервисы
                     if (me._services) {
                         for (var p in me._services) {
                             var sv = me._services[p];
-                            context.register(p, sv instanceof Descriptor ? sv : new AggregateDescriptor(sv));
+                            context.register(p, sv);
                         }
                     }
                     if (me._lazy) {
                         // сохраняем контекст активации
                         context = context.clone();
-                        return function (cfg) {
+                        return function (cfg: ServiceMap) {
                             // защищаем контекст на случай исключения в процессе
                             // активации
                             var ct = context.clone();
                             try {
                                 if (cfg)
-                                    each(cfg, function (v, k) {
+                                    for(let k in cfg)
-                                        ct.register(k, v instanceof Descriptor ? v : new AggregateDescriptor(v));
+                                        ct.register(k, cfg[v]);
-                                    });
                                 return me._optional ? ct.getService(me._name, me._default) : ct
                                     .getService(me._name);
                             } catch (error) {
                                 throw new ActivationError(me._name, ct.getStack(), error);
                             }
                         };
                     }
                     var v = me._optional ?
                         context.getService(me._name, me._default) :
                         context.getService(me._name);
                     context.leave();
                     return v;
                 }
                 isInstanceCreated() {
                     return false;
                 }
                 getInstance() {
                     throw new Error("The reference descriptor doesn't allowed to hold an instance");
                 }
                 toString() {
                     var opts = [];
                     if (this._optional)
                         opts.push("optional");
                     if (this._lazy)
                         opts.push("lazy");
                     var parts = [
                         "@ref "
                     ];
                     if (opts.length) {
                         parts.push("{");
                         parts.push(opts.join());
                         parts.push("} ");
                     }
                     parts.push(this._name);
                     if (!isNull(this._default)) {
                         parts.push(" = ");
                         parts.push(this._default);
                     }
                     return parts.join("");
                 }
             }

src/ts/safe.ts +55 -29

+            let _nextOid = 0;
+            const _oid = Symbol("__oid");
+            export function oid(instance: object) {
+                if (isNull(instance))
+                    return null;
+                if (_oid in instance)
+                    return instance[_oid];
+                else
+                    return (instance[_oid] = "oid_" + (++_nextOid));
+            }
             export function argumentNotNull(arg, name) {
                 if (arg === null || arg === undefined)
                     throw new Error("The argument " + name + " can't be null or undefined");
             }
             export function 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;
+                return parseInt(arg, 10) === arg;
             }
             export function isNumber(arg) {
-                return parseFloat(arg) == arg;
+                return parseFloat(arg) === arg;
             }
             export function isString(val) {
-                return typeof (val) == "string" || val instanceof String;
+                return typeof (val) === "string" || val instanceof String;
             }
             export function isNullOrEmptyString(str) {
                 if (str === null || str === undefined ||
-                    ((typeof (str) == "string" || str instanceof String) && str.length === 0))
+                    ((typeof (str) === "string" || str instanceof String) && str.length === 0))
                     return true;
             }
             export function isNotEmptyArray(arg): arg is Array<any> {
                 return (arg instanceof Array && arg.length > 0);
             }
+            export function getGlobal() {
+                return this;
+            }
+            export function get(member: string, context?: object) {
+                argumentNotEmptyString(member, "member");
+                let that = context || getGlobal();
+                const parts = member.split(".");
+                for (const m of parts) {
+                    if (!m)
+                        continue;
+                    if (isNull(that = that[m]))
+                        break;
+                }
+                return that;
+            }
             /**
              * Выполняет метод для каждого элемента массива, останавливается, когда
              * либо достигнут конец массива, либо функция <c>cb</c> вернула
              * значение.
              *
              * @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++) {
+                    for (let i = 0; i < obj.length; i++) {
-                        x = cb.call(thisArg, obj[i], i);
+                        const x = cb.call(thisArg, obj[i], i);
                         if (x !== undefined)
                             return x;
                     }
                 } else {
-                    var keys = Object.keys(obj);
+                    const keys = Object.keys(obj);
-                    for (i = 0; i < keys.length; i++) {
+                    for (const k of keys) {
-                        var k = keys[i];
+                        const x = cb.call(thisArg, obj[k], k);
-                        x = cb.call(thisArg, obj[k], k);
                         if (x !== undefined)
                             return x;
                     }
                 }
             }
             /** Copies property values from a source object to the destination and returns
              * the destination onject.
              *
              * @param dest The destination object into which properties from the source
              *  object will be copied.
              * @param source The source of values which will be copied to the destination
              *  object.
              * @param template An optional parameter specifies which properties should be
              *  copied from the source and how to map them to the destination. If the
              *  template is an array it contains the list of property names to copy from the
              *  source to the destination. In case of object the templates contains the map
              *  where keys are property names in the source and the values are property
              *  names in the destination object. If the template isn't specified then the
              *  own properties of the source are entirely copied to the destination.
              *
              */
             export function mixin<T, S>(dest: T, source: S, template?: string[] | object): T & S {
                 argumentNotNull(dest, "to");
-                let _res = <T & S>dest;
+                const _res = dest as T & S;
                 if (template instanceof Array) {
-                    for(let i = 0; i < template.length; i++) {
+                    for (const p  of template) {
-                        let p = template[i];
                         if (p in source)
                             _res[p] = source[p];
                     }
                 } else if (template) {
-                    let keys = Object.keys(source);
+                    const keys = Object.keys(source);
-                    for(let i = 0; i < keys.length; i++) {
+                    for (const p of keys) {
-                        let p = keys[i];
                         if (p in template)
                             _res[template[p]] = source[p];
                     }
                 } else {
-                    let keys = Object.keys(source);
+                    const keys = Object.keys(source);
-                    for(let i = 0; i < keys.length; i++) {
+                    for (const p of keys)
-                        let p = keys[i];
                         _res[p] = source[p];
                 }
                 return _res;
             }
             /** Wraps the specified function to emulate an asynchronous execution.
              * @param{Object} thisArg [Optional] Object which will be passed as 'this' to the function.
              * @param{Function|String} fn [Required] Function wich will be wrapped.
              */
             export function async(_fn: (...args: any[]) => any, thisArg): (...args: any[]) => PromiseLike<any> {
                 let fn = _fn;
-                if (arguments.length == 2 && !(fn instanceof Function))
+                if (arguments.length === 2 && !(fn instanceof Function))
                     fn = thisArg[fn];
                 if (fn == null)
                     throw new Error("The function must be specified");
                 function wrapresult(x, e?): PromiseLike<any> {
                     if (e) {
                         return {
-                            then: function (cb, eb) {
+                            then(cb, eb) {
                                 try {
                                     return eb ? wrapresult(eb(e)) : this;
                                 } catch (e2) {
                                     return wrapresult(null, e2);
                                 }
                             }
                         };
                     } else {
                         if (x && x.then)
                             return x;
                         return {
-                            then: function (cb) {
+                            then(cb) {
                                 try {
                                     return cb ? wrapresult(cb(x)) : this;
                                 } catch (e2) {
                                     return wrapresult(e2);
                                 }
                             }
                         };
                     }
                 }
-                return function () {
+                return (...args) => {
                     try {
-                        return wrapresult(fn.apply(thisArg, arguments));
+                        return wrapresult(fn.apply(thisArg, args));
                     } catch (e) {
                         return wrapresult(null, e);
                     }
                 };
             }
-            export function delegate<T, K extends keyof T>(target: T, _method: (K | Function)) {
+            type _AnyFn = (...args) => any;
+            export function delegate<T, K extends keyof T>(target: T, _method: (K | _AnyFn)) {
                 let method;
                 if (!(_method instanceof Function)) {
                     argumentNotNull(target, "target");
                     method = target[_method];
                     if (!(method instanceof Function))
                         throw new Error("'method' argument must be a Function or a method name");
                 } else {
                     method = _method;
                 }
-                return function () {
+                return (...args) => {
-                    return method.apply(target, arguments);
+                    return method.apply(target, args);
                 };
             }
             /**
              * Для каждого элемента массива вызывает указанную функцию и сохраняет
              * возвращенное значение в массиве результатов.
              *
              * @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();
             }

src/js/di/ActivationContext.js removed 0 -138

NO CONTENT: file was removed

src/js/di/ActivationError.js removed 0 -39

NO CONTENT: file was removed

src/js/di/Container.js removed 0 -299

NO CONTENT: file was removed

src/js/di/Descriptor.js removed 0 -4

NO CONTENT: file was removed

src/js/di/ReferenceDescriptor.js removed 0 -90

NO CONTENT: file was removed

src/js/di/ServiceDescriptor.js removed 0 -289

NO CONTENT: file was removed

src/js/di/ValueDescriptor.js removed 0 -38

NO CONTENT: file was removed

src/ts/di/Descriptor.ts removed 0 -11

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