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 +12 -13

                         else
                             this._cbs.push(cb);
-                        let me = this;
+                        const me = this;
                         return {
-                    	destroy() {
+                            destroy() {
-                    	    me._unregister(cb);
+                                me._unregister(cb);
+                            }
                         };
                     }
                 }
                 private _unregister(cb) {
-            	if(this._cbs) {
+                    if (this._cbs) {
-            	    let i = this._cbs.indexOf(cb);
+                        const i = this._cbs.indexOf(cb);
-            	    if ( i>=0 )
+                        if (i >= 0)
-            		this._cbs.splice(i,1);
+                            this._cbs.splice(i, 1);
+                    }
                 }
                 private _cancel(reason) {
                     this._reason = (reason = reason || new Error("Operation cancelled"));
                     if (this._cbs) {
                         this._cbs.forEach(cb => cb(reason));
                         this._cbs = null;
                     },
                     register(_cb: (e: any) => void): IDestroyable {
-                	    return destroyed;
+                        return destroyed;
                     }
                 };
-            }
  No newline at end of file

src/ts/Observable.ts +31 -42

-            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 = () => {};
+            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)
                 /**
                  * 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,
                     this._addObserver(observer);
                     return 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 _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++)
+                    this._once = [];
-                            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 = [];
                 }
                 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

             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
             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;
                     // 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;
                             }
                         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()");
                     }
                 }
                 // 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) { /**/ }
                 }
             }
             // 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];
                     }
             // **`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++]];
             }
             // 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],
             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 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) {
                 // 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;
                 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;
                 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];
                 }
             // **`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;
                 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 +32 -38

             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");
                 }
                 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
                  */
                         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;
                 }
                     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
                     });
                 }
                 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";
                 }
                 toString() {
-                    var parts = [this.message];
+                    const parts = [this.message];
                     if (this.service)
                         parts.push("when activating: " + this.service.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) {
                 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

                         owner: this
                     };
-                    function guard<T>(fn: () => PromiseLike<T>) {
-                        return fn();
                     if (data.$type) {
                         if (data.$type instanceof Function)
                             opts.type = data.$type;
                     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);
                     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 +40 -34

             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");
                 }
                 activate(context: ActivationContext, name: string) {
-                    var me = this;
-                    context.enter(name, this, true);
+                    if (this._lazy) {
-                    // добавляем сервисы
-                    if (me._services) {
-                        for (var p in me._services) {
-                            var sv = me._services[p];
-                            context.register(p, sv);
-                    if (me._lazy) {
                         // сохраняем контекст активации
                         context = context.clone();
-                        return function (cfg: ServiceMap) {
+                        // добавляем сервисы
+                        if (this._services) {
+                            for (const p of Object.keys(this._services))
+                                context.register(p, this._services[p]);
+                        }
+                        return (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();
+                        context.leave();
-                    return v;
+                        return v;
+                    }
                 }
                 isInstanceCreated() {
                 }
                 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) {
                     return parts.join("");
                 }
-            }
  No newline at end of file

src/ts/di/ServiceDescriptor.ts +30 -22

             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;
                     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]();
                 }
             }
-            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;
                 _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._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 (!this._factory) {
                         const ctor = this._type;
-                        this._factory = (...args)  => {
+                        if (this._params && this._params.length) {
-                            return new ctor(...args);
+                            this._factory = (...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) {

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

             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);
                 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);

src/ts/interfaces.ts +10 -6

+            export type Constructor<T = {}> = new (...args: any[]) => T;
+            export type Factory<T = {}> = (...args: any[]) => T;
             export interface IDestroyable {
                 destroy();
             }
                  * Starts the component activation
                  * @param ct cancellation token for this operation
                  */
-                activate(ct?: ICancellation) : Promise<void>;
+                activate(ct?: ICancellation): Promise<void>;
                 /**
                  * Starts the component deactivation
                  * @param ct cancellation token for this operation
                  */
-                deactivate(ct?: ICancellation) : Promise<void>;
+                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
             }
             export interface IObservable<T> {
-                on(next: (x:T) => void, error?: (e:any) => void, complete?:() => void): IDestroyable;
+                on(next: (x: T) => void, error?: (e: any) => void, complete?: () => void): IDestroyable;
-                next(ct?: ICancellation) : Promise<T>;
+                next(ct?: ICancellation): Promise<T>;
-            }
  No newline at end of file

src/ts/safe.ts +20 -19

             let _nextOid = 0;
             const _oid = Symbol("__oid");
-            export function oid(instance: object) {
+            export function oid(instance: object): string {
                 if (isNull(instance))
                     return null;
                 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))
                 const _res = dest as T & S;
                 if (template instanceof Array) {
-                    for (const p  of template) {
+                    for (const p of template) {
                         if (p in source)
                             _res[p] = source[p];
                     }
                 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;
                         r = cb(items[i], i);
                         ri = i;
                         i++;
-                        if (r && r.then) {
+                        if (isPromise(r)) {
                             return r.then(chain);
                         } else {
                             result[ri] = r;
             /**
              * Выбирает первый элемент из последовательности, или обещания, если в
              * качестве параметра используется обещание, оно должно вернуть массив.
+             *
              * @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)
                     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",

tsconfig.test.json +2 -2

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

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