koa-classic-server 1.0.0 → 1.0.2

package/test/node_modules/async/inject.js

@@ -1,153 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-
-var _eachOfSeries = require('./eachOfSeries.js');
-
-var _eachOfSeries2 = _interopRequireDefault(_eachOfSeries);
-
-var _once = require('./internal/once.js');
-
-var _once2 = _interopRequireDefault(_once);
-
-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 }; }
-
-/**
- * Reduces `coll` into a single value using an async `iteratee` to return each
- * successive step. `memo` is the initial state of the reduction. This function
- * only operates in series.
- *
- * For performance reasons, it may make sense to split a call to this function
- * into a parallel map, and then use the normal `Array.prototype.reduce` on the
- * results. This function is for situations where each step in the reduction
- * needs to be async; if you can get the data before reducing it, then it's
- * probably a good idea to do so.
- *
- * @name reduce
- * @static
- * @memberOf module:Collections
- * @method
- * @alias inject
- * @alias foldl
- * @category Collection
- * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
- * @param {*} memo - The initial state of the reduction.
- * @param {AsyncFunction} iteratee - A function applied to each item in the
- * array to produce the next step in the reduction.
- * The `iteratee` should complete with the next state of the reduction.
- * If the iteratee completes with an error, the reduction is stopped and the
- * main `callback` is immediately called with the error.
- * Invoked with (memo, item, callback).
- * @param {Function} [callback] - A callback which is called after all the
- * `iteratee` functions have finished. Result is the reduced value. Invoked with
- * (err, result).
- * @returns {Promise} a promise, if no callback is passed
- * @example
- *
- * // file1.txt is a file that is 1000 bytes in size
- * // file2.txt is a file that is 2000 bytes in size
- * // file3.txt is a file that is 3000 bytes in size
- * // file4.txt does not exist
- *
- * const fileList = ['file1.txt','file2.txt','file3.txt'];
- * const withMissingFileList = ['file1.txt','file2.txt','file3.txt', 'file4.txt'];
- *
- * // asynchronous function that computes the file size in bytes
- * // file size is added to the memoized value, then returned
- * function getFileSizeInBytes(memo, file, callback) {
- *     fs.stat(file, function(err, stat) {
- *         if (err) {
- *             return callback(err);
- *         }
- *         callback(null, memo + stat.size);
- *     });
- * }
- *
- * // Using callbacks
- * async.reduce(fileList, 0, getFileSizeInBytes, function(err, result) {
- *     if (err) {
- *         console.log(err);
- *     } else {
- *         console.log(result);
- *         // 6000
- *         // which is the sum of the file sizes of the three files
- *     }
- * });
- *
- * // Error Handling
- * async.reduce(withMissingFileList, 0, getFileSizeInBytes, function(err, result) {
- *     if (err) {
- *         console.log(err);
- *         // [ Error: ENOENT: no such file or directory ]
- *     } else {
- *         console.log(result);
- *     }
- * });
- *
- * // Using Promises
- * async.reduce(fileList, 0, getFileSizeInBytes)
- * .then( result => {
- *     console.log(result);
- *     // 6000
- *     // which is the sum of the file sizes of the three files
- * }).catch( err => {
- *     console.log(err);
- * });
- *
- * // Error Handling
- * async.reduce(withMissingFileList, 0, getFileSizeInBytes)
- * .then( result => {
- *     console.log(result);
- * }).catch( err => {
- *     console.log(err);
- *     // [ Error: ENOENT: no such file or directory ]
- * });
- *
- * // Using async/await
- * async () => {
- *     try {
- *         let result = await async.reduce(fileList, 0, getFileSizeInBytes);
- *         console.log(result);
- *         // 6000
- *         // which is the sum of the file sizes of the three files
- *     }
- *     catch (err) {
- *         console.log(err);
- *     }
- * }
- *
- * // Error Handling
- * async () => {
- *     try {
- *         let result = await async.reduce(withMissingFileList, 0, getFileSizeInBytes);
- *         console.log(result);
- *     }
- *     catch (err) {
- *         console.log(err);
- *         // [ Error: ENOENT: no such file or directory ]
- *     }
- * }
- *
- */
-function reduce(coll, memo, iteratee, callback) {
-    callback = (0, _once2.default)(callback);
-    var _iteratee = (0, _wrapAsync2.default)(iteratee);
-    return (0, _eachOfSeries2.default)(coll, (x, i, iterCb) => {
-        _iteratee(memo, x, (err, v) => {
-            memo = v;
-            iterCb(err);
-        });
-    }, err => callback(err, memo));
-}
-exports.default = (0, _awaitify2.default)(reduce, 4);
-module.exports = exports['default'];

package/test/node_modules/async/internal/DoublyLinkedList.js

@@ -1,92 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-// Simple doubly linked list (https://en.wikipedia.org/wiki/Doubly_linked_list) implementation
-// used for queues. This implementation assumes that the node provided by the user can be modified
-// to adjust the next and last properties. We implement only the minimal functionality
-// for queue support.
-class DLL {
-    constructor() {
-        this.head = this.tail = null;
-        this.length = 0;
-    }
-
-    removeLink(node) {
-        if (node.prev) node.prev.next = node.next;else this.head = node.next;
-        if (node.next) node.next.prev = node.prev;else this.tail = node.prev;
-
-        node.prev = node.next = null;
-        this.length -= 1;
-        return node;
-    }
-
-    empty() {
-        while (this.head) this.shift();
-        return this;
-    }
-
-    insertAfter(node, newNode) {
-        newNode.prev = node;
-        newNode.next = node.next;
-        if (node.next) node.next.prev = newNode;else this.tail = newNode;
-        node.next = newNode;
-        this.length += 1;
-    }
-
-    insertBefore(node, newNode) {
-        newNode.prev = node.prev;
-        newNode.next = node;
-        if (node.prev) node.prev.next = newNode;else this.head = newNode;
-        node.prev = newNode;
-        this.length += 1;
-    }
-
-    unshift(node) {
-        if (this.head) this.insertBefore(this.head, node);else setInitial(this, node);
-    }
-
-    push(node) {
-        if (this.tail) this.insertAfter(this.tail, node);else setInitial(this, node);
-    }
-
-    shift() {
-        return this.head && this.removeLink(this.head);
-    }
-
-    pop() {
-        return this.tail && this.removeLink(this.tail);
-    }
-
-    toArray() {
-        return [...this];
-    }
-
-    *[Symbol.iterator]() {
-        var cur = this.head;
-        while (cur) {
-            yield cur.data;
-            cur = cur.next;
-        }
-    }
-
-    remove(testFn) {
-        var curr = this.head;
-        while (curr) {
-            var { next } = curr;
-            if (testFn(curr)) {
-                this.removeLink(curr);
-            }
-            curr = next;
-        }
-        return this;
-    }
-}
-
-exports.default = DLL;
-function setInitial(dll, node) {
-    dll.length = 1;
-    dll.head = dll.tail = node;
-}
-module.exports = exports["default"];

package/test/node_modules/async/internal/Heap.js

@@ -1,120 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-// Binary min-heap implementation used for priority queue.
-// Implementation is stable, i.e. push time is considered for equal priorities
-class Heap {
-    constructor() {
-        this.heap = [];
-        this.pushCount = Number.MIN_SAFE_INTEGER;
-    }
-
-    get length() {
-        return this.heap.length;
-    }
-
-    empty() {
-        this.heap = [];
-        return this;
-    }
-
-    percUp(index) {
-        let p;
-
-        while (index > 0 && smaller(this.heap[index], this.heap[p = parent(index)])) {
-            let t = this.heap[index];
-            this.heap[index] = this.heap[p];
-            this.heap[p] = t;
-
-            index = p;
-        }
-    }
-
-    percDown(index) {
-        let l;
-
-        while ((l = leftChi(index)) < this.heap.length) {
-            if (l + 1 < this.heap.length && smaller(this.heap[l + 1], this.heap[l])) {
-                l = l + 1;
-            }
-
-            if (smaller(this.heap[index], this.heap[l])) {
-                break;
-            }
-
-            let t = this.heap[index];
-            this.heap[index] = this.heap[l];
-            this.heap[l] = t;
-
-            index = l;
-        }
-    }
-
-    push(node) {
-        node.pushCount = ++this.pushCount;
-        this.heap.push(node);
-        this.percUp(this.heap.length - 1);
-    }
-
-    unshift(node) {
-        return this.heap.push(node);
-    }
-
-    shift() {
-        let [top] = this.heap;
-
-        this.heap[0] = this.heap[this.heap.length - 1];
-        this.heap.pop();
-        this.percDown(0);
-
-        return top;
-    }
-
-    toArray() {
-        return [...this];
-    }
-
-    *[Symbol.iterator]() {
-        for (let i = 0; i < this.heap.length; i++) {
-            yield this.heap[i].data;
-        }
-    }
-
-    remove(testFn) {
-        let j = 0;
-        for (let i = 0; i < this.heap.length; i++) {
-            if (!testFn(this.heap[i])) {
-                this.heap[j] = this.heap[i];
-                j++;
-            }
-        }
-
-        this.heap.splice(j);
-
-        for (let i = parent(this.heap.length - 1); i >= 0; i--) {
-            this.percDown(i);
-        }
-
-        return this;
-    }
-}
-
-exports.default = Heap;
-function leftChi(i) {
-    return (i << 1) + 1;
-}
-
-function parent(i) {
-    return (i + 1 >> 1) - 1;
-}
-
-function smaller(x, y) {
-    if (x.priority !== y.priority) {
-        return x.priority < y.priority;
-    } else {
-        return x.pushCount < y.pushCount;
-    }
-}
-module.exports = exports["default"];

package/test/node_modules/async/internal/applyEach.js

@@ -1,29 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-
-exports.default = function (eachfn) {
-    return function applyEach(fns, ...callArgs) {
-        const go = (0, _awaitify2.default)(function (callback) {
-            var that = this;
-            return eachfn(fns, (fn, cb) => {
-                (0, _wrapAsync2.default)(fn).apply(that, callArgs.concat(cb));
-            }, callback);
-        });
-        return go;
-    };
-};
-
-var _wrapAsync = require('./wrapAsync.js');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-var _awaitify = require('./awaitify.js');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-module.exports = exports['default'];

package/test/node_modules/async/internal/asyncEachOfLimit.js

@@ -1,75 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = asyncEachOfLimit;
-
-var _breakLoop = require('./breakLoop.js');
-
-var _breakLoop2 = _interopRequireDefault(_breakLoop);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-// for async generators
-function asyncEachOfLimit(generator, limit, iteratee, callback) {
-    let done = false;
-    let canceled = false;
-    let awaiting = false;
-    let running = 0;
-    let idx = 0;
-
-    function replenish() {
-        //console.log('replenish')
-        if (running >= limit || awaiting || done) return;
-        //console.log('replenish awaiting')
-        awaiting = true;
-        generator.next().then(({ value, done: iterDone }) => {
-            //console.log('got value', value)
-            if (canceled || done) return;
-            awaiting = false;
-            if (iterDone) {
-                done = true;
-                if (running <= 0) {
-                    //console.log('done nextCb')
-                    callback(null);
-                }
-                return;
-            }
-            running++;
-            iteratee(value, idx, iterateeCallback);
-            idx++;
-            replenish();
-        }).catch(handleError);
-    }
-
-    function iterateeCallback(err, result) {
-        //console.log('iterateeCallback')
-        running -= 1;
-        if (canceled) return;
-        if (err) return handleError(err);
-
-        if (err === false) {
-            done = true;
-            canceled = true;
-            return;
-        }
-
-        if (result === _breakLoop2.default || done && running <= 0) {
-            done = true;
-            //console.log('done iterCb')
-            return callback(null);
-        }
-        replenish();
-    }
-
-    function handleError(err) {
-        if (canceled) return;
-        awaiting = false;
-        done = true;
-        callback(err);
-    }
-
-    replenish();
-}
-module.exports = exports['default'];

package/test/node_modules/async/internal/awaitify.js

@@ -1,27 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = awaitify;
-// conditionally promisify a function.
-// only return a promise if a callback is omitted
-function awaitify(asyncFn, arity = asyncFn.length) {
-    if (!arity) throw new Error('arity is undefined');
-    function awaitable(...args) {
-        if (typeof args[arity - 1] === 'function') {
-            return asyncFn.apply(this, args);
-        }
-
-        return new Promise((resolve, reject) => {
-            args[arity - 1] = (err, ...cbArgs) => {
-                if (err) return reject(err);
-                resolve(cbArgs.length > 1 ? cbArgs : cbArgs[0]);
-            };
-            asyncFn.apply(this, args);
-        });
-    }
-
-    return awaitable;
-}
-module.exports = exports['default'];

package/test/node_modules/async/internal/breakLoop.js

@@ -1,10 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-// A temporary value used to identify if the loop should be broken.
-// See #1064, #1293
-const breakLoop = {};
-exports.default = breakLoop;
-module.exports = exports["default"];

package/test/node_modules/async/internal/consoleFunc.js

@@ -1,31 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = consoleFunc;
-
-var _wrapAsync = require('./wrapAsync.js');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function consoleFunc(name) {
-    return (fn, ...args) => (0, _wrapAsync2.default)(fn)(...args, (err, ...resultArgs) => {
-        /* istanbul ignore else */
-        if (typeof console === 'object') {
-            /* istanbul ignore else */
-            if (err) {
-                /* istanbul ignore else */
-                if (console.error) {
-                    console.error(err);
-                }
-            } else if (console[name]) {
-                /* istanbul ignore else */
-                resultArgs.forEach(x => console[name](x));
-            }
-        }
-    });
-}
-module.exports = exports['default'];

package/test/node_modules/async/internal/createTester.js

@@ -1,40 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = _createTester;
-
-var _breakLoop = require('./breakLoop.js');
-
-var _breakLoop2 = _interopRequireDefault(_breakLoop);
-
-var _wrapAsync = require('./wrapAsync.js');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _createTester(check, getResult) {
-    return (eachfn, arr, _iteratee, cb) => {
-        var testPassed = false;
-        var testResult;
-        const iteratee = (0, _wrapAsync2.default)(_iteratee);
-        eachfn(arr, (value, _, callback) => {
-            iteratee(value, (err, result) => {
-                if (err || err === false) return callback(err);
-
-                if (check(result) && !testResult) {
-                    testPassed = true;
-                    testResult = getResult(true, value);
-                    return callback(null, _breakLoop2.default);
-                }
-                callback();
-            });
-        }, err => {
-            if (err) return cb(err);
-            cb(null, testPassed ? testResult : getResult(false));
-        });
-    };
-}
-module.exports = exports['default'];

package/test/node_modules/async/internal/eachOfLimit.js

@@ -1,90 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-
-var _once = require('./once.js');
-
-var _once2 = _interopRequireDefault(_once);
-
-var _iterator = require('./iterator.js');
-
-var _iterator2 = _interopRequireDefault(_iterator);
-
-var _onlyOnce = require('./onlyOnce.js');
-
-var _onlyOnce2 = _interopRequireDefault(_onlyOnce);
-
-var _wrapAsync = require('./wrapAsync.js');
-
-var _asyncEachOfLimit = require('./asyncEachOfLimit.js');
-
-var _asyncEachOfLimit2 = _interopRequireDefault(_asyncEachOfLimit);
-
-var _breakLoop = require('./breakLoop.js');
-
-var _breakLoop2 = _interopRequireDefault(_breakLoop);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-exports.default = limit => {
-    return (obj, iteratee, callback) => {
-        callback = (0, _once2.default)(callback);
-        if (limit <= 0) {
-            throw new RangeError('concurrency limit cannot be less than 1');
-        }
-        if (!obj) {
-            return callback(null);
-        }
-        if ((0, _wrapAsync.isAsyncGenerator)(obj)) {
-            return (0, _asyncEachOfLimit2.default)(obj, limit, iteratee, callback);
-        }
-        if ((0, _wrapAsync.isAsyncIterable)(obj)) {
-            return (0, _asyncEachOfLimit2.default)(obj[Symbol.asyncIterator](), limit, iteratee, callback);
-        }
-        var nextElem = (0, _iterator2.default)(obj);
-        var done = false;
-        var canceled = false;
-        var running = 0;
-        var looping = false;
-
-        function iterateeCallback(err, value) {
-            if (canceled) return;
-            running -= 1;
-            if (err) {
-                done = true;
-                callback(err);
-            } else if (err === false) {
-                done = true;
-                canceled = true;
-            } else if (value === _breakLoop2.default || done && running <= 0) {
-                done = true;
-                return callback(null);
-            } else if (!looping) {
-                replenish();
-            }
-        }
-
-        function replenish() {
-            looping = true;
-            while (running < limit && !done) {
-                var elem = nextElem();
-                if (elem === null) {
-                    done = true;
-                    if (running <= 0) {
-                        callback(null);
-                    }
-                    return;
-                }
-                running += 1;
-                iteratee(elem.value, elem.key, (0, _onlyOnce2.default)(iterateeCallback));
-            }
-            looping = false;
-        }
-
-        replenish();
-    };
-};
-
-module.exports = exports['default'];