implab/implabjs-core Commit - r39:ed82314aa5c8

ts code cleanup, linting

cin -

r39:ed82314aa5c8 di-typescript

parent child

Context file:

r39:ed82314aa5c8

Collapse all files

src/ts/Cancellation.ts +3 -4

             import { ICancellation, IDestroyable } from "./interfaces";
             import { argumentNotNull } from "./safe";
             const destroyed = {
                 destroy() {
                 }
             };
             export class Cancellation implements ICancellation {
                 private _reason: any;
                 private _cbs: Array<(e) => void>;
                 constructor(action: (cancel: (e) => void) => void) {
                     argumentNotNull(action, "action");
                     action(this._cancel.bind(this));
                 }
                 isSupported(): boolean {
                     return true;
                 }
                 throwIfRequested(): void {
                     if (this._reason)
                         throw this._reason;
                 }
                 isRequested(): boolean {
                     return !!this._reason;
                 }
                 register(cb: (e: any) => void): IDestroyable {
                     argumentNotNull(cb, "cb");
                     if (this._reason) {
                         cb(this._reason);
                         return destroyed;
                     } else {
                         if (!this._cbs)
                             this._cbs = [cb];
                         else
                             this._cbs.push(cb);
-                        let me = this;
+                        const me = this;
                         return {
                             destroy() {
                                 me._unregister(cb);
                             }
                         };
                     }
                 }
                 private _unregister(cb) {
                     if (this._cbs) {
-            	    let i = this._cbs.indexOf(cb);
+                        const i = this._cbs.indexOf(cb);
                         if (i >= 0)
                             this._cbs.splice(i, 1);
                     }
                 }
                 private _cancel(reason) {
                     if (this._reason)
                         return;
                     this._reason = (reason = reason || new Error("Operation cancelled"));
                     if (this._cbs) {
                         this._cbs.forEach(cb => cb(reason));
                         this._cbs = null;
                     }
                 }
                 static readonly none: ICancellation = {
                     isSupported(): boolean {
                         return false;
                     },
                     throwIfRequested(): void {
                     },
                     isRequested(): boolean {
                         return false;
                     },
                     register(_cb: (e: any) => void): IDestroyable {
                         return destroyed;
                     }
                 };
-            }
  No newline at end of file

src/ts/Observable.ts +26 -37

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

src/ts/Uuid.ts +36 -39

             // 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;
+            const _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;
+                const _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);
+                        const _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);
+                    const _rnds = new Array(16);
-                    _rng = function () {
+                    _rng = () => {
-                        for (var i = 0, r; i < 16; i++) {
+                        for (let 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) {
+                    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) {
+                if ("function" === typeof require) {
                     try {
-                        let _rb = require('crypto').randomBytes;
+                        const _rb = require("crypto").randomBytes;
-                        _rng = _rb && function () {
+                        _rng = _rb && (() => _rb(16));
-                            return _rb(16);
-                        };
                         _rng();
                     } catch (e) { /**/ }
                 }
             }
             if (_window) {
                 setupBrowser();
             } else {
                 setupNode();
             }
             // Buffer class to use
-            let BufferClass = ('function' === typeof Buffer) ? Buffer : Array;
+            const BufferClass = ("function" === typeof Buffer) ? Buffer : Array;
             // Maps for number <-> hex string conversion
-            let _byteToHex = [];
+            const _byteToHex = [];
-            let _hexToByte = {};
+            const _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> {
+            export function _parse(s, buf?, offset?): Array<string> {
-                let i = (buf && offset) || 0, ii = 0;
+                const i = (buf && offset) || 0; let ii = 0;
                 buf = buf || [];
-                s.toLowerCase().replace(/[0-9a-f]{2}/g, function (oct) {
+                s.toLowerCase().replace(/[0-9a-f]{2}/g, 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;
+                let i = offset || 0; const 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++]] + '-' + 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();
+            const _seedBytes = _rng();
             // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit =
             // 1)
-            let _nodeId = [
+            const _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;
+            let _lastMSecs = 0; let _lastNSecs = 0;
             // See https://github.com/broofa/node-uuid for API details
-            function _v1(options?, buf?, offset?): string {
+            export function _v1(options?, buf?, offset?): string {
                 let i = buf && offset || 0;
-                let b = buf || [];
+                const 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;
+                const 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');
+                        "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;
+                const 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;
+                const 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;
+                const 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 {
+            export function _v4(options?, buf?, offset?): string {
                 // Deprecated - 'format' argument, as supported in v1.2
-                let i = buf && offset || 0;
+                const i = buf && offset || 0;
-                if (typeof (options) === 'string') {
+                if (typeof (options) === "string") {
-                    buf = (options === 'binary') ? new BufferClass(16) : null;
+                    buf = (options === "binary") ? new BufferClass(16) : null;
                     options = null;
                 }
                 options = options || {};
-                let rnds = options.random || (options.rng || _rng)();
+                const 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;
-            }
  No newline at end of file

src/ts/di/ActivationContext.ts +31 -37

             import { TraceSource } from "../log/TraceSource";
             import { argumentNotNull, argumentNotEmptyString, isPrimitive, each, isNull } from "../safe";
             import { Descriptor, ServiceMap, isDescriptor } from "./interfaces";
             import { Container } from "./Container";
-            let trace = TraceSource.get("di");
+            const trace = TraceSource.get("@implab/core/di/ActivationContext");
-            export class ActivationContextInfo {
+            export interface ActivationContextInfo {
-                name: string
+                name: string;
-                service: string
+                service: Descriptor;
-                scope: ServiceMap
+                scope: ServiceMap;
             }
+            export class ActivationContext {
+                _cache: object;
-            export class ActivationContext {
+                _services: ServiceMap;
-                _cache: object
-                _services: ServiceMap
-                _stack: ActivationContextInfo[]
+                _stack: ActivationContextInfo[];
-                _visited: any
+                _visited: object;
-                container: any
+                container: Container;
                 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];
+                    const d = this._services[name];
                     if (!d)
                         if (arguments.length > 1)
                             return def;
                         else
-                            throw new Error("Service '" + name + "' not found");
+                            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) {
+                has(id: string) {
                     return id in this._cache;
                 }
-                get(id) {
+                get(id: string) {
                     return this._cache[id];
                 }
-                store(id, value) {
+                store(id: string, value) {
                     return (this._cache[id] = value);
                 }
-                parse(data: any, name) {
+                parse(data: object, name: string) {
-                    var me = this;
                     if (isPrimitive(data))
                         return data;
                     if (isDescriptor(data)) {
                         return data.activate(this, name);
                     } else if (data instanceof Array) {
-                        me.enter(name);
+                        this.enter(name);
-                        var v = data.map(function (x, i) {
+                        const v = data.map( (x, i) => this.parse(x, `[${i}]`));
-                            return me.parse(x, "." + i);
+                        this.leave();
-                        });
-                        me.leave();
                         return v;
                     } else {
-                        me.enter(name);
+                        this.enter(name);
-                        var result = {};
+                        const result = {};
-                        for (var p in data)
+                        for (const p in data)
-                            result[p] = me.parse(data[p], "." + p);
+                            result[p] = this.parse(data[p], "." + p);
-                        me.leave();
+                        this.leave();
                         return result;
                     }
                 }
-                visit(id) {
+                visit(id: string) {
-                    var count = this._visited[id] || 0;
+                    const count = this._visited[id] || 0;
                     this._visited[id] = count + 1;
                     return count;
                 }
                 getStack() {
                     return this._stack.slice().reverse();
                 }
-                enter(name, d?, localize?) {
+                enter(name: string, d?: Descriptor, localize?: boolean) {
                     if (trace.isLogEnabled())
                         trace.log("enter " + name + " " + (d || "") +
                             (localize ? " localize" : ""));
                     this._stack.push({
-                        name: name,
+                        name,
                         service: d,
                         scope: this._services
                     });
                     if (localize)
                         this._services = Object.create(this._services);
                 }
                 leave() {
-                    var ctx = this._stack.pop();
+                    const ctx = this._stack.pop();
                     this._services = ctx.scope;
                     if (trace.isLogEnabled())
                         trace.log("leave " + ctx.name + " " + (ctx.service || ""));
                 }
-            }
  No newline at end of file

src/ts/di/ActivationError.ts +9 -10

             import { ActivationContextInfo } from "./ActivationContext";
             export class ActivationError {
-                activationStack: ActivationContextInfo[]
+                activationStack: ActivationContextInfo[];
-                service: string
+                service: string;
-                innerException: any
+                innerException: any;
-                message: string
+                message: string;
                 constructor(service: string, activationStack: ActivationContextInfo[], innerException) {
                     this.message = "Failed to activate the service";
                     this.activationStack = activationStack;
                     this.service = service;
                     this.innerException = innerException;
                 }
                 toString() {
-                    var parts = [this.message];
+                    const parts = [this.message];
                     if (this.service)
                         parts.push("when activating: " + this.service.toString());
                     if (this.innerException)
                         parts.push("caused by: " + this.innerException.toString());
                     if (this.activationStack) {
                         parts.push("at");
-                        this.activationStack.forEach(function (x) {
+                        this.activationStack
-                            parts.push("    " + x.name + " " +
+                            .forEach(x => parts.push(`    ${x.name} ${x.service ? x.service.toString() : ""}`));
-                                (x.service ? x.service.toString() : ""));
-                        });
                     }
                     return parts.join("\n");
                 }
-            }
  No newline at end of file

src/ts/di/AggregateDescriptor.ts +6 -6

             import { Descriptor } from "./interfaces";
             import { ActivationContext } from "./ActivationContext";
-            export class AggregateDescriptor<T> implements Descriptor {
+            export class AggregateDescriptor implements Descriptor {
-                _value: T;
+                _value: object;
-                constructor(value: T) {
+                constructor(value: object) {
+                    this._value = value;
                 }
                 activate(context: ActivationContext, name: string) {
                     context.enter(name);
                     const v = context.parse(this._value, ".params");
                     context.leave();
                     return v;
                 }
                 isInstanceCreated(): boolean {
                     return false;
                 }
-                getInstance(): T {
+                getInstance(): any {
-                    throw new Error("Not supported exception");
+                    throw new Error("Not supported");
                 }
             }

src/ts/di/Container.ts +5 -9

             import { ActivationContext } from "./ActivationContext";
             import { ValueDescriptor } from "./ValueDescriptor";
             import { ActivationError } from "./ActivationError";
             import { isDescriptor, ActivationType, ServiceMap, isDependencyRegistration, isValueRegistration, ServiceRegistration } from "./interfaces";
             import { AggregateDescriptor } from "./AggregateDescriptor";
             import { isPrimitive } from "../safe";
             import { ReferenceDescriptor } from "./ReferenceDescriptor";
             import { ServiceDescriptor, ServiceDescriptorParams } from "./ServiceDescriptor";
             import { ModuleResolverBase } from "./ModuleResolverBase";
             import format = require("../text/format");
             export class Container {
                 _services: ServiceMap;
                 _cache: object;
                 _cleanup: (() => void)[];
                 _root: Container;
                 _parent: Container;
                 _resolver: ModuleResolverBase;
                 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) {
                     const 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() as T;
                     const context = new ActivationContext(this, this._services);
                     try {
                         return d.activate(context, name) as T;
                     } catch (error) {
                         throw new ActivationError(name, context.getStack(), error);
                     }
                 }
                 register(nameOrCollection, service?) {
                     if (arguments.length === 1) {
                         const data = nameOrCollection;
                         for (const name in data)
                             this.register(name, data[name]);
                     } else {
                         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 (const f of this._cleanup)
                             f();
                         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: string | object, opts?: object) {
                     if (typeof (config) === "string") {
                         const resolver = await this._resolver.createResolver(config, opts);
                         const data = await this._resolver.loadModule(config);
                         return this._configure(data, { resolver });
                     } else {
                         return this._configure(config);
                     }
                 }
                 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: object, opts?: { resolver: ModuleResolverBase }) {
                     const resolver = (opts && opts.resolver) || this._resolver;
                     const services: ServiceMap = {};
                     resolver.beginBatch();
                     async function parse(k) {
                         services[k] = await this._parse(data[k], resolver);
                     }
                     const batch = Object.keys(data).map(parse);
                     resolver.completeBatch();
                     await Promise.all(batch);
                     this.register(services);
                 }
                 async _parse(registration: any, resolver: ModuleResolverBase) {
                     if (isPrimitive(registration) || isDescriptor(registration))
                         return registration;
                     if (isDependencyRegistration(registration)) {
                         return new ReferenceDescriptor(
                             registration.$dependency,
                             registration.lazy,
                             registration.optional,
                             registration["default"],
                             registration.services && this._parseObject(registration.services, resolver)
                         );
                     } else if (isValueRegistration(registration)) {
                         return !registration.parse ?
                             new ValueDescriptor(registration.$value) :
                             new AggregateDescriptor(this._parse(registration.$value, resolver));
                     } else if (registration.$type || registration.$factory) {
                         return this._parseService(registration, resolver);
                     } else if (registration instanceof Array) {
                         return this._parseArray(registration, resolver);
                     }
                     return this._parseObject(registration, resolver);
                 }
                 async _parseService(data: ServiceRegistration, resolver: ModuleResolverBase) {
                     const opts: ServiceDescriptorParams = {
                         owner: this
                     };
-                    function guard<T>(fn: () => PromiseLike<T>) {
-                        return fn();
                     if (data.$type) {
                         if (data.$type instanceof Function)
                             opts.type = data.$type;
                         else if (typeof data.$type === "string")
                             opts.type = await resolver.resolve(data.$type);
                         else
                             throw new Error(format("Unsupported type specification: {0:json}", data.$type));
                     } else {
                         if (data.$factory instanceof Function)
                             opts.factory = data.$factory;
                         else if (typeof data.$factory === "string")
                             opts.factory = await resolver.resolve(data.$factory);
                         else
                             throw new Error(format("Unsupported factory specification: {0:json}", data.$factory));
                     }
                     if (data.services)
                         opts.services = await this._parseObject(data.services, resolver);
                     if (data.inject instanceof Array)
                         opts.inject = await Promise.all(data.inject.map(x => this._parseObject(x, resolver)));
                     else
-                        opts.inject = this._parseObject(data.inject, resolver);
+                        opts.inject = [await this._parseObject(data.inject, resolver)];
                     if (data.params)
                         opts.params = this._parse(data.params, resolver);
                     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: any, typemap) {
+                _parseObject(data: object, resolver: ModuleResolverBase) {
                     if (data.constructor &&
                         data.constructor.prototype !== Object.prototype)
                         return new ValueDescriptor(data);
                     const o = {};
                     for (const p in data)
-                        o[p] = this._parse(data[p], typemap);
+                        o[p] = this._parse(data[p], resolver);
                     return o;
                 }
-                _parseArray(data, typemap) {
+                _parseArray(data: Array<any>, resolver: ModuleResolverBase) {
                     if (data.constructor &&
                         data.constructor.prototype !== Array.prototype)
                         return new ValueDescriptor(data);
-                    return data.map(x => this._parse(x, typemap));
+                    return data.map(x => this._parse(x, resolver));
                 }
             }

src/ts/di/ReferenceDescriptor.ts +35 -29

             import { isNull, argumentNotEmptyString, each } from "../safe";
             import { ActivationContext } from "./ActivationContext";
             import { ServiceMap, Descriptor } from "./interfaces";
             import { ActivationError } from "./ActivationError";
             export class ReferenceDescriptor implements Descriptor {
-                _name: string
+                _name: string;
-                _lazy = false
+                _lazy = false;
-                _optional = false
+                _optional = false;
-                _default: any
+                _default: any;
-                _services: ServiceMap
+                _services: ServiceMap;
                 constructor(name: string, lazy: boolean, optional: boolean, def, services: ServiceMap) {
                     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 (this._lazy) {
+                        // сохраняем контекст активации
+                        context = context.clone();
                         // добавляем сервисы
-                    if (me._services) {
+                        if (this._services) {
-                        for (var p in me._services) {
+                            for (const p of Object.keys(this._services))
-                            var sv = me._services[p];
+                                context.register(p, this._services[p]);
-                            context.register(p, sv);
                         }
-                    if (me._lazy) {
+                        return (cfg: ServiceMap) => {
-                        // сохраняем контекст активации
-                        context = context.clone();
-                        return function (cfg: ServiceMap) {
                             // защищаем контекст на случай исключения в процессе
                             // активации
-                            var ct = context.clone();
+                            const ct = context.clone();
                             try {
-                                if (cfg)
+                                if (cfg) {
-                                    for(let k in cfg)
+                                    for (const k in cfg)
-                                        ct.register(k, cfg[v]);
+                                        ct.register(k, cfg[k]);
+                                }
-                                return me._optional ? ct.getService(me._name, me._default) : ct
+                                return this._optional ? ct.getService(this._name, this._default) : ct
-                                    .getService(me._name);
+                                    .getService(this._name);
                             } catch (error) {
-                                throw new ActivationError(me._name, ct.getStack(), error);
+                                throw new ActivationError(this._name, ct.getStack(), error);
                             }
                         };
+                    } else {
+                        context.enter(name, this, !!this._services);
+                        // добавляем сервисы
+                        if (this._services) {
+                            for (const p of Object.keys(this._services))
+                                context.register(p, this._services[p]);
                         }
-                    var v = me._optional ?
+                        const v = this._optional ?
-                        context.getService(me._name, me._default) :
+                        context.getService(this._name, this._default) :
-                        context.getService(me._name);
+                        context.getService(this._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 = [];
+                    const opts = [];
                     if (this._optional)
                         opts.push("optional");
                     if (this._lazy)
                         opts.push("lazy");
-                    var parts = [
+                    const 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("");
                 }
-            }
  No newline at end of file

src/ts/di/ServiceDescriptor.ts +28 -20

             import { ActivationContext } from "./ActivationContext";
-            import { Descriptor, ActivationType, ServiceMap, Constructor, Factory } from "./interfaces";
+            import { Descriptor, ActivationType, ServiceMap } from "./interfaces";
             import { Container } from "./Container";
-            import { argumentNotNull, isPrimitive, oid } from "../safe";
+            import { argumentNotNull, isPrimitive, oid, isPromise } from "../safe";
-            import { ClientResponse } from "http";
+            import { Constructor, Factory } from "../interfaces";
             let cacheId = 0;
             function injectMethod(target, method, context, args) {
                 const m = target[method];
                 if (!m)
                     throw new Error("Method '" + method + "' not found");
                 if (args instanceof Array)
-                    m.apply(target, context.parse(args, "." + method));
+                    return m.apply(target, context.parse(args, "." + method));
                 else
-                    m.call(target, context.parse(args, "." + method));
+                    return m.call(target, context.parse(args, "." + method));
             }
-            function makeClenupCallback(target, method: (instance) => void | string) {
+            function makeClenupCallback(target, method: ((instance) => void) | string) {
                 if (typeof (method) === "string") {
                     return () => {
                         target[method]();
                     };
                 } else {
                     return () => {
                         method(target);
                     };
                 }
             }
-            export interface ServiceDescriptorParams<T = {}> {
+            export interface ServiceDescriptorParams {
                 activation?: ActivationType;
                 owner: Container;
-                type?: Constructor<T>;
+                type?: Constructor;
-                factory?: Factory<T>;
+                factory?: Factory;
                 params?;
-                inject?;
+                inject?: object[];
                 services?: ServiceMap;
-                cleanup?: (instance: T) => void | string;
+                cleanup?: ((x) => void) | string;
             }
-            export class ServiceDescriptor<T = {}> implements Descriptor {
+            export class ServiceDescriptor implements Descriptor {
-                _instance: T = null;
+                _instance;
                 _hasInstance = false;
                 _activationType = ActivationType.Call;
                 _services: ServiceMap;
-                _type: Constructor<T> = null;
+                _type: Constructor = null;
-                _factory: Factory<T> = null;
+                _factory: Factory = null;
                 _params;
-                _inject: Array<object>;
+                _inject: object[];
-                _cleanup: (instance: T) => void;
+                _cleanup: ((x) => void) | string;
                 _cacheId: any;
                 _owner: Container;
-                constructor(opts: ServiceDescriptorParams<T>) {
+                constructor(opts: ServiceDescriptorParams) {
                     argumentNotNull(opts, "opts");
                     argumentNotNull(opts.owner, "owner");
                     this._owner = opts.owner;
                     if (!(opts.type || opts.factory))
                         throw new Error(
                             "Either a type or a factory must be specified");
                     if (opts.activation)
                         this._activationType = opts.activation;
                     if (opts.type)
                         this._type = opts.type;
                     if (opts.params)
                         this._params = opts.params;
                     if (opts.inject)
-                        this._inject = opts.inject instanceof Array ? opts.inject : [opts.inject];
+                        this._inject = opts.inject;
                     if (opts.services)
                         this._services = opts.services;
                     if (opts.factory)
                         this._factory = opts.factory;
                     if (opts.cleanup) {
                         if (!(typeof (opts.cleanup) === "string" || opts.cleanup instanceof Function))
                             throw new Error(
                                 "The cleanup parameter must be either a function or a function name");
                         this._cleanup = opts.cleanup;
                     }
                     if (this._activationType === ActivationType.Singleton) {
                         const tof = this._type || this._factory;
                         // create the persistent cache identifier for the type
                         if (isPrimitive(tof))
                             this._cacheId = tof;
                         else
                             this._cacheId = oid(tof);
                     } else {
                         this._cacheId = ++cacheId;
                     }
                 }
                 activate(context: ActivationContext, name: string) {
                     // if we have a local service records, register them first
                     let instance;
                     switch (this._activationType) {
                         case ActivationType.Singleton: // SINGLETON
                             // if the value is cached return it
                             if (this._hasInstance)
                                 return this._instance;
                             // singletons are bound to the root container
                             const container = context.container.getRootContainer();
                             if (container.has(this._cacheId)) {
                                 instance = container.get(this._cacheId);
                             } else {
                                 instance = this._create(context, name);
                                 container.store(this._cacheId, instance);
                                 if (this._cleanup)
                                     container.onDispose(
                                         makeClenupCallback(instance, this._cleanup));
                             }
                             this._hasInstance = true;
                             return (this._instance = instance);
                         case ActivationType.Container: // CONTAINER
                             // return a cached value
                             if (this._hasInstance)
                                 return this._instance;
                             // create an instance
                             instance = this._create(context, name);
                             // the instance is bound to the container
                             if (this._cleanup)
                                 this._owner.onDispose(
                                     makeClenupCallback(instance, this._cleanup));
                             // cache and return the instance
                             this._hasInstance = true;
                             return (this._instance = instance);
                         case ActivationType.Context: // CONTEXT
                             // return a cached value if one exists
                             if (context.has(this._cacheId))
                                 return context.get(this._cacheId);
                             // context context activated instances are controlled by callers
                             return context.store(this._cacheId, this._create(
                                 context,
                                 name));
                         case ActivationType.Call: // CALL
                             // per-call created instances are controlled by callers
                             return this._create(context, name);
                         case ActivationType.Hierarchy: // HIERARCHY
                             // hierarchy activated instances are behave much like container activated
                             // except they are created and bound to the child container
                             // return a cached value
                             if (context.container.has(this._cacheId))
                                 return context.container.get(this._cacheId);
                             instance = this._create(context, name);
                             if (this._cleanup)
                                 context.container.onDispose(makeClenupCallback(
                                     instance,
                                     this._cleanup));
                             return context.container.store(this._cacheId, instance);
                         default:
                             throw new Error("Invalid activation type: " + this._activationType);
                     }
                 }
                 isInstanceCreated() {
                     return this._hasInstance;
                 }
                 getInstance() {
                     return this._instance;
                 }
                 _create(context, name) {
                     context.enter(name, this, Boolean(this._services));
                     if (this._activationType !== ActivationType.Call &&
                         context.visit(this._cacheId) > 0)
                         throw new Error("Recursion detected");
                     if (this._services) {
                         for (const p in this._services)
                             context.register(p, this._services[p]);
                     }
                     let instance;
                     if (!this._factory) {
                         const ctor = this._type;
+                        if (this._params && this._params.length) {
                             this._factory = (...args) => {
-                            return new ctor(...args);
+                                const t = Object.create(ctor.prototype);
+                                const inst = ctor.apply(t, args);
+                                return isPrimitive(inst) ? t : inst;
                             };
+                        } else {
+                            this._factory = () => {
+                                return new ctor();
+                            };
+                        }
                     }
                     if (this._params === undefined) {
                         instance = this._factory();
                     } else if (this._params instanceof Array) {
                         instance = this._factory.apply(this, context.parse(
                             this._params,
                             ".params"));
                     } else {
                         instance = this._factory(context.parse(
                             this._params,
                             ".params"));
                     }
                     if (this._inject) {
                         this._inject.forEach(spec => {
                             for (const m in spec)
                                 injectMethod(instance, m, context, spec[m]);
                         });
                     }
                     context.leave();
                     return instance;
                 }
                 // @constructor {singleton} foo/bar/Baz
                 // @factory {singleton}
                 toString() {
                     const parts = [];
                     parts.push(this._type ? "@constructor" : "@factory");
                     parts.push(ActivationType[this._activationType]);
                     if (typeof (this._type) === "string")
                         parts.push(this._type);
                     return parts.join(" ");
                 }
             }

src/ts/di/ValueDescriptor.ts +6 -6

             import { Descriptor } from "./interfaces";
             import { ActivationContext } from "./ActivationContext";
-            export class ValueDescriptor<T> implements Descriptor {
+            export class ValueDescriptor implements Descriptor {
-                _value: T
+                _value;
-                constructor(value: T) {
+                constructor(value) {
                     this._value = value;
                 }
                 activate(context: ActivationContext, name: string) {
                     context.enter(name);
-                    let v = this._value;
+                    const v = this._value;
                     context.leave();
                     return v;
                 }
                 isInstanceCreated(): boolean {
                     return true;
                 }
-                getInstance(): T {
+                getInstance() {
                     return this._value;
                 }
-            }
  No newline at end of file

src/ts/di/interfaces.ts +1 -4

             import { isNull } from "../safe";
             import { ActivationContext } from "./ActivationContext";
+            import { Constructor, Factory } from "../interfaces";
             export interface Descriptor {
                 activate(context: ActivationContext, name?: string);
                 isInstanceCreated(): boolean;
                 getInstance();
             }
-            export type Constructor<T = {}> = new (...args: any[]) => T;
-            export type Factory<T = {}> = (...args: any[]) => T;
             export function isDescriptor(instance): instance is Descriptor {
                 return (!isNull(instance)) &&
                     ("activate" in instance);
             }
             export interface ServiceMap {
                 [s: string]: Descriptor;
             }
             export enum ActivationType {
                 Singleton,
                 Container,
                 Hierarchy,
                 Context,
                 Call
             }
             export interface RegistrationWithServices {
                 services?: object;
             }
             export interface ServiceRegistration extends RegistrationWithServices {
                 $type?: string | Constructor;
                 $factory?: string | Factory;
                 activation?: "singleton" | "container" | "hierarchy" | "context" | "call";
                 params?;
                 inject?: object | object[];
                 cleanup: (instance) => void | string;
             }
             export interface ValueRegistration {
                 $value;
                 parse?: boolean;
             }
             export interface DependencyRegistration extends RegistrationWithServices {
                 $dependency: string;
                 lazy?: boolean;
                 optional?: boolean;
                 default?;
             }
             export function isServiceRegistration(x): x is ServiceRegistration {
                 return x && ("$type" in x || "$factory" in x);
             }
             export function isValueRegistration(x): x is ValueRegistration {
                 return x && "$value" in x;
             }
             export function isDependencyRegistration(x): x is DependencyRegistration {
                 return x && "$depdendency" in x;
             }

src/ts/interfaces.ts +5 -1

+            export type Constructor<T = {}> = new (...args: any[]) => T;
+            export type Factory<T = {}> = (...args: any[]) => T;
             export interface IDestroyable {
                 destroy();
             }
             export interface ICancellation {
                 throwIfRequested(): void;
                 isRequested(): boolean;
                 isSupported(): boolean;
                 register(cb: (e: any) => void): IDestroyable;
             }
             /**
              * Интерфейс поддерживающий асинхронную активацию
              */
             export interface IActivatable {
                 /**
                  * @returns Boolean indicates the current state
                  */
                 isActive(): boolean;
                 /**
                  * Starts the component activation
                  * @param ct cancellation token for this operation
                  */
                 activate(ct?: ICancellation): Promise<void>;
                 /**
                  * Starts the component deactivation
                  * @param ct cancellation token for this operation
                  */
                 deactivate(ct?: ICancellation): Promise<void>;
                 /**
                  * Sets the activation controller for this component
                  * @param controller The activation controller
                  *
                  * Activation controller checks whether this component
                  * can be activated and manages the active state of the
                  * component
                  */
                 setActivationController(controller: IActivationController);
                 /**
                  * Gets the current activation controller for this component
                  */
                 getActivationController(): IActivationController;
             }
             export interface IActivationController {
                 activating(component: IActivatable, ct?: ICancellation): Promise<void>;
                 activated(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivating(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivated(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivate(ct?: ICancellation): Promise<void>;
                 activate(component: IActivatable, ct?: ICancellation): Promise<void>;
                 getActive(): IActivatable;
             }
             export interface IAsyncComponent {
                 getCompletion(): Promise<void>;
             }
             export interface ICancellable {
                 cancel(reason?: any): void;
             }
             export interface IObservable<T> {
                 on(next: (x: T) => void, error?: (e: any) => void, complete?: () => void): IDestroyable;
                 next(ct?: ICancellation): Promise<T>;
-            }
  No newline at end of file

src/ts/safe.ts +17 -16

             let _nextOid = 0;
             const _oid = Symbol("__oid");
-            export function oid(instance: object) {
+            export function oid(instance: object): string {
                 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, 10) === arg;
             }
             export function isNumber(arg) {
                 return parseFloat(arg) === arg;
             }
             export function isString(val) {
                 return typeof (val) === "string" || val instanceof String;
             }
+            export function isPromise(val): val is PromiseLike<any> {
+                return "then" in val && val.then instanceof Function;
+            }
             export function isNullOrEmptyString(str) {
                 if (str === null || str === undefined ||
                     ((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");
                 if (obj instanceof Array) {
                     for (let i = 0; i < obj.length; i++) {
                         const x = cb.call(thisArg, obj[i], i);
                         if (x !== undefined)
                             return x;
                     }
                 } else {
                     const keys = Object.keys(obj);
                     for (const k of keys) {
                         const 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");
                 const _res = dest as T & S;
                 if (template instanceof Array) {
                     for (const p of template) {
                         if (p in source)
                             _res[p] = source[p];
                     }
                 } else if (template) {
                     const keys = Object.keys(source);
                     for (const p of keys) {
                         if (p in template)
                             _res[template[p]] = source[p];
                     }
                 } else {
                     const keys = Object.keys(source);
                     for (const p of keys)
                         _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))
                     fn = thisArg[fn];
                 if (fn == null)
                     throw new Error("The function must be specified");
                 function wrapresult(x, e?): PromiseLike<any> {
                     if (e) {
                         return {
                             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(cb) {
                                 try {
                                     return cb ? wrapresult(cb(x)) : this;
                                 } catch (e2) {
                                     return wrapresult(e2);
                                 }
                             }
                         };
                     }
                 }
                 return (...args) => {
                     try {
                         return wrapresult(fn.apply(thisArg, args));
                     } catch (e) {
                         return wrapresult(null, e);
                     }
                 };
             }
             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 (...args) => {
                     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 items.then(data => pmap(data, cb));
-                        return pmap(data, cb);
-                    });
                 if (isNull(items) || !items.length)
                     return items;
-                var i = 0,
+                let i = 0;
-                    result = [];
+                const result = [];
                 function next() {
-                    var r, ri;
+                    let r;
+                    let 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) {
+                        if (isPromise(r)) {
                             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) {
+            export function first(sequence, cb: (x) => any, err: (x) => any) {
                 if (sequence) {
-                    if (sequence.then instanceof Function) {
+                    if (isPromise(sequence)) {
-                        return sequence.then(function (res) {
+                        return sequence.then(res => first(res, cb, err));
-                            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) {
+            export function destroy(d) {
-                if (d && 'destroy' in d)
+                if (d && "destroy" in d)
                     d.destroy();
-            }
  No newline at end of file

test/js/plan.js +2 -2

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

test/ts/dummy.ts +6 -6

-            import * as tape from 'tape';
+            import * as tape from "tape";
-            import * as uuid from '@implab/core/Uuid';
+            import { Uuid } from "@implab/core/Uuid";
-            tape('simple', function(t){
+            tape("simple", t => {
                 t.pass("sync assert");
                 setTimeout(() => {
                     t.pass("async assert");
-                    t.comment(uuid());
+                    t.comment(Uuid());
-                    t.ok(uuid() != uuid());
+                    t.ok(Uuid() !== Uuid());
                     // end should be called after the last assertion
                     t.end();
                 }, 100);
-            });
  No newline at end of file
+            });

tsconfig.json +1 -1

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

tsconfig.test.json +2 -2

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

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