All Promise Utils functions from github.com/sindresorhus bundled together!

npm install p-fun --save

const p = require('p-fun')

/*
    That's it!, now you can call any of his functions :)
*/

p.delay(1000)
 .then(() => console.log('I waited 1000 milliseconds to send this message! :D'))

One important thing is that due to not all of the packages being legal variable names in JavaScript (for example the package p-map would be interpreted as p - map, like it would be a math equation)

Due to this, the keys in the object that represent the function will follow this naming convention:

1. If the module does not start with p-, it will be temporary be added to the module name, like this require('delay') -> require('p-delay')
2. p- will now be removed from the key name, due to the recommended varible the require('p-fun') being assigned to is p or P, like the example above!
3. If the module name has hyphens (-) in it, it will get removed, and the following character will be capitalized, like this require('do-whilst') -> require('doWhilst')
4. Now the module name will get added to the object that this module is exporting, for example like this:

   const p = {
       doWhilst: require('p-do-whilst')
   }

Returns an object with all the Promise util functions!

They will be mapped just like this:

• all -> require('p-all'): Run promise-returning & async functions concurrently with optional limited concurrency
• any -> require('p-any'): Wait for any promise to be fulfilled
• break -> require('p-break'): Break out of a promise chain
• cancelable -> require('p-cancelable'): Create a promise that can be canceled
• catchIf -> require('p-catch-if'): Conditional promise catch handler
• debounce -> require('p-debounce'): Debounce promise-returning & async functions
• defer -> require('p-defer'): Create a deferred promise
• delay -> require('delay'): Delay a promise a specified amount of time
• doWhilst -> require('p-do-whilst'): Calls a function repeatedly while a condition returns true and then resolves the promise
• eachSeries -> require('p-each-series'): Iterate over promises serially
• event -> require('p-event'): Promisify an event by waiting for it to be emitted
• every -> require('p-every'): Test whether all promises passes a testing function
• filter -> require('p-filter'): Filter promises concurrently
• finally -> require('p-finally'): Promise#finally() ponyfill - Invoked when the promise is settled regardless of outcome
• forever -> require('p-forever'): Run promise-returning & async functions repeatedly until you end it
• hardRejection -> require('hard-rejection'): Make unhandled promise rejections fail hard right away instead of the default silent fail
• if -> require('p-if'): Conditional promise chains
• immediate -> require('p-immediate'): Returns a promise resolved in the next event loop - think setImmediate()
• isPromise -> require('p-is-promise'): Check if something is a promise
• lazy -> require('p-lazy'): Create a lazy promise that defers execution until .then() or .catch() is called
• limit -> require('p-limit'): Run multiple promise-returning & async functions with limited concurrency
• locate -> require('p-locate'): Get the first fulfilled promise that satisfies the provided testing function
• log -> require('p-log'): Log the value/error of a promise
• loudRejection -> require('loud-rejection'): Make unhandled promise rejections fail loudly instead of the default silent fail
• map -> require('p-map'): Map over promises concurrently
• mapSeries -> require('p-map-series'): Map over promises serially
• memoize -> require('p-memoize'): Memoize promise-returning & async functions
• minDelay -> require('p-min-delay'): Delay a promise a minimum amount of time
• one -> require('p-one'): Test whether some promise passes a testing function
• pify -> require('pify'): Promisify a callback-style function
• pipe -> require('p-pipe'): Compose promise-returning & async functions into a reusable pipeline
• progress -> require('p-progress'): Create a promise that reports progress
• props -> require('p-props'): Like Promise.all() but for Map and Object
• queue -> require('p-queue'): Promise queue with concurrency control
• race -> require('p-race'): A better Promise.race()
• reduce -> require('p-reduce'): Reduce a list of values using promises into a promise for a value
• reflect -> require('p-reflect'): Make a promise always fulfill with its actual fulfillment value or rejection reason
• retry -> require('p-retry'): Retry a promise-returning or async function
• series -> require('p-series'): Run promise-returning & async functions in series
• settle -> require('p-settle'): Settle promises concurrently and get their fulfillment value or rejection reason
• some -> require('p-some'): Wait for a specified number of promises to be fulfilled
• tap -> require('p-tap'): Tap into a promise chain without affecting its value or state
• throttle -> require('p-throttle'): Throttle promise-returning & async functions
• time -> require('p-time'): Measure the time a promise takes to resolve
• timeout -> require('p-timeout'): Timeout a promise after a specified amount of time
• times -> require('p-times'): Run promise-returning & async functions a specific number of times concurrently
• try -> require('p-try'): Promise#try() ponyfill - Starts a promise chain
• waitFor -> require('p-wait-for'): Wait for a condition to be true
• waterfall -> require('p-waterfall'): Run promise-returning & async functions in series, each passing its result to the next
• whilst -> require('p-whilst'): Calls a function repeatedly while a condition returns true and then resolves the promise

MIT