until.js

import whilst from './whilst.js'
import wrapAsync from './internal/wrapAsync.js'

/**
 * Repeatedly call `iteratee` until `test` returns `true`. Calls `callback` when
 * stopped, or an error occurs. `callback` will be passed an error and any
 * arguments passed to the final `iteratee`'s callback.
 *
 * The inverse of [whilst]{@link module:ControlFlow.whilst}.
 *
 * @name until
 * @static
 * @memberOf module:ControlFlow
 * @method
 * @see [async.whilst]{@link module:ControlFlow.whilst}
 * @category Control Flow
 * @param {AsyncFunction} test - asynchronous truth test to perform before each
 * execution of `iteratee`. Invoked with (callback).
 * @param {AsyncFunction} iteratee - An async function which is called each time
 * `test` fails. Invoked with (callback).
 * @param {Function} [callback] - A callback which is called after the test
 * function has passed and repeated execution of `iteratee` has stopped. `callback`
 * will be passed an error and any arguments passed to the final `iteratee`'s
 * callback. Invoked with (err, [results]);
 * @returns {Promise} a promise, if a callback is not passed
 *
 * @example
 * const results = []
 * let finished = false
 * async.until(function test(cb) {
 * cb(null, finished)
 * }, function iter(next) {
 * fetchPage(url, (err, body) => {
 * if (err) return next(err)
 * results = results.concat(body.objects)
 * finished = !!body.next
 * next(err)
 * })
 * }, function done (err) {
 * // all pages have been fetched
 * })
 */
export default function until(test, iteratee, callback) {
    const _test = wrapAsync(test)
    return whilst((cb) => _test((err, truth) => cb (err, !truth)), iteratee, callback);
}