Merge pull request #1 from megawac/docs-jsdocs

Genetate import path using jsdoc plugin

lib/apply.js

@@ -1,9 +1,6 @@
 import rest from 'lodash/rest';
 
 /**
- * ```
- * import apply from 'async/apply'
- * ```
  * Creates a continuation function with some arguments already applied.
  *
  * Useful as a shorthand when combined with other control flow functions. Any

lib/applyEach.js

@@ -2,9 +2,6 @@ import applyEach from './internal/applyEach';
 import map from './map';
 
 /**
- * ```
- * import applyEach from 'async/applyEach'
- * ```
  * Applies the provided arguments to each function in the array, calling
  * `callback` after all functions have completed. If you only provide the first
  * argument, then it will return a function which lets you pass in the

lib/applyEachSeries.js

@@ -2,9 +2,6 @@ import applyEach from './internal/applyEach';
 import mapSeries from './mapSeries';
 
 /**
- * ```
- * import applyEachSeries from 'async/applyEachSeries'
- * ```
  * The same as [`applyEach`]{@link module:ControlFlow.applyEach} but runs only a single async operation at a time.
  *
  * @name applyEachSeries

lib/asyncify.js

@@ -2,9 +2,6 @@ import isObject from 'lodash/isObject';
 import initialParams from './internal/initialParams';
 
 /**
- * ```
- * import asyncify from 'async/asyncify'
- * ```
  * Take a sync function and make it async, passing its return value to a
  * callback. This is useful for plugging sync functions into a waterfall,
  * series, or other async functions. Any arguments passed to the generated

lib/auto.js

@@ -10,9 +10,6 @@ import rest from 'lodash/rest';
 import onlyOnce from './internal/onlyOnce';
 
 /**
- * ```
- * import auto from 'async/auto'
- * ```
  * Determines the best order for running the functions in `tasks`, based on
  * their requirements. Each function can optionally depend on other functions
  * being completed first, and each function is run as soon as its requirements

lib/autoInject.js

@@ -12,9 +12,6 @@ function parseParams(func) {
 }
 
 /**
- * ```
- * import autoInject from 'async/autoInject'
- * ```
  * A dependency-injected version of the [async.auto]{@link module:ControlFlow.auto} function. Dependent
  * tasks are specified as parameters to the function, after the usual callback
  * parameter, with the parameter names matching the names of the tasks it

lib/cargo.js

@@ -31,9 +31,6 @@ import queue from './internal/queue';
  */
 
 /**
- * ```
- * import cargo from 'async/cargo'
- * ```
  * Creates a `cargo` object with the specified payload. Tasks added to the
  * cargo will be processed altogether (up to the `payload` limit). If the
  * `worker` is in progress, the task is queued until it becomes available. Once

lib/compose.js

@@ -3,9 +3,6 @@ import seq from './seq';
 var reverse = Array.prototype.reverse;
 
 /**
- * ```
- * import compose from 'async/compose'
- * ```
  * Creates a function which is a composition of the passed asynchronous
  * functions. Each function consumes the return value of the function that
  * follows. Composing functions `f()`, `g()`, and `h()` would produce the result

lib/concat.js

@@ -2,9 +2,6 @@ import concat from './internal/concat';
 import doParallel from './internal/doParallel';
 
 /**
- * ```
- * import concat from 'async/concat'
- * ```
  * Applies `iteratee` to each item in `coll`, concatenating the results. Returns
  * the concatenated list. The `iteratee`s are called in parallel, and the
  * results are concatenated as they return. There is no guarantee that the

lib/concatSeries.js

@@ -2,9 +2,6 @@ import concat from './internal/concat';
 import doSeries from './internal/doSeries';
 
 /**
- * ```
- * import concatSeries from 'async/concatSeries'
- * ```
  * The same as [`concat`]{@link module:Collections.concat} but runs only a single async operation at a time.
  *
  * @name concatSeries

lib/constant.js

@@ -2,9 +2,6 @@ import rest from 'lodash/rest';
 import initialParams from './internal/initialParams';
 
 /**
- * ```
- * import constant from 'async/constant'
- * ```
  * Returns a function that when called, calls-back with the values provided.
  * Useful as the first function in a [`waterfall`]{@link module:ControlFlow.waterfall}, or for plugging values in to
  * [`auto`]{@link module:ControlFlow.auto}.

lib/detect.js

@@ -5,9 +5,6 @@ import eachOf from './eachOf';
 import findGetResult from './internal/findGetResult';
 
 /**
- * ```
- * import detect from 'async/detect'
- * ```
  * Returns the first value in `coll` that passes an async truth test. The
  * `iteratee` is applied in parallel, meaning the first iteratee to return
  * `true` will fire the detect `callback` with that result. That means the

lib/detectLimit.js

@@ -5,9 +5,6 @@ import eachOfLimit from './eachOfLimit';
 import findGetResult from './internal/findGetResult';
 
 /**
- * ```
- * import detectLimit from 'async/detectLimit'
- * ```
  * The same as [`detect`]{@link module:Collections.detect} but runs a maximum of `limit` async operations at a
  * time.
  *

lib/detectSeries.js

@@ -5,9 +5,6 @@ import eachOfSeries from './eachOfSeries';
 import findGetResult from './internal/findGetResult';
 
 /**
- * ```
- * import detectSeries from 'async/detectSeries'
- * ```
  * The same as [`detect`]{@link module:Collections.detect} but runs only a single async operation at a time.
  *
  * @name detectSeries

lib/dir.js

@@ -1,9 +1,6 @@
 import consoleFunc from './internal/consoleFunc';
 
 /**
- * ```
- * import dir from 'async/dir'
- * ```
  * Logs the result of an `async` function to the `console` using `console.dir`
  * to display the properties of the resulting object. Only works in Node.js or
  * in browsers that support `console.dir` and `console.error` (such as FF and

lib/doDuring.js

@@ -1,9 +1,6 @@
 import during from './during';
 
 /**
- * ```
- * import doDuring from 'async/doDuring'
- * ```
  * The post-check version of [`during`]{@link module:ControlFlow.during}. To reflect the difference in
  * the order of operations, the arguments `test` and `fn` are switched.
  *

lib/doUntil.js

@@ -1,9 +1,6 @@
 import doWhilst from './doWhilst';
 
 /**
- * ```
- * import doUtil from 'async/doUtil'
- * ```
  * Like ['doWhilst']{@link module:ControlFlow.doWhilst}, except the `test` is inverted. Note the
  * argument ordering differs from `until`.
  *

lib/doWhilst.js

@@ -1,9 +1,6 @@
 import whilst from './whilst';
 
 /**
- * ```
- * import doWhilst from 'async/doWhilst'
- * ```
  * The post-check version of [`whilst`]{@link module:ControlFlow.whilst}. To reflect the difference in
  * the order of operations, the arguments `test` and `fn` are switched.
  *

lib/during.js

@@ -2,9 +2,6 @@ import noop from 'lodash/noop';
 import rest from 'lodash/rest';
 
 /**
- * ```
- * import during from 'async/during'
- * ```
  * Like [`whilst`]{@link module:ControlFlow.whilst}, except the `test` is an asynchronous function that
  * is passed a callback in the form of `function (err, truth)`. If error is
  * passed to `test` or `fn`, the main callback is immediately called with the

lib/each.js

@@ -2,9 +2,6 @@ import eachLimit from './eachLimit';
 import doLimit from './internal/doLimit';
 
 /**
- * ```
- * import each from 'async/each'
- * ```
  * Applies the function `iteratee` to each item in `coll`, in parallel.
  * The `iteratee` is called with an item from the list, and a callback for when
  * it has finished. If the `iteratee` passes an error to its `callback`, the

lib/eachLimit.js

@@ -2,9 +2,6 @@ import eachOfLimit from './internal/eachOfLimit';
 import withoutIndex from './internal/withoutIndex';
 
 /**
- * ```
- * import eachLimit from 'async/eachLimit'
- * ```
  * The same as [`each`]{@link module:Collections.each} but runs a maximum of `limit` async operations at a time.
  *
  * @name eachLimit

lib/eachOf.js

@@ -2,9 +2,6 @@ import eachOfLimit from './eachOfLimit';
 import doLimit from './internal/doLimit';
 
 /**
- * ```
- * import eachOf from 'async/eachOf'
- * ```
  * Like [`each`]{@link module:Collections.each}, except that it passes the key (or index) as the second argument
  * to the iteratee.
  *

lib/eachOfLimit.js

@@ -1,9 +1,6 @@
 import _eachOfLimit from './internal/eachOfLimit';
 
 /**
- * ```
- * import eachOfLimit from 'async/eachOfLimit'
- * ```
  * The same as [`eachOf`]{@link module:Collections.eachOf} but runs a maximum of `limit` async operations at a
  * time.
  *

lib/eachOfSeries.js

@@ -2,9 +2,6 @@ import eachOfLimit from './eachOfLimit';
 import doLimit from './internal/doLimit';
 
 /**
- * ```
- * import eachOfSeries from 'async/eachOfSeries'
- * ```
  * The same as [`eachOf`]{@link module:Collections.eachOf} but runs only a single async operation at a time.
  *
  * @name eachOfSeries

lib/eachSeries.js

@@ -2,9 +2,6 @@ import eachLimit from './eachLimit';
 import doLimit from './internal/doLimit';
 
 /**
- * ```
- * import eachSeries from 'async/eachSeries'
- * ```
  * The same as [`each`]{@link module:Collections.each} but runs only a single async operation at a time.
  *
  * @name eachSeries

lib/ensureAsync.js

@@ -2,9 +2,6 @@ import setImmediate from './internal/setImmediate';
 import initialParams from './internal/initialParams';
 
 /**
- * ```
- * import ensureAsync from 'async/ensureAsync'
- * ```
  * Wrap an async function and ensure it calls its callback on a later tick of
  * the event loop.  If the function already calls its callback on a next tick,
  * no extra deferral is added. This is useful for preventing stack overflows

lib/every.js

@@ -2,9 +2,6 @@ import everyLimit from './everyLimit';
 import doLimit from './internal/doLimit';
 
 /**
- * ```
- * import every from 'async/every'
- * ```
  * Returns `true` if every element in `coll` satisfies an async test. If any
  * iteratee call returns `false`, the main `callback` is immediately called.
  *

lib/everyLimit.js

@@ -3,9 +3,6 @@ import eachOfLimit from './eachOfLimit';
 import notId from './internal/notId';
 
 /**
- * ```
- * import everyLimit from 'async/everyLimit'
- * ```
  * The same as [`every`]{@link module:Collections.every} but runs a maximum of `limit` async operations at a time.
  *
  * @name everyLimit

lib/everySeries.js

@@ -2,9 +2,6 @@ import everyLimit from './everyLimit';
 import doLimit from './internal/doLimit';
 
 /**
- * ```
- * import everySeries from 'async/everySeries'
- * ```
  * The same as [`every`]{@link module:Collections.every} but runs only a single async operation at a time.
  *
  * @name everySeries

lib/filter.js

@@ -2,9 +2,6 @@ import filterLimit from './filterLimit';
 import doLimit from './internal/doLimit';
 
 /**
- * ```
- * import filter from 'async/filter'
- * ```
  * Returns a new array of all the values in `coll` which pass an async truth
  * test. This operation is performed in parallel, but the results array will be
  * in the same order as the original.

lib/filterLimit.js

@@ -2,9 +2,6 @@ import filter from './internal/filter';
 import doParallelLimit from './internal/doParallelLimit';
 
 /**
- * ```
- * import filterLimit from 'async/filterLimit'
- * ```
  * The same as [`filter`]{@link module:Collections.filter} but runs a maximum of `limit` async operations at a
  * time.
  *

lib/filterSeries.js

@@ -2,9 +2,6 @@ import filterLimit from './filterLimit';
 import doLimit from './internal/doLimit';
 
 /**
- * ```
- * import filterSeries from 'async/filterSeries'
- * ```
  * The same as [`filter`]{@link module:Collections.filter} but runs only a single async operation at a time.
  *
  * @name filterSeries

lib/forever.js

@@ -4,9 +4,6 @@ import onlyOnce from './internal/onlyOnce';
 import ensureAsync from './ensureAsync';
 
 /**
- * ```
- * import forever from 'async/forever'
- * ```
  * Calls the asynchronous function `fn` with a callback parameter that allows it
  * to call itself again, in series, indefinitely.
 

lib/iterator.js

@@ -1,7 +1,4 @@
 /**
- * ```
- * import iterator from 'async/iterator'
- * ```
  * Creates an iterator function which calls the next function in the `tasks`
  * array, returning a continuation to call the next one after that. It's also
  * possible to “peek” at the next iterator with `iterator.next()`.

lib/log.js

@@ -1,9 +1,6 @@
 import consoleFunc from './internal/consoleFunc';
 
 /**
- * ```
- * import log from 'async/log'
- * ```
  * Logs the result of an `async` function to the `console`. Only works in
  * Node.js or in browsers that support `console.log` and `console.error` (such
  * as FF and Chrome). If multiple arguments are returned from the async

lib/map.js

@@ -2,9 +2,6 @@ import mapLimit from './mapLimit';
 import doLimit from './internal/doLimit';
 
 /**
- * ```
- * import map from 'async/map'
- * ```
  * Produces a new collection of values by mapping each value in `coll` through
  * the `iteratee` function. The `iteratee` is called with an item from `coll`
  * and a callback for when it has finished processing. Each of these callback

lib/mapLimit.js

@@ -2,9 +2,6 @@ import doParallelLimit from './internal/doParallelLimit';
 import map from './internal/map';
 
 /**
- * ```
- * import mapLimit from 'async/mapLimit'
- * ```
  * The same as [`map`]{@link module:Collections.map} but runs a maximum of `limit` async operations at a time.
  *
  * @name mapLimit

lib/mapSeries.js

@@ -2,9 +2,6 @@ import mapLimit from './mapLimit';
 import doLimit from './internal/doLimit';
 
 /**
- * ```
- * import mapSeries from 'async/mapSeries'
- * ```
  * The same as [`map`]{@link module:Collections.map} but runs only a single async operation at a time.
  *
  * @name mapSeries

lib/mapValues.js

@@ -3,9 +3,6 @@ import doLimit from './internal/doLimit';
 
 
 /**
- * ```
- * import mapValues from 'async/mapValues'
- * ```
  * A relative of [`map`]{@link module:Collections.map}, designed for use with objects.
  *
  * Produces a new Object by mapping each value of `obj` through the `iteratee`

lib/mapValuesLimit.js

@@ -1,9 +1,6 @@
 import eachOfLimit from './eachOfLimit';
 
 /**
- * ```
- * import mapValuesLimit from 'async/mapValuesLimit'
- * ```
  * The same as [`mapValues`]{@link module:Collections.mapValues} but runs a maximum of `limit` async operations at a
  * time.
  *