@veecode-platform/backstage-plugin-about-backend-dynamic 1.0.1 → 1.0.2

package/node_modules/async/sortBy.js

@@ -1,190 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-
-var _map = require('./map.js');
-
-var _map2 = _interopRequireDefault(_map);
-
-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 }; }
-
-/**
- * Sorts a list by the results of running each `coll` value through an async
- * `iteratee`.
- *
- * @name sortBy
- * @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 value to use as the sort criteria as
- * its `result`.
- * Invoked with (item, callback).
- * @param {Function} callback - A callback which is called after all the
- * `iteratee` functions have finished, or an error occurs. Results is the items
- * from the original `coll` sorted by the values returned by the `iteratee`
- * calls. Invoked with (err, results).
- * @returns {Promise} a promise, if no callback passed
- * @example
- *
- * // bigfile.txt is a file that is 251100 bytes in size
- * // mediumfile.txt is a file that is 11000 bytes in size
- * // smallfile.txt is a file that is 121 bytes in size
- *
- * // asynchronous function that returns the file size in bytes
- * function getFileSizeInBytes(file, callback) {
- *     fs.stat(file, function(err, stat) {
- *         if (err) {
- *             return callback(err);
- *         }
- *         callback(null, stat.size);
- *     });
- * }
- *
- * // Using callbacks
- * async.sortBy(['mediumfile.txt','smallfile.txt','bigfile.txt'], getFileSizeInBytes,
- *     function(err, results) {
- *         if (err) {
- *             console.log(err);
- *         } else {
- *             console.log(results);
- *             // results is now the original array of files sorted by
- *             // file size (ascending by default), e.g.
- *             // [ 'smallfile.txt', 'mediumfile.txt', 'bigfile.txt']
- *         }
- *     }
- * );
- *
- * // By modifying the callback parameter the
- * // sorting order can be influenced:
- *
- * // ascending order
- * async.sortBy(['mediumfile.txt','smallfile.txt','bigfile.txt'], function(file, callback) {
- *     getFileSizeInBytes(file, function(getFileSizeErr, fileSize) {
- *         if (getFileSizeErr) return callback(getFileSizeErr);
- *         callback(null, fileSize);
- *     });
- * }, function(err, results) {
- *         if (err) {
- *             console.log(err);
- *         } else {
- *             console.log(results);
- *             // results is now the original array of files sorted by
- *             // file size (ascending by default), e.g.
- *             // [ 'smallfile.txt', 'mediumfile.txt', 'bigfile.txt']
- *         }
- *     }
- * );
- *
- * // descending order
- * async.sortBy(['bigfile.txt','mediumfile.txt','smallfile.txt'], function(file, callback) {
- *     getFileSizeInBytes(file, function(getFileSizeErr, fileSize) {
- *         if (getFileSizeErr) {
- *             return callback(getFileSizeErr);
- *         }
- *         callback(null, fileSize * -1);
- *     });
- * }, function(err, results) {
- *         if (err) {
- *             console.log(err);
- *         } else {
- *             console.log(results);
- *             // results is now the original array of files sorted by
- *             // file size (ascending by default), e.g.
- *             // [ 'bigfile.txt', 'mediumfile.txt', 'smallfile.txt']
- *         }
- *     }
- * );
- *
- * // Error handling
- * async.sortBy(['mediumfile.txt','smallfile.txt','missingfile.txt'], getFileSizeInBytes,
- *     function(err, results) {
- *         if (err) {
- *             console.log(err);
- *             // [ Error: ENOENT: no such file or directory ]
- *         } else {
- *             console.log(results);
- *         }
- *     }
- * );
- *
- * // Using Promises
- * async.sortBy(['mediumfile.txt','smallfile.txt','bigfile.txt'], getFileSizeInBytes)
- * .then( results => {
- *     console.log(results);
- *     // results is now the original array of files sorted by
- *     // file size (ascending by default), e.g.
- *     // [ 'smallfile.txt', 'mediumfile.txt', 'bigfile.txt']
- * }).catch( err => {
- *     console.log(err);
- * });
- *
- * // Error handling
- * async.sortBy(['mediumfile.txt','smallfile.txt','missingfile.txt'], getFileSizeInBytes)
- * .then( results => {
- *     console.log(results);
- * }).catch( err => {
- *     console.log(err);
- *     // [ Error: ENOENT: no such file or directory ]
- * });
- *
- * // Using async/await
- * (async () => {
- *     try {
- *         let results = await async.sortBy(['bigfile.txt','mediumfile.txt','smallfile.txt'], getFileSizeInBytes);
- *         console.log(results);
- *         // results is now the original array of files sorted by
- *         // file size (ascending by default), e.g.
- *         // [ 'smallfile.txt', 'mediumfile.txt', 'bigfile.txt']
- *     }
- *     catch (err) {
- *         console.log(err);
- *     }
- * })();
- *
- * // Error handling
- * async () => {
- *     try {
- *         let results = await async.sortBy(['missingfile.txt','mediumfile.txt','smallfile.txt'], getFileSizeInBytes);
- *         console.log(results);
- *     }
- *     catch (err) {
- *         console.log(err);
- *         // [ Error: ENOENT: no such file or directory ]
- *     }
- * }
- *
- */
-function sortBy(coll, iteratee, callback) {
-    var _iteratee = (0, _wrapAsync2.default)(iteratee);
-    return (0, _map2.default)(coll, (x, iterCb) => {
-        _iteratee(x, (err, criteria) => {
-            if (err) return iterCb(err);
-            iterCb(err, { value: x, criteria });
-        });
-    }, (err, results) => {
-        if (err) return callback(err);
-        callback(null, results.sort(comparator).map(v => v.value));
-    });
-
-    function comparator(left, right) {
-        var a = left.criteria,
-            b = right.criteria;
-        return a < b ? -1 : a > b ? 1 : 0;
-    }
-}
-exports.default = (0, _awaitify2.default)(sortBy, 3);
-module.exports = exports.default;

package/node_modules/async/timeout.js

@@ -1,89 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = timeout;
-
-var _initialParams = require('./internal/initialParams.js');
-
-var _initialParams2 = _interopRequireDefault(_initialParams);
-
-var _wrapAsync = require('./internal/wrapAsync.js');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Sets a time limit on an asynchronous function. If the function does not call
- * its callback within the specified milliseconds, it will be called with a
- * timeout error. The code property for the error object will be `'ETIMEDOUT'`.
- *
- * @name timeout
- * @static
- * @memberOf module:Utils
- * @method
- * @category Util
- * @param {AsyncFunction} asyncFn - The async function to limit in time.
- * @param {number} milliseconds - The specified time limit.
- * @param {*} [info] - Any variable you want attached (`string`, `object`, etc)
- * to timeout Error for more information..
- * @returns {AsyncFunction} Returns a wrapped function that can be used with any
- * of the control flow functions.
- * Invoke this function with the same parameters as you would `asyncFunc`.
- * @example
- *
- * function myFunction(foo, callback) {
- *     doAsyncTask(foo, function(err, data) {
- *         // handle errors
- *         if (err) return callback(err);
- *
- *         // do some stuff ...
- *
- *         // return processed data
- *         return callback(null, data);
- *     });
- * }
- *
- * var wrapped = async.timeout(myFunction, 1000);
- *
- * // call `wrapped` as you would `myFunction`
- * wrapped({ bar: 'bar' }, function(err, data) {
- *     // if `myFunction` takes < 1000 ms to execute, `err`
- *     // and `data` will have their expected values
- *
- *     // else `err` will be an Error with the code 'ETIMEDOUT'
- * });
- */
-function timeout(asyncFn, milliseconds, info) {
-    var fn = (0, _wrapAsync2.default)(asyncFn);
-
-    return (0, _initialParams2.default)((args, callback) => {
-        var timedOut = false;
-        var timer;
-
-        function timeoutCallback() {
-            var name = asyncFn.name || 'anonymous';
-            var error = new Error('Callback function "' + name + '" timed out.');
-            error.code = 'ETIMEDOUT';
-            if (info) {
-                error.info = info;
-            }
-            timedOut = true;
-            callback(error);
-        }
-
-        args.push((...cbArgs) => {
-            if (!timedOut) {
-                callback(...cbArgs);
-                clearTimeout(timer);
-            }
-        });
-
-        // setup timer and call original function
-        timer = setTimeout(timeoutCallback, milliseconds);
-        fn(...args);
-    });
-}
-module.exports = exports.default;

package/node_modules/async/times.js

@@ -1,50 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = times;
-
-var _timesLimit = require('./timesLimit.js');
-
-var _timesLimit2 = _interopRequireDefault(_timesLimit);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Calls the `iteratee` function `n` times, and accumulates results in the same
- * manner you would use with [map]{@link module:Collections.map}.
- *
- * @name times
- * @static
- * @memberOf module:ControlFlow
- * @method
- * @see [async.map]{@link module:Collections.map}
- * @category Control Flow
- * @param {number} n - The number of times to run the function.
- * @param {AsyncFunction} iteratee - The async function to call `n` times.
- * Invoked with the iteration index and a callback: (n, next).
- * @param {Function} callback - see {@link module:Collections.map}.
- * @returns {Promise} a promise, if no callback is provided
- * @example
- *
- * // Pretend this is some complicated async factory
- * var createUser = function(id, callback) {
- *     callback(null, {
- *         id: 'user' + id
- *     });
- * };
- *
- * // generate 5 users
- * async.times(5, function(n, next) {
- *     createUser(n, function(err, user) {
- *         next(err, user);
- *     });
- * }, function(err, users) {
- *     // we should now have 5 users
- * });
- */
-function times(n, iteratee, callback) {
-    return (0, _timesLimit2.default)(n, Infinity, iteratee, callback);
-}
-module.exports = exports.default;

package/node_modules/async/timesLimit.js

@@ -1,43 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = timesLimit;
-
-var _mapLimit = require('./mapLimit.js');
-
-var _mapLimit2 = _interopRequireDefault(_mapLimit);
-
-var _range = require('./internal/range.js');
-
-var _range2 = _interopRequireDefault(_range);
-
-var _wrapAsync = require('./internal/wrapAsync.js');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * The same as [times]{@link module:ControlFlow.times} but runs a maximum of `limit` async operations at a
- * time.
- *
- * @name timesLimit
- * @static
- * @memberOf module:ControlFlow
- * @method
- * @see [async.times]{@link module:ControlFlow.times}
- * @category Control Flow
- * @param {number} count - The number of times to run the function.
- * @param {number} limit - The maximum number of async operations at a time.
- * @param {AsyncFunction} iteratee - The async function to call `n` times.
- * Invoked with the iteration index and a callback: (n, next).
- * @param {Function} callback - see [async.map]{@link module:Collections.map}.
- * @returns {Promise} a promise, if no callback is provided
- */
-function timesLimit(count, limit, iteratee, callback) {
-    var _iteratee = (0, _wrapAsync2.default)(iteratee);
-    return (0, _mapLimit2.default)((0, _range2.default)(count), limit, _iteratee, callback);
-}
-module.exports = exports.default;

package/node_modules/async/timesSeries.js

@@ -1,32 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = timesSeries;
-
-var _timesLimit = require('./timesLimit.js');
-
-var _timesLimit2 = _interopRequireDefault(_timesLimit);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * The same as [times]{@link module:ControlFlow.times} but runs only a single async operation at a time.
- *
- * @name timesSeries
- * @static
- * @memberOf module:ControlFlow
- * @method
- * @see [async.times]{@link module:ControlFlow.times}
- * @category Control Flow
- * @param {number} n - The number of times to run the function.
- * @param {AsyncFunction} iteratee - The async function to call `n` times.
- * Invoked with the iteration index and a callback: (n, next).
- * @param {Function} callback - see {@link module:Collections.map}.
- * @returns {Promise} a promise, if no callback is provided
- */
-function timesSeries(n, iteratee, callback) {
-    return (0, _timesLimit2.default)(n, 1, iteratee, callback);
-}
-module.exports = exports.default;

package/node_modules/async/transform.js

@@ -1,173 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = transform;
-
-var _eachOf = require('./eachOf.js');
-
-var _eachOf2 = _interopRequireDefault(_eachOf);
-
-var _once = require('./internal/once.js');
-
-var _once2 = _interopRequireDefault(_once);
-
-var _wrapAsync = require('./internal/wrapAsync.js');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-var _promiseCallback = require('./internal/promiseCallback.js');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * A relative of `reduce`.  Takes an Object or Array, and iterates over each
- * element in parallel, each step potentially mutating an `accumulator` value.
- * The type of the accumulator defaults to the type of collection passed in.
- *
- * @name transform
- * @static
- * @memberOf module:Collections
- * @method
- * @category Collection
- * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
- * @param {*} [accumulator] - The initial state of the transform.  If omitted,
- * it will default to an empty Object or Array, depending on the type of `coll`
- * @param {AsyncFunction} iteratee - A function applied to each item in the
- * collection that potentially modifies the accumulator.
- * Invoked with (accumulator, item, key, callback).
- * @param {Function} [callback] - A callback which is called after all the
- * `iteratee` functions have finished. Result is the transformed accumulator.
- * Invoked with (err, result).
- * @returns {Promise} a promise, if no callback provided
- * @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
- *
- * // helper function that returns human-readable size format from bytes
- * function formatBytes(bytes, decimals = 2) {
- *   // implementation not included for brevity
- *   return humanReadbleFilesize;
- * }
- *
- * const fileList = ['file1.txt','file2.txt','file3.txt'];
- *
- * // asynchronous function that returns the file size, transformed to human-readable format
- * // e.g. 1024 bytes = 1KB, 1234 bytes = 1.21 KB, 1048576 bytes = 1MB, etc.
- * function transformFileSize(acc, value, key, callback) {
- *     fs.stat(value, function(err, stat) {
- *         if (err) {
- *             return callback(err);
- *         }
- *         acc[key] = formatBytes(stat.size);
- *         callback(null);
- *     });
- * }
- *
- * // Using callbacks
- * async.transform(fileList, transformFileSize, function(err, result) {
- *     if(err) {
- *         console.log(err);
- *     } else {
- *         console.log(result);
- *         // [ '1000 Bytes', '1.95 KB', '2.93 KB' ]
- *     }
- * });
- *
- * // Using Promises
- * async.transform(fileList, transformFileSize)
- * .then(result => {
- *     console.log(result);
- *     // [ '1000 Bytes', '1.95 KB', '2.93 KB' ]
- * }).catch(err => {
- *     console.log(err);
- * });
- *
- * // Using async/await
- * (async () => {
- *     try {
- *         let result = await async.transform(fileList, transformFileSize);
- *         console.log(result);
- *         // [ '1000 Bytes', '1.95 KB', '2.93 KB' ]
- *     }
- *     catch (err) {
- *         console.log(err);
- *     }
- * })();
- *
- * @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
- *
- * // helper function that returns human-readable size format from bytes
- * function formatBytes(bytes, decimals = 2) {
- *   // implementation not included for brevity
- *   return humanReadbleFilesize;
- * }
- *
- * const fileMap = { f1: 'file1.txt', f2: 'file2.txt', f3: 'file3.txt' };
- *
- * // asynchronous function that returns the file size, transformed to human-readable format
- * // e.g. 1024 bytes = 1KB, 1234 bytes = 1.21 KB, 1048576 bytes = 1MB, etc.
- * function transformFileSize(acc, value, key, callback) {
- *     fs.stat(value, function(err, stat) {
- *         if (err) {
- *             return callback(err);
- *         }
- *         acc[key] = formatBytes(stat.size);
- *         callback(null);
- *     });
- * }
- *
- * // Using callbacks
- * async.transform(fileMap, transformFileSize, function(err, result) {
- *     if(err) {
- *         console.log(err);
- *     } else {
- *         console.log(result);
- *         // { f1: '1000 Bytes', f2: '1.95 KB', f3: '2.93 KB' }
- *     }
- * });
- *
- * // Using Promises
- * async.transform(fileMap, transformFileSize)
- * .then(result => {
- *     console.log(result);
- *     // { f1: '1000 Bytes', f2: '1.95 KB', f3: '2.93 KB' }
- * }).catch(err => {
- *     console.log(err);
- * });
- *
- * // Using async/await
- * async () => {
- *     try {
- *         let result = await async.transform(fileMap, transformFileSize);
- *         console.log(result);
- *         // { f1: '1000 Bytes', f2: '1.95 KB', f3: '2.93 KB' }
- *     }
- *     catch (err) {
- *         console.log(err);
- *     }
- * }
- *
- */
-function transform(coll, accumulator, iteratee, callback) {
-    if (arguments.length <= 3 && typeof accumulator === 'function') {
-        callback = iteratee;
-        iteratee = accumulator;
-        accumulator = Array.isArray(coll) ? [] : {};
-    }
-    callback = (0, _once2.default)(callback || (0, _promiseCallback.promiseCallback)());
-    var _iteratee = (0, _wrapAsync2.default)(iteratee);
-
-    (0, _eachOf2.default)(coll, (v, k, cb) => {
-        _iteratee(accumulator, v, k, cb);
-    }, err => callback(err, accumulator));
-    return callback[_promiseCallback.PROMISE_SYMBOL];
-}
-module.exports = exports.default;

package/node_modules/async/tryEach.js

@@ -1,78 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-
-var _eachSeries = require('./eachSeries.js');
-
-var _eachSeries2 = _interopRequireDefault(_eachSeries);
-
-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 }; }
-
-/**
- * It runs each task in series but stops whenever any of the functions were
- * successful. If one of the tasks were successful, the `callback` will be
- * passed the result of the successful task. If all tasks fail, the callback
- * will be passed the error and result (if any) of the final attempt.
- *
- * @name tryEach
- * @static
- * @memberOf module:ControlFlow
- * @method
- * @category Control Flow
- * @param {Array|Iterable|AsyncIterable|Object} tasks - A collection containing functions to
- * run, each function is passed a `callback(err, result)` it must call on
- * completion with an error `err` (which can be `null`) and an optional `result`
- * value.
- * @param {Function} [callback] - An optional callback which is called when one
- * of the tasks has succeeded, or all have failed. It receives the `err` and
- * `result` arguments of the last attempt at completing the `task`. Invoked with
- * (err, results).
- * @returns {Promise} a promise, if no callback is passed
- * @example
- * async.tryEach([
- *     function getDataFromFirstWebsite(callback) {
- *         // Try getting the data from the first website
- *         callback(err, data);
- *     },
- *     function getDataFromSecondWebsite(callback) {
- *         // First website failed,
- *         // Try getting the data from the backup website
- *         callback(err, data);
- *     }
- * ],
- * // optional callback
- * function(err, results) {
- *     Now do something with the data.
- * });
- *
- */
-function tryEach(tasks, callback) {
-    var error = null;
-    var result;
-    return (0, _eachSeries2.default)(tasks, (task, taskCb) => {
-        (0, _wrapAsync2.default)(task)((err, ...args) => {
-            if (err === false) return taskCb(err);
-
-            if (args.length < 2) {
-                [result] = args;
-            } else {
-                result = args;
-            }
-            error = err;
-            taskCb(err ? null : {});
-        });
-    }, () => callback(error, result));
-}
-
-exports.default = (0, _awaitify2.default)(tryEach);
-module.exports = exports.default;

package/node_modules/async/unmemoize.js

@@ -1,25 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = unmemoize;
-/**
- * Undoes a [memoize]{@link module:Utils.memoize}d function, reverting it to the original,
- * unmemoized form. Handy for testing.
- *
- * @name unmemoize
- * @static
- * @memberOf module:Utils
- * @method
- * @see [async.memoize]{@link module:Utils.memoize}
- * @category Util
- * @param {AsyncFunction} fn - the memoized function
- * @returns {AsyncFunction} a function that calls the original unmemoized function
- */
-function unmemoize(fn) {
-    return (...args) => {
-        return (fn.unmemoized || fn)(...args);
-    };
-}
-module.exports = exports.default;