js-web-tools/lib/balancer.js

Tools for Javascript develpers

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.indexOfMinOrMax = indexOfMinOrMax;
exports["default"] = balancer;

function isNumber(input) {
  return !isNaN(parseInt(input, 10)) && !isNaN(Number(input));
}

function indexOfMinOrMax() {
  var arr = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
  var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'min';

  if (arr.length === 0) {
    return -1;
  }

  var tmpVal = arr[0];
  var targetIndex = 0;
  arr.forEach(function (num, index) {
    if (type === 'min') {
      if (num < tmpVal) {
        targetIndex = index;
        tmpVal = num;
      }
    } else {
      if (num > tmpVal) {
        targetIndex = index;
        tmpVal = num;
      }
    }
  });
  return targetIndex;
}

function sumTotal(list) {
  return list.reduce(function (val, num) {
    val += Number(num);
    return val;
  }, 0);
}

function convertToFactors(list) {
  var total = sumTotal(list);
  return list.map(function (l) {
    return l / total;
  });
}

function round(number, places) {
  var multiplier = Math.pow(10, places);
  return Math.round(number * multiplier) / multiplier;
}

function roundEach(list, places) {
  return list.map(function (num) {
    return round(num, places);
  });
}

function balancer() {
  var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
  var goal = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100;
  var places = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 10;

  if (data.length === 0) {
    return [];
  }

  if (data.every(function (v) {
    return v === 0;
  })) {
    return data;
  }

  var list = data.filter(function (num) {
    return isNumber(num);
  });
  var outList = roundEach(list, places);
  var factors = convertToFactors(list);
  goal = round(goal, places);
  var sum = round(sumTotal(outList), places);
  var oldDiff = null;

  while (goal !== sum) {
    var diff = goal - sum;

    if (oldDiff == diff) {
      var idx = diff < 0 ? indexOfMinOrMax(factors, 'max') : indexOfMinOrMax(factors);
      outList[idx] += round(diff, places);
    } else {
      for (var i = 0; i < factors.length; i += 1) {
        outList[i] += round(diff * factors[i], places);
      }
    }

    sum = round(sumTotal(outList), places);
    oldDiff = diff;
  }

  return roundEach(outList, places);
}