compiled files updated

Author: ashah-splunk

client/splunk.js

@@ -23172,7 +23172,7 @@ exports.Highcharts = {
      * @function splunkjs.Utils
      */
     root.indexOf = function(arr, search) {
-        for(var i=0; i<arr.length; i++) {
+        for(let i=0; i<arr.length; i++) {
             if (arr[i] === search) {
                 return i;
             }
@@ -23214,7 +23214,7 @@ exports.Highcharts = {
      * @function splunkjs.Utils
      */
     root.startsWith = function(original, prefix) {
-        var matches = original.match("^" + prefix);
+        let matches = original.match("^" + prefix);
         return matches && matches.length > 0 && matches[0] === prefix;  
     };
 
@@ -23232,7 +23232,7 @@ exports.Highcharts = {
      * @function splunkjs.Utils
      */
     root.endsWith = function(original, suffix) {
-        var matches = original.match(suffix + "$");
+        let matches = original.match(suffix + "$");
         return matches && matches.length > 0 && matches[0] === suffix;  
     };
 
@@ -23373,7 +23373,7 @@ exports.Highcharts = {
             return obj.length === 0;
         }
 
-        for (var key in obj) {
+        for (let key in obj) {
             if (this.hasOwnProperty.call(obj, key)) {
                 return false;
             }
@@ -23403,14 +23403,14 @@ exports.Highcharts = {
             obj.forEach(iterator, context);
         } 
         else if (obj.length === +obj.length) {
-            for (var i = 0, l = obj.length; i < l; i++) {
+            for (let i = 0, l = obj.length; i < l; i++) {
                 if (i in obj && iterator.call(context, obj[i], i, obj) === {}) {
                     return;
                 }
             }
         } 
         else {
-            for (var key in obj) {
+            for (let key in obj) {
                 if (obj.hasOwnProperty(key)) {
                     if (iterator.call(context, obj[key], key, obj) === {}) {
                         return;
@@ -23437,7 +23437,7 @@ exports.Highcharts = {
      */
     root.extend = function(obj) {
         root.forEach(Array.prototype.slice.call(arguments, 1), function(source) {
-            for (var prop in source) {
+            for (let prop in source) {
                 obj[prop] = source[prop];
             }
         });
@@ -23499,7 +23499,7 @@ exports.Highcharts = {
       * @function splunkjs.Utils
       */
     root.keyOf = function(val, obj) {
-        for (var k in obj) {
+        for (let k in obj) {
             if (obj.hasOwnProperty(k) && obj[k] === val) {
                 return k;
             }
@@ -23518,7 +23518,7 @@ exports.Highcharts = {
      */
     root.getWithVersion = function(version, map) {
         map = map || {};
-        var currentVersion = (version + "") || "";
+        let currentVersion = (version + "") || "";
         while (currentVersion !== "") {
             if (map.hasOwnProperty(currentVersion)) {
                 return map[currentVersion];
@@ -23561,6 +23561,313 @@ exports.Highcharts = {
         return fs.readFileSync(path.resolve(filename, relativePath)).toString();
     };
 
+    /**
+     * can make a function to pause execution for a fixed amount of time
+     *
+     * @example
+     * 
+     *      await Utils.sleep(1000);
+     * 
+     * @param {Number} ms The timeout period, in milliseconds.
+     *
+     * @function splunkjs.Utils
+     */
+    root.sleep = function (ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+
+    /**
+     * Runs an asynchronous `while` loop.
+     *
+     * @example
+     *      
+     *      let i = 0;
+     *      try {
+     *          await Utils.whilst(
+     *              function() { return i++ < 3; },
+     *              async function() {
+     *                  await Utils.sleep(0);
+     *              });
+     *      } catch(err) {
+     *          console.log(err);
+     *      }
+     *
+     * @param {Function} condition A function that returns a _boolean_ indicating whether the condition has been met.
+     * @param {Function} body A function that runs the body of the loop.
+     *
+     * @function splunkjs.Utils
+     */
+    root.whilst = async function(condition, body){
+        condition = condition || function() { return false; };
+        body = body || function() { return; };
+
+        let iterationDone = function(err) {
+            if (err) {
+                throw err;
+            }
+            else {
+                return root.whilst(condition, body);
+            }
+        };
+
+        if(condition()){
+            return iterationDone(await body())
+        }else{
+            return null;
+        }
+    }
+
+    /**
+     * Runs multiple functions (tasks) in parallel. 
+     * Each task takes the function as a parameter. 
+     * When all tasks have been completed or if an error occurs, the 
+     * function returns a combined results of all tasks. 
+     *
+     * **Note**: Tasks might not be run in the same order as they appear in the array,
+     * but the results will be returned in that order. 
+     *
+     * @example
+     *      
+     *      let [err, one, two] = await Utils.parallel([
+     *          function() {
+     *              return [null, 1];
+     *          },
+     *          function() {
+     *              return [null, 2, 3];
+     *          }]
+     *      );
+     *      console.log(err); // == null
+     *      console.log(one); // == 1
+     *      console.log(two); // == [1,2]
+     *
+     * @param {Function} tasks An array of functions.
+     * @param {Boolean} fromMap set to true when method call is made from parallerMap function. (optional)
+     *
+     * @function splunkjs.Utils
+     */
+    root.parallel = async function (tasks, fromMap) {
+        let res = [];
+        if(!root.isArray(tasks) && root.isFunction(fromMap)){
+            let taskList = [];
+            Object.keys(arguments).forEach(key => {
+                taskList.push(arguments[key]);
+            });
+            tasks = taskList;
+            fromMap = false;
+        }
+        for(let task of tasks) {
+            let result = task();
+            res.push(result);
+        }
+        let result = await Promise.all(res);
+        let response = [];
+        for(let resp of result){
+            if(resp){
+                if(resp[0]){
+                    return [resp[0], null];
+                }
+                if(resp.length > 2){
+                    response.push(resp.slice(1));
+                }else{
+                    response.push(resp[1]);
+                }
+            }
+        }
+        return fromMap ? [null, response] : [null, ...response];
+    }
+
+    /**
+     * Runs an asynchronous function (mapping it) over each element in an array, in parallel.
+     * When all tasks have been completed or if an error occurs, function
+     * returns the resulting array.
+     *
+     * @example
+     *      
+     *      let [err, vals] = await Utils.parallelMap(
+     *          [1, 2, 3],
+     *          async function(val, idx) { 
+     *              if (val === 2) {
+     *                  await Utils.sleep(100);
+     *                  return [null, val+1];
+     *               }
+     *              else {
+     *                  return [null, val + 1];
+     *              }
+     *          });
+     *      console.log(vals); // == [2,3,4]
+     *
+     * @param {Array} vals An array of values.
+     * @param {Function} fn A function (possibly asynchronous) to apply to each element. 
+     *
+     * @function splunkjs.Utils
+     */
+    root.parallelMap = async function (vals, fn) {
+        vals = vals || [];
+        let tasks = [];
+        let createTask = function(val, idx) {
+            return function() { return fn(val, idx); };
+        };
+        
+        for(let i = 0; i < vals.length; i++) {
+            tasks.push(createTask(vals[i], i));
+        }
+        return await root.parallel(tasks, true);
+    }
+
+    /**
+     * Applies an asynchronous function over each element in an array, in parallel.
+     * If an error occurs, the function returns an error.
+     *
+     * @example
+     *      
+     *      var total = 0;
+     *      let err = await Utils.parallelEach(
+     *          [1, 2, 3],
+     *          async function(val, idx) { 
+     *              var go = function() {
+     *                  total += val;
+     *              };
+     *              
+     *              if (idx === 1) {
+     *                  await Utils.sleep(100);
+     *                  go();
+     *              }
+     *              else {
+     *                  go();
+     *              }
+     *          });
+     *      console.log(total); // == 6
+     *
+     * @param {Array} vals An array of values.
+     * @param {Function} fn A function (possibly asynchronous) to apply to each element.
+     *
+     * @function splunkjs.Utils
+     */
+    root.parallelEach =  async function (vals, fn) {  
+        vals = vals || [];
+        let [err,res] = await root.parallelMap(vals, fn);
+        return err || null;
+    };
+
+    /**
+     * Runs multiple functions (tasks) in series. 
+     * Each task takes the function as a parameter. 
+     * When all tasks have been completed or if an error occurs, the 
+     * function returns the combined results of all tasks in the order
+     * they were run.
+     * 
+     * @example
+     *      
+     *      var keeper = 0;
+     *      let [err, one, two] = awiat Utils.series([
+     *          async function() {
+     *              await Utils.sleep(10);
+     *              console.log(keeper++); // == 0
+     *              return [null, 1];
+     *          },
+     *          function() {
+     *              console.log(keeper++); // == 1
+     *              return [null, 2, 3];
+     *          }]
+     *      );
+     *      console.log(err); // == null
+     *      console.log(one); // == 1
+     *      console.log(two); // == [2, 3]
+     *
+     * @param {Function} tasks An array of functions.
+     * @param {Boolean} fromMap set to true when method call is made from seriesMap function. (optional)
+     *
+     * @function splunkjs.Utils
+     */
+    root.series = async function (tasks, fromMap) {
+        let res = [];
+        if(!root.isArray(tasks)&& root.isFunction(fromMap)){
+            let taskList = [];
+            Object.keys(arguments).forEach(key => {
+                taskList.push(arguments[key]);
+            });
+            tasks = taskList;
+            fromMap = false;
+        }
+        for(let task of tasks) {
+            let result = await task();
+            if(result){
+                if(result[0]){
+                    return [result[0], null];
+                }
+                if(result.length > 2){
+                    res.push(result.slice(1));
+                }else{
+                    res.push(result[1]);
+                }
+            }
+        }
+        return fromMap ? [null, res] : [null, ...res];
+    }
+
+    /**
+     * Runs an asynchronous function (mapping it) over each element in an array, in series.
+     * When all tasks have been completed or if an error occurs, function
+     * returns the resulting array.
+     *
+     * @example
+     *      
+     *      var keeper = 1;
+     *      let [err, vals] = await Utils.seriesMap(
+     *          [1, 2, 3],
+     *          function(val, idx) { 
+     *              console.log(keeper++); // == 1, then 2, then 3
+     *              return [null, val + 1];
+     *          }
+     *      );
+     *      console.log(vals); // == [2,3,4];
+     *
+     * @param {Array} vals An array of values.
+     * @param {Function} fn A function (possibly asynchronous) to apply to each element.
+     *
+     * @function splunkjs.Utils
+     */
+    root.seriesMap = async function (vals, fn) {
+        vals = vals || [];
+        let tasks = [];
+        let createTask = function(val, idx) {
+            return function() { 
+                return fn(val, idx); 
+            };
+        };
+        for(let i = 0; i < vals.length; i++) {
+            tasks.push(createTask(vals[i], i));
+        }
+        return await root.series(tasks, true);
+    }
+
+    /**
+     * Applies an asynchronous function over each element in an array, in series.
+     * If an error occurs, the function returns an error.
+     *
+     * @example
+     *      
+     *      var results = [1, 3, 6];
+     *      var total = 0;
+     *      let err = await Utils.seriesEach(
+     *          [1, 2, 3],
+     *          function(val, idx) { 
+     *              total += val;
+     *              console.log(total === results[idx]); //== true
+     *          });
+     *      console.log(total); //== 6
+     *
+     * @param {Array} vals An array of values.
+     * @param {Function} fn A function (possibly asynchronous)to apply to each element.
+     *
+     * @function splunkjs.Utils
+     */
+    root.seriesEach = async function (vals, fn) {  
+        vals = vals || [];
+        let [err,res] = await root.seriesMap(vals, fn);
+        return err || null;
+    };
+
 })();
 },{"fs":12,"path":13}],12:[function(require,module,exports){