"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});
var S = require("./index");

var createdPromise;

/**
 * @module promises
 */

/**
 * Creates a callback that resolve or reject a promise
 * according to the default callback convention in node: (err, result)
 *
 * @param {Function} resolve resolve function of the promise
 * @param {Function} reject reject function of the promise
 * @return {Function}
 */
var resolveFromCallback = function resolveFromCallback(resolve, reject) {
    return function (err, result) {
        if (err) {
            return reject(err);
        }
        resolve(result);
    };
};

exports.resolveFromCallback = resolveFromCallback;
/**
 * Returns a promise
 *
 * The first argument is a callback with a done function
 *
 * @example
 * S.promiseCallback((done) => {
 *     fs.readFile('./myFile.txt', done);
 * }).then((txtContentBuffer) => {
 *     console.log(txtContentBuffer.toString());
 * });
 *
 * @param {Function} callback callback((done) => {})
 * @return {Promise}
 */
var promiseCallback = function promiseCallback(callback) {
    var resolveCallback, rejectCallback;
    var createdPromise = new Promise(function (resolve, reject) {
        resolveCallback = resolve;
        rejectCallback = reject;
    });
    var doneCallback = resolveFromCallback(resolveCallback, rejectCallback);
    callback(doneCallback);
    return createdPromise;
};

exports.promiseCallback = promiseCallback;
/**
 * Returns an array with two values : the promise and the callback to call
 *
 * @deprecated Prefer use of S.promiseCallback()
 *
 * @example
 * var [promise, doneCallback] = promises.creator();
 * fs.readFile('./myFile.txt', doneCallback);
 * promise.then((txtContentBuffer) => {
 * 	   console.log(txtContentBuffer.toString());
 * });
 *
 * @return {Array}
 */
var creator = function creator() {
    var resolveCallback, rejectCallback;
    var createdPromise = new Promise(function (resolve, reject) {
        resolveCallback = resolve;
        rejectCallback = reject;
    });
    var doneCallback = resolveFromCallback(resolveCallback, rejectCallback);
    return [createdPromise, doneCallback];
};

exports.creator = creator;
/**
 * Returns a callback that resolve or reject the created promise that you can get with {promises}
 *
 * @deprecated Prefer use of S.promiseCallback()
 *
 * @return {Function} callback(err, result)
 */
var done = function done() {
    var resolveCallback, rejectCallback;
    createdPromise = new Promise(function (resolve, reject) {
        resolveCallback = resolve;
        rejectCallback = reject;
    });
    return resolveFromCallback(resolveCallback, rejectCallback);
};

exports.done = done;
/**
* Returns the Promise created by the previously called method done()
*
* @deprecated Prefer use of S.promiseCallback()
*
* @example
* promises.promise(callback(promises.done()));
*
* @return {Promise}
*/
var promise = function promise() {
    if (!createdPromise) {
        throw new Error("No promise in stack, done() should be called before");
    }
    var p = createdPromise;
    createdPromise = undefined;
    return p;
};

exports.promise = promise;
/**
 * Execute promises in parallel
 *
 * @param {Array|Object|Map|Set} iterable an iterable with .map method (like Array), or an key/value object
 * @param {Function} callback callback(value, index) called for each values
 * @return {Promise}
 */
var forEach = function forEach(iterable, callback) {
    if (Array.isArray(iterable)) {
        return Promise.all(iterable.map(callback));
    }
    var keys = [],
        values = [];
    S.forEach(S.map(iterable, callback), function (value, index) {
        keys.push(index);
        values.push(value);
    });

    return Promise.all(values).then(function (results) {
        return S.map(iterable, function (value, index) {
            return results[keys.indexOf(index)];
        });
    });
};

exports.forEach = forEach;
/**
 * Execute promises in series
 *
 * @param {Array|Object} iterable an iterable with .map method (like Array), or an key/value object
 * @param {Function} callback callback(value, index) called for each values
 * @return {Promise}
 */
var forEachSeries = function forEachSeries(iterable, callback) {
    return new Promise(function (resolve, reject) {
        var entriesIterator = S.entries(iterable);
        var results = new iterable.constructor();
        (function next() {
            var current = entriesIterator.next();
            if (current.done) {
                return resolve(results);
            }
            var key = current.value[0],
                value = current.value[1];
            var result = callback(value, key);
            if (result && typeof result.then === "function") {
                result.then(function (result) {
                    results[key] = result;
                    next();
                })["catch"](reject);
            } else {
                results[key] = result;
                setImmediate(next);
            }
        })();
    });
};

exports.forEachSeries = forEachSeries;
/**
 * Execute the second callback wile the first callback is true
 *
 * @param {Function} iterable an iterable with .map method (like Array), or an key/value object
 * @param {Function} callback callback(value, index) called for each values
 * @return {Promise}
 */
var whileTrue = function whileTrue(conditionCallback, callback) {
    return new Promise(function (resolve, reject) {
        (function next() {
            if (!conditionCallback()) {
                return resolve();
            }
            var result = callback();
            if (result && typeof result.then === "function") {
                result.then(function () {
                    setImmediate(next);
                })["catch"](reject);
            } else {
                setImmediate(next);
            }
        })();
    });
};

exports.whileTrue = whileTrue;
/**
 * Returns a promise
 *
 * The first argument is a callback with a done function
 *
 * @example
 * S.promiseCallback((done) => {
 *     fs.readFile('./myFile.txt', done);
 * }).then((txtContentBuffer) => {
 *     console.log(txtContentBuffer.toString());
 * });
 *
 * @function module:utils.promiseCallback
 * @param {Function} callback callback((done) => {})
 * @return {Promise}
 */
S.promiseCallback = promiseCallback;
//# sourceMappingURL=promises.js.map