villa/bld/es5/node/awaitable.js

Promise utilities for async/await-ready environment.

"use strict";
// tslint:disable:unified-signatures
Object.defineProperty(exports, "__esModule", { value: true });
var EventEmitterConstructor = safeRequire('events').EventEmitter;
var ChildProcessConstructor = safeRequire('child_process').ChildProcess;
var _a = safeRequire('stream'), ReadableConstructor = _a.Readable, WritableConstructor = _a.Writable;
var awaitable_1 = require("../awaitable");
function getEventEmitterAwaitableOptions(emitter) {
    if (ChildProcessConstructor && emitter instanceof ChildProcessConstructor) {
        return {
            types: ['exit'],
            assertion: function (code) {
                if (code !== 0) {
                    throw new Error("Invalid exit code " + code);
                }
            },
        };
    }
    else if ((ReadableConstructor && emitter instanceof ReadableConstructor) ||
        (WritableConstructor && emitter instanceof WritableConstructor)) {
        return {
            types: ['close'],
        };
    }
    else {
        throw new Error('Missing event types');
    }
}
function eventEmitterAwaitableCreator(emitter, types, assertion, errorEmitters) {
    if (assertion === void 0) { assertion = []; }
    if (!(emitter instanceof EventEmitterConstructor)) {
        return undefined;
    }
    if (typeof types === 'string' || isStringArray(types)) {
        if (typeof types === 'string') {
            types = [types];
        }
        if (Array.isArray(assertion)) {
            errorEmitters = assertion;
            // TODO: possibly a bug of TypeScript 2.2, adding ! temporarily.
            assertion = undefined;
        }
    }
    else {
        errorEmitters = types;
        var options = getEventEmitterAwaitableOptions(emitter);
        types = options.types;
        // TODO: possibly a bug of TypeScript 2.2, adding ! temporarily.
        assertion = options.assertion;
    }
    if (!errorEmitters) {
        errorEmitters = [];
    }
    errorEmitters.unshift(emitter);
    var promise = new Promise(function (resolve, reject) {
        for (var _i = 0, _a = types; _i < _a.length; _i++) {
            var type = _a[_i];
            emitter.on(type, onsuccess);
        }
        for (var _b = 0, _c = errorEmitters; _b < _c.length; _b++) {
            var emitter_1 = _c[_b];
            emitter_1.on('error', onerror);
        }
        function removeListeners() {
            for (var _i = 0, _a = types; _i < _a.length; _i++) {
                var type = _a[_i];
                emitter.removeListener(type, onsuccess);
            }
            for (var _b = 0, _c = errorEmitters; _b < _c.length; _b++) {
                var emitter_2 = _c[_b];
                emitter_2.removeListener('error', onerror);
            }
        }
        function onsuccess(value) {
            removeListeners();
            resolve(value);
        }
        function onerror(error) {
            setImmediate(removeListeners);
            reject(error);
        }
    });
    if (assertion) {
        promise = promise.then(assertion);
    }
    return promise;
}
/* istanbul ignore else */
if (EventEmitterConstructor) {
    awaitable_1.awaitableCreators.push(eventEmitterAwaitableCreator);
}
function safeRequire(id) {
    try {
        return require(id);
    }
    catch (error) {
        /* istanbul ignore next */
        return {};
    }
}
function isStringArray(object) {
    return Array.isArray(object) && typeof object[0] === 'string';
}
//# sourceMappingURL=awaitable.js.map