'use strict';

var eachOf = require('../../_virtual/eachOf.js');
var isArrayLike = require('./internal/isArrayLike.js');
var breakLoop = require('./internal/breakLoop.js');
var eachOfLimit = require('./eachOfLimit.js');
var once = require('./internal/once.js');
var onlyOnce = require('./internal/onlyOnce.js');
var wrapAsync = require('./internal/wrapAsync.js');
var awaitify = require('./internal/awaitify.js');

(function (module, exports) {

	Object.defineProperty(exports, "__esModule", {
	    value: true
	});

	var _isArrayLike = isArrayLike.isArrayLikeExports;

	var _isArrayLike2 = _interopRequireDefault(_isArrayLike);

	var _breakLoop = breakLoop.breakLoopExports;

	var _breakLoop2 = _interopRequireDefault(_breakLoop);

	var _eachOfLimit = eachOfLimit.eachOfLimitExports;

	var _eachOfLimit2 = _interopRequireDefault(_eachOfLimit);

	var _once = once.onceExports;

	var _once2 = _interopRequireDefault(_once);

	var _onlyOnce = onlyOnce.onlyOnceExports;

	var _onlyOnce2 = _interopRequireDefault(_onlyOnce);

	var _wrapAsync = wrapAsync.__require();

	var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

	var _awaitify = awaitify.awaitifyExports;

	var _awaitify2 = _interopRequireDefault(_awaitify);

	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

	// eachOf implementation optimized for array-likes
	function eachOfArrayLike(coll, iteratee, callback) {
	    callback = (0, _once2.default)(callback);
	    var index = 0,
	        completed = 0,
	        { length } = coll,
	        canceled = false;
	    if (length === 0) {
	        callback(null);
	    }

	    function iteratorCallback(err, value) {
	        if (err === false) {
	            canceled = true;
	        }
	        if (canceled === true) return;
	        if (err) {
	            callback(err);
	        } else if (++completed === length || value === _breakLoop2.default) {
	            callback(null);
	        }
	    }

	    for (; index < length; index++) {
	        iteratee(coll[index], index, (0, _onlyOnce2.default)(iteratorCallback));
	    }
	}

	// a generic version of eachOf which can handle array, object, and iterator cases.
	function eachOfGeneric(coll, iteratee, callback) {
	    return (0, _eachOfLimit2.default)(coll, Infinity, iteratee, callback);
	}

	/**
	 * Like [`each`]{@link module:Collections.each}, except that it passes the key (or index) as the second argument
	 * to the iteratee.
	 *
	 * @name eachOf
	 * @static
	 * @memberOf module:Collections
	 * @method
	 * @alias forEachOf
	 * @category Collection
	 * @see [async.each]{@link module:Collections.each}
	 * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
	 * @param {AsyncFunction} iteratee - A function to apply to each
	 * item in `coll`.
	 * The `key` is the item's key, or index in the case of an array.
	 * Invoked with (item, key, callback).
	 * @param {Function} [callback] - A callback which is called when all
	 * `iteratee` functions have finished, or an error occurs. Invoked with (err).
	 * @returns {Promise} a promise, if a callback is omitted
	 * @example
	 *
	 * // dev.json is a file containing a valid json object config for dev environment
	 * // dev.json is a file containing a valid json object config for test environment
	 * // prod.json is a file containing a valid json object config for prod environment
	 * // invalid.json is a file with a malformed json object
	 *
	 * let configs = {}; //global variable
	 * let validConfigFileMap = {dev: 'dev.json', test: 'test.json', prod: 'prod.json'};
	 * let invalidConfigFileMap = {dev: 'dev.json', test: 'test.json', invalid: 'invalid.json'};
	 *
	 * // asynchronous function that reads a json file and parses the contents as json object
	 * function parseFile(file, key, callback) {
	 *     fs.readFile(file, "utf8", function(err, data) {
	 *         if (err) return calback(err);
	 *         try {
	 *             configs[key] = JSON.parse(data);
	 *         } catch (e) {
	 *             return callback(e);
	 *         }
	 *         callback();
	 *     });
	 * }
	 *
	 * // Using callbacks
	 * async.forEachOf(validConfigFileMap, parseFile, function (err) {
	 *     if (err) {
	 *         console.error(err);
	 *     } else {
	 *         console.log(configs);
	 *         // configs is now a map of JSON data, e.g.
	 *         // { dev: //parsed dev.json, test: //parsed test.json, prod: //parsed prod.json}
	 *     }
	 * });
	 *
	 * //Error handing
	 * async.forEachOf(invalidConfigFileMap, parseFile, function (err) {
	 *     if (err) {
	 *         console.error(err);
	 *         // JSON parse error exception
	 *     } else {
	 *         console.log(configs);
	 *     }
	 * });
	 *
	 * // Using Promises
	 * async.forEachOf(validConfigFileMap, parseFile)
	 * .then( () => {
	 *     console.log(configs);
	 *     // configs is now a map of JSON data, e.g.
	 *     // { dev: //parsed dev.json, test: //parsed test.json, prod: //parsed prod.json}
	 * }).catch( err => {
	 *     console.error(err);
	 * });
	 *
	 * //Error handing
	 * async.forEachOf(invalidConfigFileMap, parseFile)
	 * .then( () => {
	 *     console.log(configs);
	 * }).catch( err => {
	 *     console.error(err);
	 *     // JSON parse error exception
	 * });
	 *
	 * // Using async/await
	 * async () => {
	 *     try {
	 *         let result = await async.forEachOf(validConfigFileMap, parseFile);
	 *         console.log(configs);
	 *         // configs is now a map of JSON data, e.g.
	 *         // { dev: //parsed dev.json, test: //parsed test.json, prod: //parsed prod.json}
	 *     }
	 *     catch (err) {
	 *         console.log(err);
	 *     }
	 * }
	 *
	 * //Error handing
	 * async () => {
	 *     try {
	 *         let result = await async.forEachOf(invalidConfigFileMap, parseFile);
	 *         console.log(configs);
	 *     }
	 *     catch (err) {
	 *         console.log(err);
	 *         // JSON parse error exception
	 *     }
	 * }
	 *
	 */
	function eachOf(coll, iteratee, callback) {
	    var eachOfImplementation = (0, _isArrayLike2.default)(coll) ? eachOfArrayLike : eachOfGeneric;
	    return eachOfImplementation(coll, (0, _wrapAsync2.default)(iteratee), callback);
	}

	exports.default = (0, _awaitify2.default)(eachOf, 3);
	module.exports = exports.default; 
} (eachOf.__module, eachOf.__module.exports));

var eachOfExports = eachOf.__module.exports;

exports.eachOfExports = eachOfExports;
