api_connect_nodejs 1.0.0 → 1.0.1

package/test/EdelCsvTestSuite/node_modules/async/retryable.js

@@ -1,77 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = retryable;
-
-var _retry = require('./retry');
-
-var _retry2 = _interopRequireDefault(_retry);
-
-var _initialParams = require('./internal/initialParams');
-
-var _initialParams2 = _interopRequireDefault(_initialParams);
-
-var _wrapAsync = require('./internal/wrapAsync');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-var _promiseCallback = require('./internal/promiseCallback');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * A close relative of [`retry`]{@link module:ControlFlow.retry}.  This method
- * wraps a task and makes it retryable, rather than immediately calling it
- * with retries.
- *
- * @name retryable
- * @static
- * @memberOf module:ControlFlow
- * @method
- * @see [async.retry]{@link module:ControlFlow.retry}
- * @category Control Flow
- * @param {Object|number} [opts = {times: 5, interval: 0}| 5] - optional
- * options, exactly the same as from `retry`, except for a `opts.arity` that
- * is the arity of the `task` function, defaulting to `task.length`
- * @param {AsyncFunction} task - the asynchronous function to wrap.
- * This function will be passed any arguments passed to the returned wrapper.
- * Invoked with (...args, callback).
- * @returns {AsyncFunction} The wrapped function, which when invoked, will
- * retry on an error, based on the parameters specified in `opts`.
- * This function will accept the same parameters as `task`.
- * @example
- *
- * async.auto({
- *     dep1: async.retryable(3, getFromFlakyService),
- *     process: ["dep1", async.retryable(3, function (results, cb) {
- *         maybeProcessData(results.dep1, cb);
- *     })]
- * }, callback);
- */
-function retryable(opts, task) {
-    if (!task) {
-        task = opts;
-        opts = null;
-    }
-    let arity = opts && opts.arity || task.length;
-    if ((0, _wrapAsync.isAsync)(task)) {
-        arity += 1;
-    }
-    var _task = (0, _wrapAsync2.default)(task);
-    return (0, _initialParams2.default)((args, callback) => {
-        if (args.length < arity - 1 || callback == null) {
-            args.push(callback);
-            callback = (0, _promiseCallback.promiseCallback)();
-        }
-        function taskFn(cb) {
-            _task(...args, cb);
-        }
-
-        if (opts) (0, _retry2.default)(opts, taskFn, callback);else (0, _retry2.default)(taskFn, callback);
-
-        return callback[_promiseCallback.PROMISE_SYMBOL];
-    });
-}
-module.exports = exports['default'];

package/test/EdelCsvTestSuite/node_modules/async/select.js

@@ -1,93 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-var _filter2 = require('./internal/filter');
-
-var _filter3 = _interopRequireDefault(_filter2);
-
-var _eachOf = require('./eachOf');
-
-var _eachOf2 = _interopRequireDefault(_eachOf);
-
-var _awaitify = require('./internal/awaitify');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * 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.
- *
- * @name filter
- * @static
- * @memberOf module:Collections
- * @method
- * @alias select
- * @category Collection
- * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
- * @param {Function} iteratee - A truth test to apply to each item in `coll`.
- * The `iteratee` is passed a `callback(err, truthValue)`, which must be called
- * with a boolean argument once it has completed. Invoked with (item, callback).
- * @param {Function} [callback] - A callback which is called after all the
- * `iteratee` functions have finished. Invoked with (err, results).
- * @returns {Promise} a promise, if no callback provided
- * @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
- *
- * const files = ['dir1/file1.txt','dir2/file3.txt','dir3/file6.txt'];
- *
- * // asynchronous function that checks if a file exists
- * function fileExists(file, callback) {
- *    fs.access(file, fs.constants.F_OK, (err) => {
- *        callback(null, !err);
- *    });
- * }
- *
- * // Using callbacks
- * async.filter(files, fileExists, function(err, results) {
- *    if(err) {
- *        console.log(err);
- *    } else {
- *        console.log(results);
- *        // [ 'dir1/file1.txt', 'dir2/file3.txt' ]
- *        // results is now an array of the existing files
- *    }
- * });
- *
- * // Using Promises
- * async.filter(files, fileExists)
- * .then(results => {
- *     console.log(results);
- *     // [ 'dir1/file1.txt', 'dir2/file3.txt' ]
- *     // results is now an array of the existing files
- * }).catch(err => {
- *     console.log(err);
- * });
- *
- * // Using async/await
- * async () => {
- *     try {
- *         let results = await async.filter(files, fileExists);
- *         console.log(results);
- *         // [ 'dir1/file1.txt', 'dir2/file3.txt' ]
- *         // results is now an array of the existing files
- *     }
- *     catch (err) {
- *         console.log(err);
- *     }
- * }
- *
- */
-function filter(coll, iteratee, callback) {
-  return (0, _filter3.default)(_eachOf2.default, coll, iteratee, callback);
-}
-exports.default = (0, _awaitify2.default)(filter, 3);
-module.exports = exports['default'];

package/test/EdelCsvTestSuite/node_modules/async/selectLimit.js

@@ -1,45 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-var _filter2 = require('./internal/filter');
-
-var _filter3 = _interopRequireDefault(_filter2);
-
-var _eachOfLimit = require('./internal/eachOfLimit');
-
-var _eachOfLimit2 = _interopRequireDefault(_eachOfLimit);
-
-var _awaitify = require('./internal/awaitify');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * The same as [`filter`]{@link module:Collections.filter} but runs a maximum of `limit` async operations at a
- * time.
- *
- * @name filterLimit
- * @static
- * @memberOf module:Collections
- * @method
- * @see [async.filter]{@link module:Collections.filter}
- * @alias selectLimit
- * @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 {Function} iteratee - A truth test to apply to each item in `coll`.
- * The `iteratee` is passed a `callback(err, truthValue)`, which must be called
- * with a boolean argument once it has completed. Invoked with (item, callback).
- * @param {Function} [callback] - A callback which is called after all the
- * `iteratee` functions have finished. Invoked with (err, results).
- * @returns {Promise} a promise, if no callback provided
- */
-function filterLimit(coll, limit, iteratee, callback) {
-  return (0, _filter3.default)((0, _eachOfLimit2.default)(limit), coll, iteratee, callback);
-}
-exports.default = (0, _awaitify2.default)(filterLimit, 4);
-module.exports = exports['default'];

package/test/EdelCsvTestSuite/node_modules/async/selectSeries.js

@@ -1,43 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-var _filter2 = require('./internal/filter');
-
-var _filter3 = _interopRequireDefault(_filter2);
-
-var _eachOfSeries = require('./eachOfSeries');
-
-var _eachOfSeries2 = _interopRequireDefault(_eachOfSeries);
-
-var _awaitify = require('./internal/awaitify');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * The same as [`filter`]{@link module:Collections.filter} but runs only a single async operation at a time.
- *
- * @name filterSeries
- * @static
- * @memberOf module:Collections
- * @method
- * @see [async.filter]{@link module:Collections.filter}
- * @alias selectSeries
- * @category Collection
- * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
- * @param {Function} iteratee - A truth test to apply to each item in `coll`.
- * The `iteratee` is passed a `callback(err, truthValue)`, which must be called
- * with a boolean argument once it has completed. Invoked with (item, callback).
- * @param {Function} [callback] - A callback which is called after all the
- * `iteratee` functions have finished. Invoked with (err, results)
- * @returns {Promise} a promise, if no callback provided
- */
-function filterSeries(coll, iteratee, callback) {
-  return (0, _filter3.default)(_eachOfSeries2.default, coll, iteratee, callback);
-}
-exports.default = (0, _awaitify2.default)(filterSeries, 3);
-module.exports = exports['default'];

package/test/EdelCsvTestSuite/node_modules/async/seq.js

@@ -1,79 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = seq;
-
-var _reduce = require('./reduce');
-
-var _reduce2 = _interopRequireDefault(_reduce);
-
-var _wrapAsync = require('./internal/wrapAsync');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-var _promiseCallback = require('./internal/promiseCallback');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Version of the compose function that is more natural to read. Each function
- * consumes the return value of the previous function. It is the equivalent of
- * [compose]{@link module:ControlFlow.compose} with the arguments reversed.
- *
- * Each function is executed with the `this` binding of the composed function.
- *
- * @name seq
- * @static
- * @memberOf module:ControlFlow
- * @method
- * @see [async.compose]{@link module:ControlFlow.compose}
- * @category Control Flow
- * @param {...AsyncFunction} functions - the asynchronous functions to compose
- * @returns {Function} a function that composes the `functions` in order
- * @example
- *
- * // Requires lodash (or underscore), express3 and dresende's orm2.
- * // Part of an app, that fetches cats of the logged user.
- * // This example uses `seq` function to avoid overnesting and error
- * // handling clutter.
- * app.get('/cats', function(request, response) {
- *     var User = request.models.User;
- *     async.seq(
- *         _.bind(User.get, User),  // 'User.get' has signature (id, callback(err, data))
- *         function(user, fn) {
- *             user.getCats(fn);      // 'getCats' has signature (callback(err, data))
- *         }
- *     )(req.session.user_id, function (err, cats) {
- *         if (err) {
- *             console.error(err);
- *             response.json({ status: 'error', message: err.message });
- *         } else {
- *             response.json({ status: 'ok', message: 'Cats found', data: cats });
- *         }
- *     });
- * });
- */
-function seq(...functions) {
-    var _functions = functions.map(_wrapAsync2.default);
-    return function (...args) {
-        var that = this;
-
-        var cb = args[args.length - 1];
-        if (typeof cb == 'function') {
-            args.pop();
-        } else {
-            cb = (0, _promiseCallback.promiseCallback)();
-        }
-
-        (0, _reduce2.default)(_functions, args, (newargs, fn, iterCb) => {
-            fn.apply(that, newargs.concat((err, ...nextargs) => {
-                iterCb(err, nextargs);
-            }));
-        }, (err, results) => cb(err, ...results));
-
-        return cb[_promiseCallback.PROMISE_SYMBOL];
-    };
-}
-module.exports = exports['default'];

package/test/EdelCsvTestSuite/node_modules/async/series.js

@@ -1,186 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = series;
-
-var _parallel2 = require('./internal/parallel');
-
-var _parallel3 = _interopRequireDefault(_parallel2);
-
-var _eachOfSeries = require('./eachOfSeries');
-
-var _eachOfSeries2 = _interopRequireDefault(_eachOfSeries);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Run the functions in the `tasks` collection in series, each one running once
- * the previous function has completed. If any functions in the series pass an
- * error to its callback, no more functions are run, and `callback` is
- * immediately called with the value of the error. Otherwise, `callback`
- * receives an array of results when `tasks` have completed.
- *
- * It is also possible to use an object instead of an array. Each property will
- * be run as a function, and the results will be passed to the final `callback`
- * as an object instead of an array. This can be a more readable way of handling
- *  results from {@link async.series}.
- *
- * **Note** that while many implementations preserve the order of object
- * properties, the [ECMAScript Language Specification](http://www.ecma-international.org/ecma-262/5.1/#sec-8.6)
- * explicitly states that
- *
- * > The mechanics and order of enumerating the properties is not specified.
- *
- * So if you rely on the order in which your series of functions are executed,
- * and want this to work on all platforms, consider using an array.
- *
- * @name series
- * @static
- * @memberOf module:ControlFlow
- * @method
- * @category Control Flow
- * @param {Array|Iterable|AsyncIterable|Object} tasks - A collection containing
- * [async functions]{@link AsyncFunction} to run in series.
- * Each function can complete with any number of optional `result` values.
- * @param {Function} [callback] - An optional callback to run once all the
- * functions have completed. This function gets a results array (or object)
- * containing all the result arguments passed to the `task` callbacks. Invoked
- * with (err, result).
- * @return {Promise} a promise, if no callback is passed
- * @example
- *
- * //Using Callbacks
- * async.series([
- *     function(callback) {
- *         setTimeout(function() {
- *             // do some async task
- *             callback(null, 'one');
- *         }, 200);
- *     },
- *     function(callback) {
- *         setTimeout(function() {
- *             // then do another async task
- *             callback(null, 'two');
- *         }, 100);
- *     }
- * ], function(err, results) {
- *     console.log(results);
- *     // results is equal to ['one','two']
- * });
- *
- * // an example using objects instead of arrays
- * async.series({
- *     one: function(callback) {
- *         setTimeout(function() {
- *             // do some async task
- *             callback(null, 1);
- *         }, 200);
- *     },
- *     two: function(callback) {
- *         setTimeout(function() {
- *             // then do another async task
- *             callback(null, 2);
- *         }, 100);
- *     }
- * }, function(err, results) {
- *     console.log(results);
- *     // results is equal to: { one: 1, two: 2 }
- * });
- *
- * //Using Promises
- * async.series([
- *     function(callback) {
- *         setTimeout(function() {
- *             callback(null, 'one');
- *         }, 200);
- *     },
- *     function(callback) {
- *         setTimeout(function() {
- *             callback(null, 'two');
- *         }, 100);
- *     }
- * ]).then(results => {
- *     console.log(results);
- *     // results is equal to ['one','two']
- * }).catch(err => {
- *     console.log(err);
- * });
- *
- * // an example using an object instead of an array
- * async.series({
- *     one: function(callback) {
- *         setTimeout(function() {
- *             // do some async task
- *             callback(null, 1);
- *         }, 200);
- *     },
- *     two: function(callback) {
- *         setTimeout(function() {
- *             // then do another async task
- *             callback(null, 2);
- *         }, 100);
- *     }
- * }).then(results => {
- *     console.log(results);
- *     // results is equal to: { one: 1, two: 2 }
- * }).catch(err => {
- *     console.log(err);
- * });
- *
- * //Using async/await
- * async () => {
- *     try {
- *         let results = await async.series([
- *             function(callback) {
- *                 setTimeout(function() {
- *                     // do some async task
- *                     callback(null, 'one');
- *                 }, 200);
- *             },
- *             function(callback) {
- *                 setTimeout(function() {
- *                     // then do another async task
- *                     callback(null, 'two');
- *                 }, 100);
- *             }
- *         ]);
- *         console.log(results);
- *         // results is equal to ['one','two']
- *     }
- *     catch (err) {
- *         console.log(err);
- *     }
- * }
- *
- * // an example using an object instead of an array
- * async () => {
- *     try {
- *         let results = await async.parallel({
- *             one: function(callback) {
- *                 setTimeout(function() {
- *                     // do some async task
- *                     callback(null, 1);
- *                 }, 200);
- *             },
- *            two: function(callback) {
- *                 setTimeout(function() {
- *                     // then do another async task
- *                     callback(null, 2);
- *                 }, 100);
- *            }
- *         });
- *         console.log(results);
- *         // results is equal to: { one: 1, two: 2 }
- *     }
- *     catch (err) {
- *         console.log(err);
- *     }
- * }
- *
- */
-function series(tasks, callback) {
-  return (0, _parallel3.default)(_eachOfSeries2.default, tasks, callback);
-}
-module.exports = exports['default'];

package/test/EdelCsvTestSuite/node_modules/async/setImmediate.js

@@ -1,45 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-var _setImmediate = require('./internal/setImmediate');
-
-var _setImmediate2 = _interopRequireDefault(_setImmediate);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Calls `callback` on a later loop around the event loop. In Node.js this just
- * calls `setImmediate`.  In the browser it will use `setImmediate` if
- * available, otherwise `setTimeout(callback, 0)`, which means other higher
- * priority events may precede the execution of `callback`.
- *
- * This is used internally for browser-compatibility purposes.
- *
- * @name setImmediate
- * @static
- * @memberOf module:Utils
- * @method
- * @see [async.nextTick]{@link module:Utils.nextTick}
- * @category Util
- * @param {Function} callback - The function to call on a later loop around
- * the event loop. Invoked with (args...).
- * @param {...*} args... - any number of additional arguments to pass to the
- * callback on the next tick.
- * @example
- *
- * var call_order = [];
- * async.nextTick(function() {
- *     call_order.push('two');
- *     // call_order now equals ['one','two']
- * });
- * call_order.push('one');
- *
- * async.setImmediate(function (a, b, c) {
- *     // a, b, and c equal 1, 2, and 3
- * }, 1, 2, 3);
- */
-exports.default = _setImmediate2.default;
-module.exports = exports['default'];

package/test/EdelCsvTestSuite/node_modules/async/some.js

@@ -1,122 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-var _createTester = require('./internal/createTester');
-
-var _createTester2 = _interopRequireDefault(_createTester);
-
-var _eachOf = require('./eachOf');
-
-var _eachOf2 = _interopRequireDefault(_eachOf);
-
-var _awaitify = require('./internal/awaitify');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Returns `true` if at least one element in the `coll` satisfies an async test.
- * If any iteratee call returns `true`, the main `callback` is immediately
- * called.
- *
- * @name some
- * @static
- * @memberOf module:Collections
- * @method
- * @alias any
- * @category Collection
- * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
- * @param {AsyncFunction} iteratee - An async truth test to apply to each item
- * in the collections in parallel.
- * The iteratee should complete with a boolean `result` value.
- * Invoked with (item, callback).
- * @param {Function} [callback] - A callback which is called as soon as any
- * iteratee returns `true`, or after all the iteratee functions have finished.
- * Result will be either `true` or `false` depending on the values of the async
- * tests. Invoked with (err, result).
- * @returns {Promise} a promise, if no callback provided
- * @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
- *
- * // asynchronous function that checks if a file exists
- * function fileExists(file, callback) {
- *    fs.access(file, fs.constants.F_OK, (err) => {
- *        callback(null, !err);
- *    });
- * }
- *
- * // Using callbacks
- * async.some(['dir1/missing.txt','dir2/missing.txt','dir3/file5.txt'], fileExists,
- *    function(err, result) {
- *        console.log(result);
- *        // true
- *        // result is true since some file in the list exists
- *    }
- *);
- *
- * async.some(['dir1/missing.txt','dir2/missing.txt','dir4/missing.txt'], fileExists,
- *    function(err, result) {
- *        console.log(result);
- *        // false
- *        // result is false since none of the files exists
- *    }
- *);
- *
- * // Using Promises
- * async.some(['dir1/missing.txt','dir2/missing.txt','dir3/file5.txt'], fileExists)
- * .then( result => {
- *     console.log(result);
- *     // true
- *     // result is true since some file in the list exists
- * }).catch( err => {
- *     console.log(err);
- * });
- *
- * async.some(['dir1/missing.txt','dir2/missing.txt','dir4/missing.txt'], fileExists)
- * .then( result => {
- *     console.log(result);
- *     // false
- *     // result is false since none of the files exists
- * }).catch( err => {
- *     console.log(err);
- * });
- *
- * // Using async/await
- * async () => {
- *     try {
- *         let result = await async.some(['dir1/missing.txt','dir2/missing.txt','dir3/file5.txt'], fileExists);
- *         console.log(result);
- *         // true
- *         // result is true since some file in the list exists
- *     }
- *     catch (err) {
- *         console.log(err);
- *     }
- * }
- *
- * async () => {
- *     try {
- *         let result = await async.some(['dir1/missing.txt','dir2/missing.txt','dir4/missing.txt'], fileExists);
- *         console.log(result);
- *         // false
- *         // result is false since none of the files exists
- *     }
- *     catch (err) {
- *         console.log(err);
- *     }
- * }
- *
- */
-function some(coll, iteratee, callback) {
-  return (0, _createTester2.default)(Boolean, res => res)(_eachOf2.default, coll, iteratee, callback);
-}
-exports.default = (0, _awaitify2.default)(some, 3);
-module.exports = exports['default'];