first commit

node_modules/recharts-scale/es6/util/arithmetic.js

@@ -0,0 +1,103 @@
+/**
+ * @fileOverview 一些公用的运算方法
+ * @author xile611
+ * @date 2015-09-17
+ */
+import Decimal from 'decimal.js-light';
+import { curry } from './utils';
+/**
+ * 获取数值的位数
+ * 其中绝对值属于区间[0.1, 1)， 得到的值为0
+ * 绝对值属于区间[0.01, 0.1)，得到的位数为 -1
+ * 绝对值属于区间[0.001, 0.01)，得到的位数为 -2
+ *
+ * @param  {Number} value 数值
+ * @return {Integer} 位数
+ */
+
+function getDigitCount(value) {
+  var result;
+
+  if (value === 0) {
+    result = 1;
+  } else {
+    result = Math.floor(new Decimal(value).abs().log(10).toNumber()) + 1;
+  }
+
+  return result;
+}
+/**
+ * 按照固定的步长获取[start, end)这个区间的数据
+ * 并且需要处理js计算精度的问题
+ *
+ * @param  {Decimal} start 起点
+ * @param  {Decimal} end   终点，不包含该值
+ * @param  {Decimal} step  步长
+ * @return {Array}         若干数值
+ */
+
+
+function rangeStep(start, end, step) {
+  var num = new Decimal(start);
+  var i = 0;
+  var result = []; // magic number to prevent infinite loop
+
+  while (num.lt(end) && i < 100000) {
+    result.push(num.toNumber());
+    num = num.add(step);
+    i++;
+  }
+
+  return result;
+}
+/**
+ * 对数值进行线性插值
+ *
+ * @param  {Number} a  定义域的极点
+ * @param  {Number} b  定义域的极点
+ * @param  {Number} t  [0, 1]内的某个值
+ * @return {Number}    定义域内的某个值
+ */
+
+
+var interpolateNumber = curry(function (a, b, t) {
+  var newA = +a;
+  var newB = +b;
+  return newA + t * (newB - newA);
+});
+/**
+ * 线性插值的逆运算
+ *
+ * @param  {Number} a 定义域的极点
+ * @param  {Number} b 定义域的极点
+ * @param  {Number} x 可以认为是插值后的一个输出值
+ * @return {Number}   当x在 a ~ b这个范围内时，返回值属于[0, 1]
+ */
+
+var uninterpolateNumber = curry(function (a, b, x) {
+  var diff = b - +a;
+  diff = diff || Infinity;
+  return (x - a) / diff;
+});
+/**
+ * 线性插值的逆运算，并且有截断的操作
+ *
+ * @param  {Number} a 定义域的极点
+ * @param  {Number} b 定义域的极点
+ * @param  {Number} x 可以认为是插值后的一个输出值
+ * @return {Number}   当x在 a ~ b这个区间内时，返回值属于[0, 1]，
+ * 当x不在 a ~ b这个区间时，会截断到 a ~ b 这个区间
+ */
+
+var uninterpolateTruncation = curry(function (a, b, x) {
+  var diff = b - +a;
+  diff = diff || Infinity;
+  return Math.max(0, Math.min(1, (x - a) / diff));
+});
+export default {
+  rangeStep: rangeStep,
+  getDigitCount: getDigitCount,
+  interpolateNumber: interpolateNumber,
+  uninterpolateNumber: uninterpolateNumber,
+  uninterpolateTruncation: uninterpolateTruncation
+};

node_modules/recharts-scale/es6/util/utils.js

@@ -0,0 +1,132 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+var identity = function identity(i) {
+  return i;
+};
+
+export var PLACE_HOLDER = {
+  '@@functional/placeholder': true
+};
+
+var isPlaceHolder = function isPlaceHolder(val) {
+  return val === PLACE_HOLDER;
+};
+
+var curry0 = function curry0(fn) {
+  return function _curried() {
+    if (arguments.length === 0 || arguments.length === 1 && isPlaceHolder(arguments.length <= 0 ? undefined : arguments[0])) {
+      return _curried;
+    }
+
+    return fn.apply(void 0, arguments);
+  };
+};
+
+var curryN = function curryN(n, fn) {
+  if (n === 1) {
+    return fn;
+  }
+
+  return curry0(function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    var argsLength = args.filter(function (arg) {
+      return arg !== PLACE_HOLDER;
+    }).length;
+
+    if (argsLength >= n) {
+      return fn.apply(void 0, args);
+    }
+
+    return curryN(n - argsLength, curry0(function () {
+      for (var _len2 = arguments.length, restArgs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        restArgs[_key2] = arguments[_key2];
+      }
+
+      var newArgs = args.map(function (arg) {
+        return isPlaceHolder(arg) ? restArgs.shift() : arg;
+      });
+      return fn.apply(void 0, _toConsumableArray(newArgs).concat(restArgs));
+    }));
+  });
+};
+
+export var curry = function curry(fn) {
+  return curryN(fn.length, fn);
+};
+export var range = function range(begin, end) {
+  var arr = [];
+
+  for (var i = begin; i < end; ++i) {
+    arr[i - begin] = i;
+  }
+
+  return arr;
+};
+export var map = curry(function (fn, arr) {
+  if (Array.isArray(arr)) {
+    return arr.map(fn);
+  }
+
+  return Object.keys(arr).map(function (key) {
+    return arr[key];
+  }).map(fn);
+});
+export var compose = function compose() {
+  for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+    args[_key3] = arguments[_key3];
+  }
+
+  if (!args.length) {
+    return identity;
+  }
+
+  var fns = args.reverse(); // first function can receive multiply arguments
+
+  var firstFn = fns[0];
+  var tailsFn = fns.slice(1);
+  return function () {
+    return tailsFn.reduce(function (res, fn) {
+      return fn(res);
+    }, firstFn.apply(void 0, arguments));
+  };
+};
+export var reverse = function reverse(arr) {
+  if (Array.isArray(arr)) {
+    return arr.reverse();
+  } // can be string
+
+
+  return arr.split('').reverse.join('');
+};
+export var memoize = function memoize(fn) {
+  var lastArgs = null;
+  var lastResult = null;
+  return function () {
+    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+      args[_key4] = arguments[_key4];
+    }
+
+    if (lastArgs && args.every(function (val, i) {
+      return val === lastArgs[i];
+    })) {
+      return lastResult;
+    }
+
+    lastArgs = args;
+    lastResult = fn.apply(void 0, args);
+    return lastResult;
+  };
+};