koa-classic-server 1.0.0 → 1.0.2

package/test/node_modules/async/forEachOf.js

@@ -1,185 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-
-var _isArrayLike = require('./internal/isArrayLike.js');
-
-var _isArrayLike2 = _interopRequireDefault(_isArrayLike);
-
-var _breakLoop = require('./internal/breakLoop.js');
-
-var _breakLoop2 = _interopRequireDefault(_breakLoop);
-
-var _eachOfLimit = require('./eachOfLimit.js');
-
-var _eachOfLimit2 = _interopRequireDefault(_eachOfLimit);
-
-var _once = require('./internal/once.js');
-
-var _once2 = _interopRequireDefault(_once);
-
-var _onlyOnce = require('./internal/onlyOnce.js');
-
-var _onlyOnce2 = _interopRequireDefault(_onlyOnce);
-
-var _wrapAsync = require('./internal/wrapAsync.js');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-var _awaitify = require('./internal/awaitify.js');
-
-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'];

package/test/node_modules/async/forEachOfLimit.js

@@ -1,47 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-var _eachOfLimit2 = require('./internal/eachOfLimit.js');
-
-var _eachOfLimit3 = _interopRequireDefault(_eachOfLimit2);
-
-var _wrapAsync = require('./internal/wrapAsync.js');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-var _awaitify = require('./internal/awaitify.js');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * The same as [`eachOf`]{@link module:Collections.eachOf} but runs a maximum of `limit` async operations at a
- * time.
- *
- * @name eachOfLimit
- * @static
- * @memberOf module:Collections
- * @method
- * @see [async.eachOf]{@link module:Collections.eachOf}
- * @alias forEachOfLimit
- * @category Collection
- * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
- * @param {number} limit - The maximum number of async operations at a time.
- * @param {AsyncFunction} iteratee - An async 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
- */
-function eachOfLimit(coll, limit, iteratee, callback) {
-  return (0, _eachOfLimit3.default)(limit)(coll, (0, _wrapAsync2.default)(iteratee), callback);
-}
-
-exports.default = (0, _awaitify2.default)(eachOfLimit, 4);
-module.exports = exports['default'];

package/test/node_modules/async/forEachOfSeries.js

@@ -1,39 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-var _eachOfLimit = require('./eachOfLimit.js');
-
-var _eachOfLimit2 = _interopRequireDefault(_eachOfLimit);
-
-var _awaitify = require('./internal/awaitify.js');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * The same as [`eachOf`]{@link module:Collections.eachOf} but runs only a single async operation at a time.
- *
- * @name eachOfSeries
- * @static
- * @memberOf module:Collections
- * @method
- * @see [async.eachOf]{@link module:Collections.eachOf}
- * @alias forEachOfSeries
- * @category Collection
- * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
- * @param {AsyncFunction} iteratee - An async function to apply to each item in
- * `coll`.
- * 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
- */
-function eachOfSeries(coll, iteratee, callback) {
-  return (0, _eachOfLimit2.default)(coll, 1, iteratee, callback);
-}
-exports.default = (0, _awaitify2.default)(eachOfSeries, 3);
-module.exports = exports['default'];

package/test/node_modules/async/forEachSeries.js

@@ -1,44 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-var _eachLimit = require('./eachLimit.js');
-
-var _eachLimit2 = _interopRequireDefault(_eachLimit);
-
-var _awaitify = require('./internal/awaitify.js');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * The same as [`each`]{@link module:Collections.each} but runs only a single async operation at a time.
- *
- * Note, that unlike [`each`]{@link module:Collections.each}, this function applies iteratee to each item
- * in series and therefore the iteratee functions will complete in order.
-
- * @name eachSeries
- * @static
- * @memberOf module:Collections
- * @method
- * @see [async.each]{@link module:Collections.each}
- * @alias forEachSeries
- * @category Collection
- * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
- * @param {AsyncFunction} iteratee - An async function to apply to each
- * item in `coll`.
- * The array index is not passed to the iteratee.
- * If you need the index, use `eachOfSeries`.
- * Invoked with (item, 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
- */
-function eachSeries(coll, iteratee, callback) {
-  return (0, _eachLimit2.default)(coll, 1, iteratee, callback);
-}
-exports.default = (0, _awaitify2.default)(eachSeries, 3);
-module.exports = exports['default'];

package/test/node_modules/async/forever.js

@@ -1,68 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-
-var _onlyOnce = require('./internal/onlyOnce.js');
-
-var _onlyOnce2 = _interopRequireDefault(_onlyOnce);
-
-var _ensureAsync = require('./ensureAsync.js');
-
-var _ensureAsync2 = _interopRequireDefault(_ensureAsync);
-
-var _wrapAsync = require('./internal/wrapAsync.js');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-var _awaitify = require('./internal/awaitify.js');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Calls the asynchronous function `fn` with a callback parameter that allows it
- * to call itself again, in series, indefinitely.
-
- * If an error is passed to the callback then `errback` is called with the
- * error, and execution stops, otherwise it will never be called.
- *
- * @name forever
- * @static
- * @memberOf module:ControlFlow
- * @method
- * @category Control Flow
- * @param {AsyncFunction} fn - an async function to call repeatedly.
- * Invoked with (next).
- * @param {Function} [errback] - when `fn` passes an error to it's callback,
- * this function will be called, and execution stops. Invoked with (err).
- * @returns {Promise} a promise that rejects if an error occurs and an errback
- * is not passed
- * @example
- *
- * async.forever(
- *     function(next) {
- *         // next is suitable for passing to things that need a callback(err [, whatever]);
- *         // it will result in this function being called again.
- *     },
- *     function(err) {
- *         // if next is called with a value in its first parameter, it will appear
- *         // in here as 'err', and execution will stop.
- *     }
- * );
- */
-function forever(fn, errback) {
-    var done = (0, _onlyOnce2.default)(errback);
-    var task = (0, _wrapAsync2.default)((0, _ensureAsync2.default)(fn));
-
-    function next(err) {
-        if (err) return done(err);
-        if (err === false) return;
-        task(next);
-    }
-    return next();
-}
-exports.default = (0, _awaitify2.default)(forever, 2);
-module.exports = exports['default'];

package/test/node_modules/async/groupBy.js

@@ -1,108 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = groupBy;
-
-var _groupByLimit = require('./groupByLimit.js');
-
-var _groupByLimit2 = _interopRequireDefault(_groupByLimit);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Returns a new object, where each value corresponds to an array of items, from
- * `coll`, that returned the corresponding key. That is, the keys of the object
- * correspond to the values passed to the `iteratee` callback.
- *
- * Note: Since this function applies the `iteratee` to each item in parallel,
- * there is no guarantee that the `iteratee` functions will complete in order.
- * However, the values for each key in the `result` will be in the same order as
- * the original `coll`. For Objects, the values will roughly be in the order of
- * the original Objects' keys (but this can vary across JavaScript engines).
- *
- * @name groupBy
- * @static
- * @memberOf module:Collections
- * @method
- * @category Collection
- * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
- * @param {AsyncFunction} iteratee - An async function to apply to each item in
- * `coll`.
- * The iteratee should complete with a `key` to group the value under.
- * Invoked with (value, callback).
- * @param {Function} [callback] - A callback which is called when all `iteratee`
- * functions have finished, or an error occurs. Result is an `Object` whoses
- * properties are arrays of values which returned the corresponding key.
- * @returns {Promise} a promise, if no callback is passed
- * @example
- *
- * // dir1 is a directory that contains file1.txt, file2.txt
- * // dir2 is a directory that contains file3.txt, file4.txt
- * // dir3 is a directory that contains file5.txt
- * // dir4 does not exist
- *
- * const files = ['dir1/file1.txt','dir2','dir4']
- *
- * // asynchronous function that detects file type as none, file, or directory
- * function detectFile(file, callback) {
- *     fs.stat(file, function(err, stat) {
- *         if (err) {
- *             return callback(null, 'none');
- *         }
- *         callback(null, stat.isDirectory() ? 'directory' : 'file');
- *     });
- * }
- *
- * //Using callbacks
- * async.groupBy(files, detectFile, function(err, result) {
- *     if(err) {
- *         console.log(err);
- *     } else {
- *	       console.log(result);
- *         // {
- *         //     file: [ 'dir1/file1.txt' ],
- *         //     none: [ 'dir4' ],
- *         //     directory: [ 'dir2']
- *         // }
- *         // result is object containing the files grouped by type
- *     }
- * });
- *
- * // Using Promises
- * async.groupBy(files, detectFile)
- * .then( result => {
- *     console.log(result);
- *     // {
- *     //     file: [ 'dir1/file1.txt' ],
- *     //     none: [ 'dir4' ],
- *     //     directory: [ 'dir2']
- *     // }
- *     // result is object containing the files grouped by type
- * }).catch( err => {
- *     console.log(err);
- * });
- *
- * // Using async/await
- * async () => {
- *     try {
- *         let result = await async.groupBy(files, detectFile);
- *         console.log(result);
- *         // {
- *         //     file: [ 'dir1/file1.txt' ],
- *         //     none: [ 'dir4' ],
- *         //     directory: [ 'dir2']
- *         // }
- *         // result is object containing the files grouped by type
- *     }
- *     catch (err) {
- *         console.log(err);
- *     }
- * }
- *
- */
-function groupBy(coll, iteratee, callback) {
-  return (0, _groupByLimit2.default)(coll, Infinity, iteratee, callback);
-}
-module.exports = exports['default'];

package/test/node_modules/async/groupByLimit.js

@@ -1,71 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-
-var _mapLimit = require('./mapLimit.js');
-
-var _mapLimit2 = _interopRequireDefault(_mapLimit);
-
-var _wrapAsync = require('./internal/wrapAsync.js');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-var _awaitify = require('./internal/awaitify.js');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * The same as [`groupBy`]{@link module:Collections.groupBy} but runs a maximum of `limit` async operations at a time.
- *
- * @name groupByLimit
- * @static
- * @memberOf module:Collections
- * @method
- * @see [async.groupBy]{@link module:Collections.groupBy}
- * @category Collection
- * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
- * @param {number} limit - The maximum number of async operations at a time.
- * @param {AsyncFunction} iteratee - An async function to apply to each item in
- * `coll`.
- * The iteratee should complete with a `key` to group the value under.
- * Invoked with (value, callback).
- * @param {Function} [callback] - A callback which is called when all `iteratee`
- * functions have finished, or an error occurs. Result is an `Object` whoses
- * properties are arrays of values which returned the corresponding key.
- * @returns {Promise} a promise, if no callback is passed
- */
-function groupByLimit(coll, limit, iteratee, callback) {
-    var _iteratee = (0, _wrapAsync2.default)(iteratee);
-    return (0, _mapLimit2.default)(coll, limit, (val, iterCb) => {
-        _iteratee(val, (err, key) => {
-            if (err) return iterCb(err);
-            return iterCb(err, { key, val });
-        });
-    }, (err, mapResults) => {
-        var result = {};
-        // from MDN, handle object having an `hasOwnProperty` prop
-        var { hasOwnProperty } = Object.prototype;
-
-        for (var i = 0; i < mapResults.length; i++) {
-            if (mapResults[i]) {
-                var { key } = mapResults[i];
-                var { val } = mapResults[i];
-
-                if (hasOwnProperty.call(result, key)) {
-                    result[key].push(val);
-                } else {
-                    result[key] = [val];
-                }
-            }
-        }
-
-        return callback(err, result);
-    });
-}
-
-exports.default = (0, _awaitify2.default)(groupByLimit, 4);
-module.exports = exports['default'];

package/test/node_modules/async/groupBySeries.js

@@ -1,36 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = groupBySeries;
-
-var _groupByLimit = require('./groupByLimit.js');
-
-var _groupByLimit2 = _interopRequireDefault(_groupByLimit);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * The same as [`groupBy`]{@link module:Collections.groupBy} but runs only a single async operation at a time.
- *
- * @name groupBySeries
- * @static
- * @memberOf module:Collections
- * @method
- * @see [async.groupBy]{@link module:Collections.groupBy}
- * @category Collection
- * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
- * @param {AsyncFunction} iteratee - An async function to apply to each item in
- * `coll`.
- * The iteratee should complete with a `key` to group the value under.
- * Invoked with (value, callback).
- * @param {Function} [callback] - A callback which is called when all `iteratee`
- * functions have finished, or an error occurs. Result is an `Object` whose
- * properties are arrays of values which returned the corresponding key.
- * @returns {Promise} a promise, if no callback is passed
- */
-function groupBySeries(coll, iteratee, callback) {
-  return (0, _groupByLimit2.default)(coll, 1, iteratee, callback);
-}
-module.exports = exports['default'];