v1.0 with SW PWA enabled

frontend/node_modules/recharts/es6/util/DataUtils.js

@@ -0,0 +1,170 @@
+import isString from 'lodash/isString';
+import isNan from 'lodash/isNaN';
+import get from 'lodash/get';
+import lodashIsNumber from 'lodash/isNumber';
+import isNil from 'lodash/isNil';
+export var mathSign = function mathSign(value) {
+  if (value === 0) {
+    return 0;
+  }
+  if (value > 0) {
+    return 1;
+  }
+  return -1;
+};
+export var isPercent = function isPercent(value) {
+  return isString(value) && value.indexOf('%') === value.length - 1;
+};
+export var isNumber = function isNumber(value) {
+  return lodashIsNumber(value) && !isNan(value);
+};
+export var isNullish = function isNullish(value) {
+  return isNil(value);
+};
+export var isNumOrStr = function isNumOrStr(value) {
+  return isNumber(value) || isString(value);
+};
+var idCounter = 0;
+export var uniqueId = function uniqueId(prefix) {
+  var id = ++idCounter;
+  return "".concat(prefix || '').concat(id);
+};
+
+/**
+ * Get percent value of a total value
+ * @param {number|string} percent A percent
+ * @param {number} totalValue     Total value
+ * @param {number} defaultValue   The value returned when percent is undefined or invalid
+ * @param {boolean} validate      If set to be true, the result will be validated
+ * @return {number} value
+ */
+export var getPercentValue = function getPercentValue(percent, totalValue) {
+  var defaultValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var validate = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  if (!isNumber(percent) && !isString(percent)) {
+    return defaultValue;
+  }
+  var value;
+  if (isPercent(percent)) {
+    var index = percent.indexOf('%');
+    value = totalValue * parseFloat(percent.slice(0, index)) / 100;
+  } else {
+    value = +percent;
+  }
+  if (isNan(value)) {
+    value = defaultValue;
+  }
+  if (validate && value > totalValue) {
+    value = totalValue;
+  }
+  return value;
+};
+export var getAnyElementOfObject = function getAnyElementOfObject(obj) {
+  if (!obj) {
+    return null;
+  }
+  var keys = Object.keys(obj);
+  if (keys && keys.length) {
+    return obj[keys[0]];
+  }
+  return null;
+};
+export var hasDuplicate = function hasDuplicate(ary) {
+  if (!Array.isArray(ary)) {
+    return false;
+  }
+  var len = ary.length;
+  var cache = {};
+  for (var i = 0; i < len; i++) {
+    if (!cache[ary[i]]) {
+      cache[ary[i]] = true;
+    } else {
+      return true;
+    }
+  }
+  return false;
+};
+
+/* @todo consider to rename this function into `getInterpolator` */
+export var interpolateNumber = function interpolateNumber(numberA, numberB) {
+  if (isNumber(numberA) && isNumber(numberB)) {
+    return function (t) {
+      return numberA + t * (numberB - numberA);
+    };
+  }
+  return function () {
+    return numberB;
+  };
+};
+export function findEntryInArray(ary, specifiedKey, specifiedValue) {
+  if (!ary || !ary.length) {
+    return null;
+  }
+  return ary.find(function (entry) {
+    return entry && (typeof specifiedKey === 'function' ? specifiedKey(entry) : get(entry, specifiedKey)) === specifiedValue;
+  });
+}
+
+/**
+ * The least square linear regression
+ * @param {Array} data The array of points
+ * @returns {Object} The domain of x, and the parameter of linear function
+ */
+export var getLinearRegression = function getLinearRegression(data) {
+  if (!data || !data.length) {
+    return null;
+  }
+  var len = data.length;
+  var xsum = 0;
+  var ysum = 0;
+  var xysum = 0;
+  var xxsum = 0;
+  var xmin = Infinity;
+  var xmax = -Infinity;
+  var xcurrent = 0;
+  var ycurrent = 0;
+  for (var i = 0; i < len; i++) {
+    xcurrent = data[i].cx || 0;
+    ycurrent = data[i].cy || 0;
+    xsum += xcurrent;
+    ysum += ycurrent;
+    xysum += xcurrent * ycurrent;
+    xxsum += xcurrent * xcurrent;
+    xmin = Math.min(xmin, xcurrent);
+    xmax = Math.max(xmax, xcurrent);
+  }
+  var a = len * xxsum !== xsum * xsum ? (len * xysum - xsum * ysum) / (len * xxsum - xsum * xsum) : 0;
+  return {
+    xmin: xmin,
+    xmax: xmax,
+    a: a,
+    b: (ysum - a * xsum) / len
+  };
+};
+
+/**
+ * Compare values.
+ *
+ * This function is intended to be passed to `Array.prototype.sort()`. It properly compares generic homogeneous arrays that are either `string[]`,
+ * `number[]`, or `Date[]`. When comparing heterogeneous arrays or homogeneous arrays of other types, it will attempt to compare items properly but
+ * will fall back to string comparison for mismatched or unsupported types.
+ *
+ * For some background, `Array.prototype.sort()`'s default comparator coerces each of the array's items into a string and compares the strings. This
+ * often leads to undesirable behavior, especially with numerical items.
+ *
+ * @param {unknown} a The first item to compare
+ * @param {unknown} b The second item to compare
+ * @return {number} A negative number if a < b, a positive number if a > b, 0 if equal
+ */
+export var compareValues = function compareValues(a, b) {
+  if (isNumber(a) && isNumber(b)) {
+    return a - b;
+  }
+  if (isString(a) && isString(b)) {
+    return a.localeCompare(b);
+  }
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() - b.getTime();
+  }
+  return String(a).localeCompare(String(b));
+};