This is my own library which has some helper function

RjLib.js

(function (root, factory) {
  if(typeof define === "function" && define.amd) {
    // Now we're wrapping the factory and assigning the return
    // value to the root (window) and returning it as well to
    // the AMD loader.
    define([""], function(postal){
      return (root.RjLib = factory(postal));
    });
  } else if(typeof module === "object" && module.exports) {
    // I've not encountered a need for this yet, since I haven't
    // run into a scenario where plain modules depend on CommonJS
    // *and* I happen to be loading in a CJS browser environment
    // but I'm including it for the sake of being thorough
    module.exports = (root.RjLib = factory(require("")));
  } else {
    root.RjLib = factory(root.postal);
  }
}(this, function() {
  // Defining private  variables
  var privateValue = '';

  /* This function takes object and return 'true' if
  ** it is a object and 'false' when it is not object
  **
  ** @params obj : Object
  **
  */

  function isObject(obj){
    return (typeof obj === 'object');
  }

  /* This function takes val and return 'true' if
  ** it is a number and 'false' when it is not number
  **
  ** @params val : Value
  **
  */
  function isNumber(val){
    return (typeof val === 'number');
  }

  /* This function takes val and return 'true' if
  ** it is a string and 'false' when it is not string
  **
  ** @params val : Value
  **
  */

  function isString(val){
    return (typeof val === 'string');
  }

  /* This function takes val and return 'true' if
  ** it is a boolean and 'false' when it is not boolean
  **
  ** @params val : Value
  **
  */

  function isBoolean(val){
    return (typeof val === 'boolean');
  }

  /* This function takes val and return 'true' if
  ** it is a function and 'false' when it is not function
  **
  ** @params val : Value
  **
  */

  function isFunction(val){
    return (typeof val === 'function');
  }

  /* This function takes val and return 'true' if
  ** it is a undefined and 'false' when it is not undefined
  **
  ** @params val : Value
  **
  */

  function isUndefined(val){
    return (typeof val === undefined);
  }

  /* This function takes val and return 'true' if
  ** it is an array and 'false' when it is not an array
  **
  ** @params val : Value (array) [not mixed array]
  **
  */

  function isArray(arr){
    return Array.isArray(arr);
  }

  /* This function takes val and return 'true' if
  ** it is an number is less than zero and return
  ** 'false' when it is biger than zero
  **
  ** @params val : Value (array) [not mixed array]
  **
  */

  function isNegative(val){
    return (val < 0) ;
  }
  /*
  ** This function traverse object upto one level
  ** and return true if it is a object otherwise
  ** it returns false for non-object
  **
  ** @params obj : Object
  ** @params callback : Callback
  **
  ** The callback returns following prams in fn
  ** @params err : Error
  ** @params key : Object Key
  ** @params Boolean : true/false
  */

  function traverseObjectLayerOne(obj,callback){
    // local private object
    var _obj = obj;
    Object.keys(_obj).forEach(function(item,index){
      (_obj[item] !== '' && _obj[item] !== undefined) ? callback(null,item,isObject(_obj[item])) : callback(item + ' has no values',null,null);
    });
  }

  /*
  ** This function traverse object till end it
  ** return true if it is a object otherwise it
  ** returns false for non-object
  **
  ** @params obj : Object
  ** @params callback : Callback
  **
  ** The callback returns following prams in fn
  ** @params err : Error
  ** @params key : Object Key
  ** @params Boolean : true/false
  */

  function traverseObjectFull(obj, callback) {
    Object.keys(obj).forEach(function(value){
      if (isObject(obj[value])) {
        traverseObjectFull(obj[value],callback);
        callback(null,value,true);
      }
      else {
        callback(null,value,false)
      }
    });
  }

  /*
  ** This function traverse object till end
  ** and returns leaf element of that object
  **
  ** @params obj : Object
  ** @params callback : Callback
  **
  ** The callback returns following prams in fn
  ** @params err : Error
  ** @params key : Object Key
  ** @params Boolean : Object value
  */

  function collectLeafNodes(obj,callback){
    Object.keys(obj).forEach(function(value){
      if (isObject(obj[value])) {
        collectLeafNodes(obj[value],callback);
      }else {
        callback(null,value,obj[value]);
      }
    });
  }

  /*
  ** This function is deciding whether array is either
  ** 2D or 1D or array is fully proper array or not.
  ** @params args taking arguments
  ** @params arg[0] : Array
  ** @params arg[1] : callback function
  */

  function arrayDimention(){
    var args = Array.prototype.slice.call(arguments);
    return (args[0].length === 0) ? args[1]('Array is empty') : args[1](f1(args[0]));
  }

  function f1(arr){
    var arrr = [];
    for(var i in arr){
      arrr.push(Array.isArray(arr[i]));
    }
    return (arrr.indexOf(true) > -1) ? (arrr.indexOf(false) > -1) ? 'Please check your array' : '2D' : '1D';
  }


  ////////////

  function isNumberNegative(object){
    return isNumber(object) ? (isNegative(object) ? true : false) : false;
  }

  function isStringNumber(object){
    return isString(object) ? (isNegative(object) ? true : false) : false;
  }

  function isMixedArray(array){
    return (
      array.map(function(element){
        return isNumber(element);
      }).indexOf(false) > 0 ? true : false
    );
  }

  function removeNegativeArrayElement(arr){
    return (
      arr.filter(function(val) {
        return (isString(val) ? false : (isNegative(val) ? false : true))
      })
    );
  }
  
  function removeNegativeFn(obj) {
    var _newObj = {};
    Object.keys(obj).forEach(function(value){
      if(isNumber(obj[value])) return ((isNumberNegative(obj[value])) ? false : _newObj[value] = obj[value]);
      else if(isString(obj[value])) return (isStringNumber(obj[value]) ? false : _newObj[value] = obj[value]);
      else if(isArray(obj[value])) return (isMixedArray(obj[value]) ? _newObj[value] = removeNegativeArrayElement(obj[value]) : _newObj[value] = removeNegativeArrayElement(obj[value]));
      else if(isObject(obj[value]) ? _newObj[value] = removeNegativeFn(obj[value]) : false);
      else _newObj[value] = obj[value];
    });
    return _newObj;
  }
  ////////////

  /*
  ** This function remove negative element form object
  ** also it remove negative value form array
  ** @params args taking arguments
  ** @params arg[0] : Array
  ** @params arg[1] : callback function
  */

  function removeNegativeFromObject(obj,callback){
    var returnobj = removeNegativeFn(obj);
    (Object.keys(returnobj).length !== 0) ? callback(null,returnobj) : false;
  }

  ///////////////
  function arrayFilter(arr,ll,ul,equility){
    return (
      arr.filter(function(element){
        return (
          (equility) ? ((element <= ul) ? ((ll <= element) ? element : false) : false ):((element < ul) ? ((ll < element) ? element : false) : false )
        );
      })
    );
  }
  /////////

  /*
  ** This function returns element form array by using rules
  ** @params args taking following arguments
  ** @params arg[0] : Array
  ** @params arg[1] : Rules (String) ['1-7'] { 1 = lower limit , 7 = upper limit }
  ** @parms args[2] : Equility to lower and upper limit
  */

  function arrayFilterByrules(arr,rulesArr,equility,callback){
    rulesArr.map(function(ele){
      var limitArr = ele.split("-");
      var lowerLimit = parseInt(limitArr[0]);
      var upperLimit = parseInt(limitArr[1]);
      (upperLimit > lowerLimit) ? callback(null,arrayFilter(arr,lowerLimit,upperLimit,equility)) : callback("Please check rules collection",null);
    });
  }

  /*
  ** This function returns json data according to user 
  ** gives params and number of records they want
  ** @params args taking following arguments
  ** @params arg[0] : JSON data
  ** @params arg[1] : Rules (String Array)
  ** @parms args[2] : Number of records 
  ** @parms args[3] : Callback (err,data)
  */
  
  function filterJson(data,rules,take,callback){
    var i = 0;
    var _data = data;
    var _newDataSet = [];

    take = (take == undefined) ? _data.length : take;

    while(i < take){
      Object.keys(_data[i]).forEach(function(ele){
        (rules.indexOf(ele) === -1) ? delete _data[i][ele] : false;
      });
      _newDataSet.push(_data[i]);
      i++;
    }
    callback(null,_newDataSet);
  }
  
  /*
  ** This function returns json data according to user 
  ** gives params and number of records is random if 
  ** user not given but if user give some index then
  ** it returns of that index data
  ** @params args taking following arguments
  ** @params arg[0] : JSON data
  ** @params arg[1] : Rules (String Array)
  ** @parms args[2] : Number of records 
  ** @parms args[3] : Callback (err,data)
  */
  
  function filterJsonByRandomTake(data,rules,take,callback){
      var _data = data;

      take = (take == undefined) ? Math.floor(Math.random() * _data.length) : take;

      Object.keys(_data[take]).forEach(function(ele){
        (rules.indexOf(ele) === -1) ? delete _data[take][ele] : false;
      });

      callback(null,_data[take]);
  }
  
  /*
  ** (Returning the modular object)
  ** This Object name is this module name and
  ** it returning public methods to be accessable
  */

  var RjLib = {
    // returning public function
    traverseObjectLayerOne : traverseObjectLayerOne,
    traverseObjectFull : traverseObjectFull,
    arrayDimention : arrayDimention,
    filterJson: filterJson,
    filterJsonByRandomTake: filterJsonByRandomTake,
    collectLeafNodes : collectLeafNodes,
    arrayFilterByrules: arrayFilterByrules,
    removeNegativeFromObject : removeNegativeFromObject,
    removeNegativeArrayElement: removeNegativeArrayElement
  };

  return RjLib;
}));