hekaiyu/NuclearDispersionSystem
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
d09abf7c39
NuclearDispersionSystem/ant-design-vue-jeecg/node_modules/@antv/scale/build/scale.js

2698 lines
62 KiB
JavaScript
Raw Normal View History

111
2023-09-14 14:47:11 +08:00
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define([], factory);
else if(typeof exports === 'object')
exports["scale"] = factory();
else
root["scale"] = factory();
})(typeof self !== 'undefined' ? self : this, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, {
/******/ configurable: false,
/******/ enumerable: true,
/******/ get: getter
/******/ });
/******/ }
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 13);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {
var mix = __webpack_require__(16);
var each = __webpack_require__(1);
var isObject = __webpack_require__(7);
var isNil = __webpack_require__(2);
var Scale = /*#__PURE__*/function () {
var _proto = Scale.prototype;
_proto._initDefaultCfg = function _initDefaultCfg() {
this.type = 'base';
/**
* 格式化函数,输出文本或者tick时的格式化函数
* @type {Function}
*/
this.formatter = null;
/**
* 输出的值域
* @type {Array}
*/
this.range = [0, 1];
/**
* 度量的标记
* @type {Array}
*/
this.ticks = null;
/**
* 参与度量计算的值，可选项
* @type {Array}
*/
this.values = [];
};
function Scale(cfg) {
this._initDefaultCfg();
mix(this, cfg);
this.init();
}
/**
* 度量初始化
* @protected
*/
_proto.init = function init() {}
/**
* 获取该度量的ticks,返回的是多个对象，
* - text: tick 的文本
* - value: 对应的度量转换后的值
* <code>
* [
* {text: 0,value:0}
* {text: 1,value:0.2}
* {text: 2,value:0.4}
* {text: 3,value:0.6}
* {text: 4,value:0.8}
* {text: 5,value:1}
* ]
* </code>
* @param {Number} count 输出tick的个数的近似值，默认是 10
* @return {Array} 返回 ticks 数组
*/
;
_proto.getTicks = function getTicks() {
var self = this;
var ticks = self.ticks;
var rst = [];
each(ticks, function (tick) {
var obj;
if (isObject(tick)) {
obj = tick;
} else {
obj = {
text: self.getText(tick),
tickValue: tick,
value: self.scale(tick)
};
}
rst.push(obj);
});
return rst;
}
/**
* 获取格式化后的文本
* @param {*} value 输入的数据
* @param {*} key 字段的 key
* @return {String} 格式化的文本
*/
;
_proto.getText = function getText(value, key) {
var formatter = this.formatter;
value = formatter ? formatter(value, key) : value;
if (isNil(value) || !value.toString) {
value = '';
}
return value.toString();
}
/**
* 输出的值域最小值
* @protected
* @return {Number} 返回最小的值
*/
;
_proto.rangeMin = function rangeMin() {
return this.range[0];
}
/**
* 输出的值域最大值
* @protected
* @return {Number} 返回最大的值
*/
;
_proto.rangeMax = function rangeMax() {
var range = this.range;
return range[range.length - 1];
}
/**
* 度量转换后的结果，翻转回输入域
* @param {Number} value 需要翻转的数值
* @return {*} 度量的输入值
*/
;
_proto.invert = function invert(value) {
return value;
}
/**
* 将传入的值从非数值转换成数值格式，如分类字符串、时间字符串等
* @param {*} value 传入的值
* @return {Number} 转换的值
*/
;
_proto.translate = function translate(value) {
return value;
}
/**
* 进行度量转换
* @param {*} value 输入值
* @return {Number} 输出值，在设定的输出值域之间，默认[0,1]
*/
;
_proto.scale = function scale(value) {
return value;
}
/**
* 克隆一个新的scale,拥有跟当前scale相同的输入域、输出域等
* @return {Scale} 克隆的度量
*/
;
_proto.clone = function clone() {
var self = this;
var constr = self.constructor;
var cfg = {};
each(self, function (v, k) {
cfg[k] = self[k];
});
return new constr(cfg);
}
/**
* 更改度量的属性信息
* @param {Object} info 属性信息
* @chainable
* @return {Scale} 返回自身的引用
*/
;
_proto.change = function change(info) {
this.ticks = null;
mix(this, info);
this.init();
return this;
};
return Scale;
}();
module.exports = Scale;
/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {
var isObject = __webpack_require__(7);
var isArray = __webpack_require__(17);
var each = function each(elements, func) {
if (!elements) {
return;
}
var rst = void 0;
if (isArray(elements)) {
for (var i = 0, len = elements.length; i < len; i++) {
rst = func(elements[i], i);
if (rst === false) {
break;
}
}
} else if (isObject(elements)) {
for (var k in elements) {
if (elements.hasOwnProperty(k)) {
rst = func(elements[k], k);
if (rst === false) {
break;
}
}
}
}
};
module.exports = each;
/***/ }),
/* 2 */
/***/ (function(module, exports) {
// isFinite,
var isNil = function isNil(value) {
/**
* isNil(null) => true
* isNil() => true
*/
return value === null || value === undefined;
};
module.exports = isNil;
/***/ }),
/* 3 */
/***/ (function(module, exports) {
var toString = {}.toString;
var isType = function isType(value, type) {
return toString.call(value) === '[object ' + type + ']';
};
module.exports = isType;
/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
/**
* @fileOverview The measurement of linear data scale function
* @author dxq613@gmail.com
*/
var isNil = __webpack_require__(2);
var each = __webpack_require__(1);
var Base = __webpack_require__(0);
var numberAuto = __webpack_require__(18);
/**
* 线性度量
* @class Scale.Linear
*/
var Linear = /*#__PURE__*/function (_Base) {
_inheritsLoose(Linear, _Base);
function Linear() {
return _Base.apply(this, arguments) || this;
}
var _proto = Linear.prototype;
_proto._initDefaultCfg = function _initDefaultCfg() {
_Base.prototype._initDefaultCfg.call(this);
var self = this;
self.type = 'linear';
self.isLinear = true;
/**
* 是否为了用户习惯，优化min,max和ticks，如果进行优化，则会根据生成的ticks调整min,max，否则舍弃(min,max)范围之外的ticks
* @type {Boolean}
* @default false
*/
self.nice = false;
/**
* min value of the scale
* @type {Number}
* @default null
*/
self.min = null;
/**
* min value limitted of the scale
* @type {Number}
* @default null
*/
self.minLimit = null;
/**
* max value of the scale
* @type {Number}
* @default null
*/
self.max = null;
/**
* max value limitted of the scale
* @type {Number}
* @default null
*/
self.maxLimit = null;
/**
* 自动生成标记时的个数
* @type {Number}
* @default null
*/
self.tickCount = null;
/**
* 坐标轴点之间的间距，指的是真实数据的差值
* @type {Number}
* @default null
*/
self.tickInterval = null;
/**
* 坐标轴点之间的最小间距，指的是真实数据的差值
* @type {Number}
* @default null
*/
self.minTickInterval = null;
/**
* 用于计算坐标点时逼近的数组
* @type {Array}
*/
self.snapArray = null;
}
/**
* @protected
* @override
*/
;
_proto.init = function init() {
var self = this;
if (!self.ticks) {
self.min = self.translate(self.min);
self.max = self.translate(self.max);
self.initTicks();
} else {
var ticks = self.ticks;
var firstValue = self.translate(ticks[0]);
var lastValue = self.translate(ticks[ticks.length - 1]);
if (isNil(self.min) || self.min > firstValue) {
self.min = firstValue;
}
if (isNil(self.max) || self.max < lastValue) {
self.max = lastValue;
}
}
}
/**
* 计算坐标点
* @protected
* @return {Array} 计算完成的坐标点
*/
;
_proto.calculateTicks = function calculateTicks() {
var min = this.min,
max = this.max,
minLimit = this.minLimit,
maxLimit = this.maxLimit,
tickCount = this.tickCount,
tickInterval = this.tickInterval,
minTickInterval = this.minTickInterval,
snapArray = this.snapArray;
if (tickCount === 1) {
throw new Error('linear scale\'tickCount should not be 1');
}
if (max < min) {
throw new Error("max: " + max + " should not be less than min: " + min);
}
var tmp = numberAuto({
min: min,
max: max,
minLimit: minLimit,
maxLimit: maxLimit,
minCount: tickCount,
maxCount: tickCount,
interval: tickInterval,
minTickInterval: minTickInterval,
snapArray: snapArray
});
return tmp.ticks;
} // 初始化ticks
;
_proto.initTicks = function initTicks() {
var self = this;
var calTicks = self.calculateTicks();
if (self.nice) {
// 如果需要优化显示的tick
self.ticks = calTicks;
self.min = calTicks[0];
self.max = calTicks[calTicks.length - 1];
} else {
var ticks = [];
each(calTicks, function (tick) {
if (tick >= self.min && tick <= self.max) {
ticks.push(tick);
}
}); // 如果 ticks 为空，直接输入最小值、最大值
if (!ticks.length) {
ticks.push(self.min);
ticks.push(self.max);
}
self.ticks = ticks;
}
}
/**
* @override
*/
;
_proto.scale = function scale(value) {
if (isNil(value)) {
return NaN;
}
var max = this.max;
var min = this.min;
if (max === min) {
return 0;
}
var percent = (value - min) / (max - min);
var rangeMin = this.rangeMin();
var rangeMax = this.rangeMax();
return rangeMin + percent * (rangeMax - rangeMin);
}
/**
* @override
*/
;
_proto.invert = function invert(value) {
var percent = (value - this.rangeMin()) / (this.rangeMax() - this.rangeMin());
return this.min + percent * (this.max - this.min);
};
return Linear;
}(Base);
Base.Linear = Linear;
module.exports = Linear;
/***/ }),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {
/**
* 判断是否数字
* @return {Boolean} 是否数字
*/
var isType = __webpack_require__(3);
var isNumber = function isNumber(value) {
return isType(value, 'Number');
};
module.exports = isNumber;
/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {
var isType = __webpack_require__(3);
var isString = function isString(str) {
return isType(str, 'String');
};
module.exports = isString;
/***/ }),
/* 7 */
/***/ (function(module, exports) {
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
return typeof obj;
} : function (obj) {
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
};
var isObject = function isObject(value) {
/**
* isObject({}) => true
* isObject([1, 2, 3]) => true
* isObject(Function) => true
* isObject(null) => false
*/
var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);
return value !== null && type === 'object' || type === 'function';
};
module.exports = isObject;
/***/ }),
/* 8 */
/***/ (function(module, exports) {
/**
* @fileOverview 计算方法
* @author dxq613@gmail.com
*/
// 如果小数点后面超过 10 位浮点数时进行一下处理
var DECIMAL_LENGTH = 12; // 获取系数
function getFactor(v) {
var factor = 1;
if (v === Infinity || v === -Infinity) {
throw new Error('Not support Infinity!');
}
if (v < 1) {
var count = 0;
while (v < 1) {
factor = factor / 10;
v = v * 10;
count++;
} // 浮点数计算出现问题
if (factor.toString().length > DECIMAL_LENGTH) {
factor = parseFloat(factor.toFixed(count));
}
} else {
while (v > 10) {
factor = factor * 10;
v = v / 10;
}
}
return factor;
} // 取小于当前值的
function arrayFloor(values, value) {
var length = values.length;
if (length === 0) {
return NaN;
}
var pre = values[0];
if (value < values[0]) {
return NaN;
}
if (value >= values[length - 1]) {
return values[length - 1];
}
for (var i = 1; i < values.length; i++) {
if (value < values[i]) {
break;
}
pre = values[i];
}
return pre;
} // 大于当前值的第一个
function arrayCeiling(values, value) {
var length = values.length;
if (length === 0) {
return NaN;
} // var pre = values[0];
var rst;
if (value > values[length - 1]) {
return NaN;
}
if (value < values[0]) {
return values[0];
}
for (var i = 1; i < values.length; i++) {
if (value <= values[i]) {
rst = values[i];
break;
}
}
return rst;
}
var Util = {
// 获取逼近的数值
snapFactorTo: function snapFactorTo(v, arr, snapType) {
// 假设 v = -512,isFloor = true
if (isNaN(v)) {
return NaN;
}
var factor = 1; // 计算系数
if (v !== 0) {
if (v < 0) {
factor = -1;
}
v = v * factor; // v = 512
var tmpFactor = getFactor(v);
factor = factor * tmpFactor; // factor = -100
v = v / tmpFactor; // v = 5.12
}
if (snapType === 'floor') {
v = Util.snapFloor(arr, v); // v = 5
} else if (snapType === 'ceil') {
v = Util.snapCeiling(arr, v); // v = 6
} else {
v = Util.snapTo(arr, v); // 四舍五入 5
}
var rst = parseFloat((v * factor).toPrecision(DECIMAL_LENGTH)); // 如果出现浮点数计算问题，需要处理一下
// 如果出现浮点数计算问题，需要处理一下
if (Math.abs(factor) < 1 && rst.toString().length > DECIMAL_LENGTH) {
var decimalVal = parseInt(1 / factor);
var symbol = factor > 0 ? 1 : -1;
rst = v / decimalVal * symbol;
}
return rst;
},
// 获取逼近的倍数
snapMultiple: function snapMultiple(v, base, snapType) {
var div;
if (snapType === 'ceil') {
div = Math.ceil(v / base);
} else if (snapType === 'floor') {
div = Math.floor(v / base);
} else {
div = Math.round(v / base);
}
return div * base;
},
/**
* 获取逼近的值，用于对齐数据
* @param {Array} values 数据集合
* @param {Number} value 数值
* @return {Number} 逼近的值
*/
snapTo: function snapTo(values, value) {
// 这里假定values是升序排列
var floorVal = arrayFloor(values, value);
var ceilingVal = arrayCeiling(values, value);
if (isNaN(floorVal) || isNaN(ceilingVal)) {
if (values[0] >= value) {
return values[0];
}
var last = values[values.length - 1];
if (last <= value) {
return last;
}
}
if (Math.abs(value - floorVal) < Math.abs(ceilingVal - value)) {
return floorVal;
}
return ceilingVal;
},
/**
* 获取逼近的最小值，用于对齐数据
* @param {Array} values 数据集合
* @param {Number} value 数值
* @return {Number} 逼近的最小值
*/
snapFloor: function snapFloor(values, value) {
// 这里假定values是升序排列
return arrayFloor(values, value);
},
/**
* 获取逼近的最大值，用于对齐数据
* @param {Array} values 数据集合
* @param {Number} value 数值
* @return {Number} 逼近的最大值
*/
snapCeiling: function snapCeiling(values, value) {
// 这里假定values是升序排列
return arrayCeiling(values, value);
},
fixedBase: function fixedBase(v, base) {
var str = base.toString();
var index = str.indexOf('.');
var indexOfExp = str.indexOf('e-'); // 判断是否带小数点，1.000001 1.23e-9
if (index < 0 && indexOfExp < 0) {
// base为整数
return Math.round(v);
}
var length = indexOfExp >= 0 ? parseInt(str.substr(indexOfExp + 2), 10) : str.substr(index + 1).length;
if (length > 20) {
length = 20;
}
return parseFloat(v.toFixed(length));
}
};
module.exports = Util;
/***/ }),
/* 9 */
/***/ (function(module, exports, __webpack_require__) {
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
var Base = __webpack_require__(0);
var catAuto = __webpack_require__(10);
var each = __webpack_require__(1);
var isNumber = __webpack_require__(5);
var isString = __webpack_require__(6);
var Category = /*#__PURE__*/function (_Base) {
_inheritsLoose(Category, _Base);
function Category() {
return _Base.apply(this, arguments) || this;
}
var _proto = Category.prototype;
_proto._initDefaultCfg = function _initDefaultCfg() {
_Base.prototype._initDefaultCfg.call(this);
this.type = 'cat';
/**
* 是否分类度量
* @type {Boolean}
*/
this.isCategory = true;
this.isRounding = true; // 是否进行取整操作
}
/**
* @override
*/
;
_proto.init = function init() {
var self = this;
var values = self.values;
var tickCount = self.tickCount;
each(values, function (v, i) {
values[i] = v.toString();
});
if (!self.ticks) {
var ticks = values;
if (tickCount) {
var temp = catAuto({
maxCount: tickCount,
data: values,
isRounding: self.isRounding
});
ticks = temp.ticks;
}
this.ticks = ticks;
}
}
/**
* @override
*/
;
_proto.getText = function getText(value) {
if (this.values.indexOf(value) === -1 && isNumber(value)) {
value = this.values[Math.round(value)];
}
return _Base.prototype.getText.call(this, value);
}
/**
* @override
*/
;
_proto.translate = function translate(value) {
var index = this.values.indexOf(value);
if (index === -1 && isNumber(value)) {
index = value;
} else if (index === -1) {
index = NaN;
}
return index;
}
/**
* @override
*/
;
_proto.scale = function scale(value) {
var rangeMin = this.rangeMin();
var rangeMax = this.rangeMax();
var percent;
if (isString(value) || this.values.indexOf(value) !== -1) {
value = this.translate(value);
}
if (this.values.length > 1) {
percent = value / (this.values.length - 1);
} else {
percent = value;
}
return rangeMin + percent * (rangeMax - rangeMin);
}
/**
* @override
*/
;
_proto.invert = function invert(value) {
if (isString(value)) {
// 如果已经是字符串
return value;
}
var min = this.rangeMin();
var max = this.rangeMax(); // 归一到 范围内
if (value < min) {
value = min;
}
if (value > max) {
value = max;
}
var percent = (value - min) / (max - min);
var index = Math.round(percent * (this.values.length - 1)) % this.values.length;
index = index || 0;
return this.values[index];
};
return Category;
}(Base);
Base.Cat = Category;
module.exports = Category;
/***/ }),
/* 10 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @fileOverview 计算分类的的坐标点
* @author dxq613@gmail.com
*/
var each = __webpack_require__(1);
var MAX_COUNT = 8;
var SUB_COUNT = 4; // 控制个数不能过小
function getSimpleArray(data) {
var arr = [];
each(data, function (sub) {
arr = arr.concat(sub);
});
return arr;
}
function getGreatestFactor(count, number) {
var i;
for (i = number; i > 0; i--) {
if (count % i === 0) {
break;
}
} // 如果是素数，没有可以整除的数字
if (i === 1) {
for (i = number; i > 0; i--) {
if ((count - 1) % i === 0) {
break;
}
}
}
return i;
}
module.exports = function (info) {
var rst = {};
var ticks = [];
var isRounding = info.isRounding;
var categories = getSimpleArray(info.data);
var length = categories.length;
var maxCount = info.maxCount || MAX_COUNT;
var tickCount;
if (isRounding) {
// 取整操作
tickCount = getGreatestFactor(length - 1, maxCount - 1) + 1; // 如果计算出来只有两个坐标点，则直接使用传入的 maxCount
if (tickCount === 2) {
tickCount = maxCount;
} else if (tickCount < maxCount - SUB_COUNT) {
tickCount = maxCount - SUB_COUNT;
}
} else {
tickCount = maxCount;
}
if (!isRounding && length <= tickCount + tickCount / 2) {
ticks = [].concat(categories);
} else {
var step = parseInt(length / (tickCount - 1), 10);
var groups = categories.map(function (e, i) {
return i % step === 0 ? categories.slice(i, i + step) : null;
}).filter(function (e) {
return e;
});
for (var i = 1, groupLen = groups.length; i < groupLen && (isRounding ? i * step < length - step : i < tickCount - 1); i++) {
ticks.push(groups[i][0]);
}
if (categories.length) {
ticks.unshift(categories[0]);
var last = categories[length - 1];
if (ticks.indexOf(last) === -1) {
ticks.push(last);
}
}
}
rst.categories = categories;
rst.ticks = ticks;
return rst;
};
/***/ }),
/* 11 */
/***/ (function(module, exports, __webpack_require__) {
var __WEBPACK_AMD_DEFINE_RESULT__;(function (main) {
'use strict';
/**
* Parse or format dates
* @class fecha
*/
var fecha = {};
var token = /d{1,4}|M{1,4}|YY(?:YY)?|S{1,3}|Do|ZZ|([HhMsDm])\1?|[aA]|"[^"]*"|'[^']*'/g;
var twoDigits = /\d\d?/;
var threeDigits = /\d{3}/;
var fourDigits = /\d{4}/;
var word = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i;
var literal = /\[([^]*?)\]/gm;
var noop = function () {};
function shorten(arr, sLen) {
var newArr = [];
for (var i = 0, len = arr.length; i < len; i++) {
newArr.push(arr[i].substr(0, sLen));
}
return newArr;
}
function monthUpdate(arrName) {
return function (d, v, i18n) {
var index = i18n[arrName].indexOf(v.charAt(0).toUpperCase() + v.substr(1).toLowerCase());
if (~index) {
d.month = index;
}
};
}
function pad(val, len) {
val = String(val);
len = len || 2;
while (val.length < len) {
val = '0' + val;
}
return val;
}
var dayNames = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
var monthNames = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
var monthNamesShort = shorten(monthNames, 3);
var dayNamesShort = shorten(dayNames, 3);
fecha.i18n = {
dayNamesShort: dayNamesShort,
dayNames: dayNames,
monthNamesShort: monthNamesShort,
monthNames: monthNames,
amPm: ['am', 'pm'],
DoFn: function DoFn(D) {
return D + ['th', 'st', 'nd', 'rd'][D % 10 > 3 ? 0 : (D - D % 10 !== 10) * D % 10];
}
};
var formatFlags = {
D: function (dateObj) {
return dateObj.getDate();
},
DD: function (dateObj) {
return pad(dateObj.getDate());
},
Do: function (dateObj, i18n) {
return i18n.DoFn(dateObj.getDate());
},
d: function (dateObj) {
return dateObj.getDay();
},
dd: function (dateObj) {
return pad(dateObj.getDay());
},
ddd: function (dateObj, i18n) {
return i18n.dayNamesShort[dateObj.getDay()];
},
dddd: function (dateObj, i18n) {
return i18n.dayNames[dateObj.getDay()];
},
M: function (dateObj) {
return dateObj.getMonth() + 1;
},
MM: function (dateObj) {
return pad(dateObj.getMonth() + 1);
},
MMM: function (dateObj, i18n) {
return i18n.monthNamesShort[dateObj.getMonth()];
},
MMMM: function (dateObj, i18n) {
return i18n.monthNames[dateObj.getMonth()];
},
YY: function (dateObj) {
return String(dateObj.getFullYear()).substr(2);
},
YYYY: function (dateObj) {
return pad(dateObj.getFullYear(), 4);
},
h: function (dateObj) {
return dateObj.getHours() % 12 || 12;
},
hh: function (dateObj) {
return pad(dateObj.getHours() % 12 || 12);
},
H: function (dateObj) {
return dateObj.getHours();
},
HH: function (dateObj) {
return pad(dateObj.getHours());
},
m: function (dateObj) {
return dateObj.getMinutes();
},
mm: function (dateObj) {
return pad(dateObj.getMinutes());
},
s: function (dateObj) {
return dateObj.getSeconds();
},
ss: function (dateObj) {
return pad(dateObj.getSeconds());
},
S: function (dateObj) {
return Math.round(dateObj.getMilliseconds() / 100);
},
SS: function (dateObj) {
return pad(Math.round(dateObj.getMilliseconds() / 10), 2);
},
SSS: function (dateObj) {
return pad(dateObj.getMilliseconds(), 3);
},
a: function (dateObj, i18n) {
return dateObj.getHours() < 12 ? i18n.amPm[0] : i18n.amPm[1];
},
A: function (dateObj, i18n) {
return dateObj.getHours() < 12 ? i18n.amPm[0].toUpperCase() : i18n.amPm[1].toUpperCase();
},
ZZ: function (dateObj) {
var o = dateObj.getTimezoneOffset();
return (o > 0 ? '-' : '+') + pad(Math.floor(Math.abs(o) / 60) * 100 + Math.abs(o) % 60, 4);
}
};
var parseFlags = {
D: [twoDigits, function (d, v) {
d.day = v;
}],
Do: [new RegExp(twoDigits.source + word.source), function (d, v) {
d.day = parseInt(v, 10);
}],
M: [twoDigits, function (d, v) {
d.month = v - 1;
}],
YY: [twoDigits, function (d, v) {
var da = new Date(),
cent = +('' + da.getFullYear()).substr(0, 2);
d.year = '' + (v > 68 ? cent - 1 : cent) + v;
}],
h: [twoDigits, function (d, v) {
d.hour = v;
}],
m: [twoDigits, function (d, v) {
d.minute = v;
}],
s: [twoDigits, function (d, v) {
d.second = v;
}],
YYYY: [fourDigits, function (d, v) {
d.year = v;
}],
S: [/\d/, function (d, v) {
d.millisecond = v * 100;
}],
SS: [/\d{2}/, function (d, v) {
d.millisecond = v * 10;
}],
SSS: [threeDigits, function (d, v) {
d.millisecond = v;
}],
d: [twoDigits, noop],
ddd: [word, noop],
MMM: [word, monthUpdate('monthNamesShort')],
MMMM: [word, monthUpdate('monthNames')],
a: [word, function (d, v, i18n) {
var val = v.toLowerCase();
if (val === i18n.amPm[0]) {
d.isPm = false;
} else if (val === i18n.amPm[1]) {
d.isPm = true;
}
}],
ZZ: [/([\+\-]\d\d:?\d\d|Z)/, function (d, v) {
if (v === 'Z') v = '+00:00';
var parts = (v + '').match(/([\+\-]|\d\d)/gi),
minutes;
if (parts) {
minutes = +(parts[1] * 60) + parseInt(parts[2], 10);
d.timezoneOffset = parts[0] === '+' ? minutes : -minutes;
}
}]
};
parseFlags.dd = parseFlags.d;
parseFlags.dddd = parseFlags.ddd;
parseFlags.DD = parseFlags.D;
parseFlags.mm = parseFlags.m;
parseFlags.hh = parseFlags.H = parseFlags.HH = parseFlags.h;
parseFlags.MM = parseFlags.M;
parseFlags.ss = parseFlags.s;
parseFlags.A = parseFlags.a; // Some common format strings
fecha.masks = {
default: 'ddd MMM DD YYYY HH:mm:ss',
shortDate: 'M/D/YY',
mediumDate: 'MMM D, YYYY',
longDate: 'MMMM D, YYYY',
fullDate: 'dddd, MMMM D, YYYY',
shortTime: 'HH:mm',
mediumTime: 'HH:mm:ss',
longTime: 'HH:mm:ss.SSS'
};
/***
* Format a date
* @method format
* @param {Date|number} dateObj
* @param {string} mask Format of the date, i.e. 'mm-dd-yy' or 'shortDate'
*/
fecha.format = function (dateObj, mask, i18nSettings) {
var i18n = i18nSettings || fecha.i18n;
if (typeof dateObj === 'number') {
dateObj = new Date(dateObj);
}
if (Object.prototype.toString.call(dateObj) !== '[object Date]' || isNaN(dateObj.getTime())) {
throw new Error('Invalid Date in fecha.format');
}
mask = fecha.masks[mask] || mask || fecha.masks['default'];
var literals = []; // Make literals inactive by replacing them with ??
mask = mask.replace(literal, function ($0, $1) {
literals.push($1);
return '??';
}); // Apply formatting rules
mask = mask.replace(token, function ($0) {
return $0 in formatFlags ? formatFlags[$0](dateObj, i18n) : $0.slice(1, $0.length - 1);
}); // Inline literal values back into the formatted value
return mask.replace(/\?\?/g, function () {
return literals.shift();
});
};
/**
* Parse a date string into an object, changes - into /
* @method parse
* @param {string} dateStr Date string
* @param {string} format Date parse format
* @returns {Date|boolean}
*/
fecha.parse = function (dateStr, format, i18nSettings) {
var i18n = i18nSettings || fecha.i18n;
if (typeof format !== 'string') {
throw new Error('Invalid format in fecha.parse');
}
format = fecha.masks[format] || format; // Avoid regular expression denial of service, fail early for really long strings
// https://www.owasp.org/index.php/Regular_expression_Denial_of_Service_-_ReDoS
if (dateStr.length > 1000) {
return false;
}
var isValid = true;
var dateInfo = {};
format.replace(token, function ($0) {
if (parseFlags[$0]) {
var info = parseFlags[$0];
var index = dateStr.search(info[0]);
if (!~index) {
isValid = false;
} else {
dateStr.replace(info[0], function (result) {
info[1](dateInfo, result, i18n);
dateStr = dateStr.substr(index + result.length);
return result;
});
}
}
return parseFlags[$0] ? '' : $0.slice(1, $0.length - 1);
});
if (!isValid) {
return false;
}
var today = new Date();
if (dateInfo.isPm === true && dateInfo.hour != null && +dateInfo.hour !== 12) {
dateInfo.hour = +dateInfo.hour + 12;
} else if (dateInfo.isPm === false && +dateInfo.hour === 12) {
dateInfo.hour = 0;
}
var date;
if (dateInfo.timezoneOffset != null) {
dateInfo.minute = +(dateInfo.minute || 0) - +dateInfo.timezoneOffset;
date = new Date(Date.UTC(dateInfo.year || today.getFullYear(), dateInfo.month || 0, dateInfo.day || 1, dateInfo.hour || 0, dateInfo.minute || 0, dateInfo.second || 0, dateInfo.millisecond || 0));
} else {
date = new Date(dateInfo.year || today.getFullYear(), dateInfo.month || 0, dateInfo.day || 1, dateInfo.hour || 0, dateInfo.minute || 0, dateInfo.second || 0, dateInfo.millisecond || 0);
}
return date;
};
/* istanbul ignore next */
if (typeof module !== 'undefined' && module.exports) {
module.exports = fecha;
} else if (true) {
!(__WEBPACK_AMD_DEFINE_RESULT__ = (function () {
return fecha;
}).call(exports, __webpack_require__, exports, module),
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
} else {
main.fecha = fecha;
}
})(this);
/***/ }),
/* 12 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @fileOverview 提取公共代码到util方法
* @author dxq613@gmail.com
*/
var isString = __webpack_require__(6);
var isDate = __webpack_require__(22);
module.exports = {
toTimeStamp: function toTimeStamp(value) {
if (isString(value)) {
if (value.indexOf('T') > 0) {
value = new Date(value).getTime();
} else {
value = new Date(value.replace(/-/ig, '/')).getTime();
}
}
if (isDate(value)) {
value = value.getTime();
}
return value;
}
};
/***/ }),
/* 13 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @fileOverview Scale entry, used to reference all the scales
* @author dxq613@gmail.com
*/
var lowerFirst = __webpack_require__(14);
var Base = __webpack_require__(0);
Base.Linear = __webpack_require__(4);
Base.Identity = __webpack_require__(19);
Base.Cat = __webpack_require__(9);
Base.Time = __webpack_require__(20);
Base.TimeCat = __webpack_require__(23);
Base.Log = __webpack_require__(24);
Base.Pow = __webpack_require__(25);
var _loop = function _loop(k) {
if (Base.hasOwnProperty(k)) {
var methodName = lowerFirst(k);
Base[methodName] = function (cfg) {
return new Base[k](cfg);
};
}
};
for (var k in Base) {
_loop(k);
}
var CAT_ARR = ['cat', 'timeCat'];
Base.isCategory = function (type) {
return CAT_ARR.indexOf(type) >= 0;
};
module.exports = Base;
/***/ }),
/* 14 */
/***/ (function(module, exports, __webpack_require__) {
var toString = __webpack_require__(15);
var lowerFirst = function lowerFirst(value) {
var str = toString(value);
return str.charAt(0).toLowerCase() + str.substring(1);
};
module.exports = lowerFirst;
/***/ }),
/* 15 */
/***/ (function(module, exports, __webpack_require__) {
var isNil = __webpack_require__(2);
function toString(value) {
if (isNil(value)) return '';
return value.toString();
}
module.exports = toString;
/***/ }),
/* 16 */
/***/ (function(module, exports) {
function _mix(dist, obj) {
for (var key in obj) {
if (obj.hasOwnProperty(key) && key !== 'constructor' && obj[key] !== undefined) {
dist[key] = obj[key];
}
}
}
var mix = function mix(dist, src1, src2, src3) {
if (src1) _mix(dist, src1);
if (src2) _mix(dist, src2);
if (src3) _mix(dist, src3);
return dist;
};
module.exports = mix;
/***/ }),
/* 17 */
/***/ (function(module, exports, __webpack_require__) {
var isType = __webpack_require__(3);
var isArray = Array.isArray ? Array.isArray : function (value) {
return isType(value, 'Array');
};
module.exports = isArray;
/***/ }),
/* 18 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @fileOverview 自动计算数字坐标轴
* @author dxq613@gmail.com
*/
var isNil = __webpack_require__(2);
var isNumber = __webpack_require__(5);
var AutoUtil = __webpack_require__(8);
var MIN_COUNT = 5;
var MAX_COUNT = 7;
var SNAP_COUNT_ARRAY = [1, 1.2, 1.5, 1.6, 2, 2.2, 2.4, 2.5, 3, 4, 5, 6, 7.5, 8, 10];
var SNAP_ARRAY = [1, 2, 4, 5, 10];
var EPS = 1e-12;
module.exports = function (info) {
var min = info.min;
var max = info.max;
var interval = info.interval;
var minTickInterval = info.minTickInterval;
var ticks = [];
var minCount = info.minCount || MIN_COUNT;
var maxCount = info.maxCount || MAX_COUNT;
var isFixedCount = minCount === maxCount; // 是否限定死了个数
var minLimit = isNil(info.minLimit) ? -Infinity : info.minLimit; // 限定的最小值
var maxLimit = isNil(info.maxLimit) ? Infinity : info.maxLimit; // 限定最大值
var avgCount = (minCount + maxCount) / 2;
var count = avgCount; // 用户传入的逼近数组
var snapArray = info.snapArray ? info.snapArray : isFixedCount ? SNAP_COUNT_ARRAY : SNAP_ARRAY; // 如果限定大小范围，同时大小范围等于用户传入的范围，同时限定了个数，interval 按照个数均分
if (min === minLimit && max === maxLimit && isFixedCount) {
interval = (max - min) / (count - 1);
}
if (isNil(min)) {
min = 0;
}
if (isNil(max)) {
max = 0;
}
if (Math.abs(max - min) < EPS) {
if (min === 0) {
max = 1;
} else {
if (min > 0) {
min = 0;
} else {
max = 0;
}
}
if (max - min < 5 && !interval && max - min >= 1) {
interval = 1;
}
}
if (isNil(interval)) {
// 计算间距
var temp = (max - min) / (avgCount - 1);
interval = AutoUtil.snapFactorTo(temp, snapArray, 'ceil');
if (maxCount !== minCount) {
count = parseInt((max - min) / interval, 10);
if (count > maxCount) {
count = maxCount;
}
if (count < minCount) {
count = minCount;
} // 不确定tick的个数时，使得tick偏小
interval = AutoUtil.snapFactorTo((max - min) / (count - 1), snapArray);
}
} // interval should not be less than minTickInterval
if (isNumber(minTickInterval) && interval < minTickInterval) {
interval = minTickInterval;
}
if (info.interval || maxCount !== minCount) {
// 校正 max 和 min
max = Math.min(AutoUtil.snapMultiple(max, interval, 'ceil'), maxLimit); // 向上逼近
min = Math.max(AutoUtil.snapMultiple(min, interval, 'floor'), minLimit); // 向下逼近
count = Math.round((max - min) / interval);
min = AutoUtil.fixedBase(min, interval); // 当min为负数的时候，fixedBase后，min可能会大于minLimit，导致最终产出的tick是大于minLimit的，所以必须进行修正
max = AutoUtil.fixedBase(max, interval);
var prevMin = null;
while (min > minLimit && minLimit > -Infinity && (prevMin === null || min < prevMin)) {
// 保证计算出来的刻度最小值 min， 不大于数据最小值 min
prevMin = min;
min = AutoUtil.fixedBase(min - interval, interval);
}
} else {
avgCount = parseInt(avgCount, 10); // 取整
var avg = (max + min) / 2;
var avgTick = AutoUtil.snapMultiple(avg, interval, 'ceil');
var sideCount = Math.floor((avgCount - 2) / 2);
var maxTick = avgTick + sideCount * interval;
var minTick;
if (avgCount % 2 === 0) {
minTick = avgTick - sideCount * interval;
} else {
minTick = avgTick - (sideCount + 1) * interval;
}
var prevMaxTick = null; // 如果减去intervl, fixBase后，新的minTick没有大于之前的值，就退出，防止死循环
while (maxTick < max && (prevMaxTick === null || maxTick > prevMaxTick)) {
// 保证计算出来的刻度最大值 maxTick 不小于数据最大值 max
prevMaxTick = maxTick;
maxTick = AutoUtil.fixedBase(maxTick + interval, interval);
}
var prevMinTick = null; // 如果减去intervl, fixBase后，新的minTick没有小于之前的值，就退出，防止死循环
while (minTick > min && (prevMinTick === null || minTick < prevMinTick)) {
// 保证计算出来的刻度最小值 minTick 不大于数据最小值 min
prevMinTick = minTick;
minTick = AutoUtil.fixedBase(minTick - interval, interval); // 防止超常浮点数计算问题
}
max = maxTick;
min = minTick;
}
max = Math.min(max, maxLimit);
min = Math.max(min, minLimit);
ticks.push(min);
for (var i = 1; i < count; i++) {
var tickValue = AutoUtil.fixedBase(interval * i + min, interval);
if (tickValue < max) {
ticks.push(tickValue);
}
}
if (ticks[ticks.length - 1] < max) {
ticks.push(max);
}
return {
min: min,
max: max,
interval: interval,
count: count,
ticks: ticks
};
};
/***/ }),
/* 19 */
/***/ (function(module, exports, __webpack_require__) {
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
var Base = __webpack_require__(0);
var isNumber = __webpack_require__(5);
var Identity = /*#__PURE__*/function (_Base) {
_inheritsLoose(Identity, _Base);
function Identity() {
return _Base.apply(this, arguments) || this;
}
var _proto = Identity.prototype;
_proto._initDefaultCfg = function _initDefaultCfg() {
_Base.prototype._initDefaultCfg.call(this);
this.isIdentity = true;
this.type = 'identity';
/**
* 常量值
* @type {*}
*/
this.value = null;
}
/**
* @override
*/
;
_proto.getText = function getText() {
return this.value.toString();
}
/**
* @override
*/
;
_proto.scale = function scale(value) {
if (this.value !== value && isNumber(value)) {
return value;
}
return this.range[0];
}
/**
* @override
*/
;
_proto.invert = function invert() {
return this.value;
};
return Identity;
}(Base);
Base.Identity = Identity;
module.exports = Identity;
/***/ }),
/* 20 */
/***/ (function(module, exports, __webpack_require__) {
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
/**
* @fileOverview The measurement of linear data scale function
* @author dxq613@gmail.com
*/
var fecha = __webpack_require__(11);
var each = __webpack_require__(1);
var isNil = __webpack_require__(2);
var isString = __webpack_require__(6);
var Base = __webpack_require__(0);
var Linear = __webpack_require__(4);
var timeAuto = __webpack_require__(21);
var TimeUtil = __webpack_require__(12);
/**
* 时间度量的构造函数
* @class Scale.Time
*/
var Time = /*#__PURE__*/function (_Linear) {
_inheritsLoose(Time, _Linear);
function Time() {
return _Linear.apply(this, arguments) || this;
}
var _proto = Time.prototype;
_proto._initDefaultCfg = function _initDefaultCfg() {
_Linear.prototype._initDefaultCfg.call(this);
this.type = 'time';
this.mask = 'YYYY-MM-DD';
}
/**
* @override
*/
;
_proto.init = function init() {
var self = this;
var values = self.values;
if (values && values.length) {
// 重新计算最大最小值
var timeStamps = [];
var min = Infinity; // 最小值
var secondMin = min; // 次小值
var max = 0; // 使用一个循环，计算min,max,secondMin
each(values, function (v) {
var timeStamp = self._toTimeStamp(v);
if (isNaN(timeStamp)) {
throw new TypeError("Invalid Time: " + v);
}
if (min > timeStamp) {
secondMin = min;
min = timeStamp;
} else if (secondMin > timeStamp) {
secondMin = timeStamp;
}
if (max < timeStamp) {
max = timeStamp;
}
timeStamps.push(timeStamp);
}); // 存在多个值时，设置最小间距
if (values.length > 1) {
self.minTickInterval = secondMin - min;
}
if (isNil(self.min) || self._toTimeStamp(self.min) > min) {
self.min = min;
}
if (isNil(self.max) || self._toTimeStamp(self.max) < max) {
self.max = max;
}
}
_Linear.prototype.init.call(this);
};
_proto.calculateTicks = function calculateTicks() {
var self = this;
var min = self.min;
var max = self.max;
var count = self.tickCount;
var interval = self.tickInterval;
var tmp = timeAuto({
min: min,
max: max,
minCount: count,
maxCount: count,
interval: interval,
minInterval: self.minTickInterval
});
return tmp.ticks;
}
/**
* @override
*/
;
_proto.getText = function getText(value) {
var formatter = this.formatter;
value = this.translate(value);
value = formatter ? formatter(value) : fecha.format(value, this.mask);
return value;
}
/**
* @override
*/
;
_proto.scale = function scale(value) {
if (isString(value)) {
value = this.translate(value);
}
return _Linear.prototype.scale.call(this, value);
}
/**
* @override
*/
;
_proto.translate = function translate(value) {
return this._toTimeStamp(value);
} // 将时间转换为时间戳
;
_proto._toTimeStamp = function _toTimeStamp(value) {
return TimeUtil.toTimeStamp(value);
};
return Time;
}(Linear);
Base.Time = Time;
module.exports = Time;
/***/ }),
/* 21 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @fileOverview 计算时间坐标轴
* @author dxq613@gmail.com
*/
var AutoUtil = __webpack_require__(8);
var isNil = __webpack_require__(2);
var MAX_COUNT = 6;
var SNAP_ARRAY = [1, 2, 4, 6, 8, 12];
var MINUTE_MS = 60 * 1000;
var HOUR_MS = 3600 * 1000;
var DAY_MS = 24 * 3600 * 1000;
function getYear(date) {
return new Date(date).getFullYear();
}
function createYear(year) {
return new Date(year, 0, 1).getTime();
}
function getMonth(date) {
return new Date(date).getMonth();
}
function diffMonth(min, max) {
var minYear = getYear(min);
var maxYear = getYear(max);
var minMonth = getMonth(min);
var maxMonth = getMonth(max);
return (maxYear - minYear) * 12 + (maxMonth - minMonth) % 12;
}
function creatMonth(year, month) {
return new Date(year, month, 1).getTime();
}
function diffDay(min, max) {
return Math.ceil((max - min) / DAY_MS);
}
function diffHour(min, max) {
return Math.ceil((max - min) / HOUR_MS);
}
function diffMinus(min, max) {
return Math.ceil((max - min) / (60 * 1000));
}
module.exports = function (info) {
var minInterval = info.minInterval;
var ticks = [];
var min = info.min;
var max = info.max;
var interval = info.interval;
var count; // 如果最大值和最小值相等，则设置最大值大于最小值一天
if (max === min) {
max = min + DAY_MS;
} // 计算间距
if (isNil(interval)) {
var innerTime = max - min;
var dms = DAY_MS; // 天代表的秒
var yms = 365 * dms; // 年代表的秒
interval = parseInt(innerTime / (info.maxCount || MAX_COUNT), 10);
if (minInterval && minInterval > interval) {
interval = minInterval;
}
var yfactor = interval / yms;
var minYear = getYear(min); // 大于半年
if (yfactor > 0.51) {
var year = Math.ceil(yfactor); // interval = year * yms;
var maxYear = getYear(max);
for (var i = minYear; i <= maxYear + year; i = i + year) {
ticks.push(createYear(i));
}
interval = null;
} else if (yfactor > 0.0834) {
// 大于一个月
var month = Math.ceil(yfactor / 0.0834);
var mmMoth = getMonth(min);
var dMonths = diffMonth(min, max);
for (var _i = 0; _i <= dMonths + month; _i = _i + month) {
ticks.push(creatMonth(minYear, _i + mmMoth));
}
interval = null;
} else if (interval > dms * 0.5) {
// 大于一天
var date = new Date(min);
var _year = date.getFullYear();
var _month = date.getMonth(min);
var mday = date.getDate();
var day = Math.ceil(interval / dms);
var ddays = diffDay(min, max);
interval = day * dms;
for (var _i2 = 0; _i2 < ddays + day; _i2 = _i2 + day) {
ticks.push(new Date(_year, _month, mday + _i2).getTime());
}
} else if (interval > HOUR_MS) {
// 大于一个小时
var _date = new Date(min);
var _year2 = _date.getFullYear();
var _month2 = _date.getMonth(min);
var _day = _date.getDate();
var hour = _date.getHours();
var hours = AutoUtil.snapTo(SNAP_ARRAY, Math.ceil(interval / HOUR_MS));
var dHours = diffHour(min, max);
interval = hours * HOUR_MS;
for (var _i3 = 0; _i3 <= dHours + hours; _i3 = _i3 + hours) {
ticks.push(new Date(_year2, _month2, _day, hour + _i3).getTime());
}
} else if (interval > MINUTE_MS) {
// 最小单位是分钟
var dMinus = diffMinus(min, max);
var minutes = Math.ceil(interval / MINUTE_MS);
interval = minutes * MINUTE_MS;
for (var _i4 = 0; _i4 <= dMinus + minutes; _i4 = _i4 + minutes) {
ticks.push(min + _i4 * MINUTE_MS);
}
} else {
if (interval < 1000) {
interval = 1000;
}
min = Math.floor(min / 1000) * 1000;
var dSeconds = Math.ceil((max - min) / 1000);
var seconds = Math.ceil(interval / 1000);
interval = seconds * 1000;
for (var _i5 = 0; _i5 < dSeconds + seconds; _i5 = _i5 + seconds) {
ticks.push(min + _i5 * 1000);
}
}
}
if (!ticks.length) {
min = Math.floor(min / 1000) * 1000;
max = Math.ceil(max / 1000) * 1000;
count = (max - min) / interval;
for (var _i6 = 0; _i6 <= count; _i6++) {
ticks.push(AutoUtil.fixedBase(interval * _i6 + min, interval));
}
}
return {
max: max,
min: min,
interval: interval,
ticks: ticks,
count: ticks.length
};
};
/***/ }),
/* 22 */
/***/ (function(module, exports, __webpack_require__) {
var isType = __webpack_require__(3);
var isDate = function isDate(value) {
return isType(value, 'Date');
};
module.exports = isDate;
/***/ }),
/* 23 */
/***/ (function(module, exports, __webpack_require__) {
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
/**
* @fileOverview 时间数据作为分类类型
* @author dxq613@gmail.com
*/
var Base = __webpack_require__(0);
var Category = __webpack_require__(9);
var fecha = __webpack_require__(11);
var catAuto = __webpack_require__(10);
var TimeUtil = __webpack_require__(12);
var each = __webpack_require__(1);
var isNumber = __webpack_require__(5);
var isObject = __webpack_require__(7);
var isString = __webpack_require__(6);
/**
* 度量的构造函数
* @class Scale.TimeCategory
*/
var TimeCategory = /*#__PURE__*/function (_Category) {
_inheritsLoose(TimeCategory, _Category);
function TimeCategory() {
return _Category.apply(this, arguments) || this;
}
var _proto = TimeCategory.prototype;
_proto._initDefaultCfg = function _initDefaultCfg() {
_Category.prototype._initDefaultCfg.call(this);
this.type = 'timeCat';
/**
* 是否需要排序，默认进行排序
* @type {Boolean}
*/
this.sortable = true;
this.tickCount = 5;
/**
* 时间格式化
* @type {String}
*/
this.mask = 'YYYY-MM-DD';
};
_proto.init = function init() {
var self = this;
var values = this.values; // 针对时间分类类型，会将时间统一转换为时间戳
each(values, function (v, i) {
values[i] = self._toTimeStamp(v);
});
if (this.sortable) {
// 允许排序
values.sort(function (v1, v2) {
return v1 - v2;
});
}
if (!self.ticks) {
self.ticks = this.calculateTicks();
}
}
/**
* 计算 ticks
* @return {array} 返回 ticks 数组
*/
;
_proto.calculateTicks = function calculateTicks() {
var self = this;
var count = self.tickCount;
var ticks;
if (count) {
var temp = catAuto({
maxCount: count,
data: self.values,
isRounding: self.isRounding
});
ticks = temp.ticks;
} else {
ticks = self.values;
}
return ticks;
}
/**
* @override
*/
;
_proto.translate = function translate(value) {
value = this._toTimeStamp(value);
var index = this.values.indexOf(value);
if (index === -1) {
if (isNumber(value) && value < this.values.length) {
index = value;
} else {
index = NaN;
}
}
return index;
}
/**
* @override
*/
;
_proto.scale = function scale(value) {
var rangeMin = this.rangeMin();
var rangeMax = this.rangeMax();
var index = this.translate(value);
var percent;
if (this.values.length === 1 || isNaN(index)) {
// is index is NAN should not be set as 0
percent = index;
} else if (index > -1) {
percent = index / (this.values.length - 1);
} else {
percent = 0;
}
return rangeMin + percent * (rangeMax - rangeMin);
}
/**
* @override
*/
;
_proto.getText = function getText(value) {
var result = '';
var index = this.translate(value);
if (index > -1) {
result = this.values[index];
} else {
result = value;
}
var formatter = this.formatter;
result = parseInt(result, 10);
result = formatter ? formatter(result) : fecha.format(result, this.mask);
return result;
}
/**
* @override
*/
;
_proto.getTicks = function getTicks() {
var self = this;
var ticks = this.ticks;
var rst = [];
each(ticks, function (tick) {
var obj;
if (isObject(tick)) {
obj = tick;
} else {
obj = {
text: isString(tick) ? tick : self.getText(tick),
value: self.scale(tick),
tickValue: tick // 用于坐标轴上文本动画时确定前后帧的对应关系
};
}
rst.push(obj);
});
return rst;
} // 将时间转换为时间戳
;
_proto._toTimeStamp = function _toTimeStamp(value) {
return TimeUtil.toTimeStamp(value);
};
return TimeCategory;
}(Category);
Base.TimeCat = TimeCategory;
module.exports = TimeCategory;
/***/ }),
/* 24 */
/***/ (function(module, exports, __webpack_require__) {
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
/**
* @fileOverview 使用度量，进行log转换
* @author dxq613@gmail.com
*/
var each = __webpack_require__(1);
var Base = __webpack_require__(0);
var Linear = __webpack_require__(4); // 计算log
function log(a, b) {
if (a === 1) {
return 1;
}
return Math.log(b) / Math.log(a);
}
/**
* 度量的log计算
* @class Scale.Log
*/
var Log = /*#__PURE__*/function (_Linear) {
_inheritsLoose(Log, _Linear);
function Log() {
return _Linear.apply(this, arguments) || this;
}
var _proto = Log.prototype;
_proto._initDefaultCfg = function _initDefaultCfg() {
_Linear.prototype._initDefaultCfg.call(this);
this.type = 'log';
/**
* @override
* log 的坐标点的个数控制在10个以下
* @type {Number}
*/
this.tickCount = 10;
/**
* 进行log计算的基数
* @type {Number}
*/
this.base = 2; // 最小的tick，仅内部使用
this._minTick = null;
}
/**
* @override
*/
;
_proto.calculateTicks = function calculateTicks() {
var self = this;
var base = self.base;
var minTick;
if (self.min < 0) {
throw new Error('The minimum value must be greater than zero!');
}
var maxTick = log(base, self.max);
if (self.min > 0) {
minTick = Math.floor(log(base, self.min));
} else {
var values = self.values;
var positiveMin = self.max; // 查找大于0的第一个值, 如果都小于0，默认为1
each(values, function (value) {
if (value > 0 && value < positiveMin) {
positiveMin = value;
}
});
if (positiveMin === self.max) {
positiveMin = self.max / base;
}
if (positiveMin > 1) {
positiveMin = 1;
}
minTick = Math.floor(log(base, positiveMin));
self._minTick = minTick;
self.positiveMin = positiveMin;
}
var count = maxTick - minTick;
var tickCount = self.tickCount;
var avg = Math.ceil(count / tickCount);
var ticks = [];
for (var i = minTick; i < maxTick + avg; i = i + avg) {
ticks.push(Math.pow(base, i));
}
if (self.min === 0) {
ticks.unshift(0);
}
return ticks;
} // 获取度量计算时，value占的定义域百分比
;
_proto._getScalePercent = function _getScalePercent(value) {
var max = this.max;
var min = this.min;
if (max === min) {
return 0;
} // 如果值小于等于0，则按照0处理
if (value <= 0) {
return 0;
}
var base = this.base;
var positiveMin = this.positiveMin; // 如果min == 0, 则根据比0大的最小值，计算比例关系。这个最小值作为坐标轴上的第二个tick，第一个是0但是不显示
if (positiveMin) {
min = positiveMin * 1 / base;
}
var percent; // 如果数值小于次小值，那么就计算 value / 次小值 占整体的比例
if (value < positiveMin) {
percent = value / positiveMin / (log(base, max) - log(base, min));
} else {
percent = (log(base, value) - log(base, min)) / (log(base, max) - log(base, min));
}
return percent;
}
/**
* @override
*/
;
_proto.scale = function scale(value) {
var percent = this._getScalePercent(value);
var rangeMin = this.rangeMin();
var rangeMax = this.rangeMax();
return rangeMin + percent * (rangeMax - rangeMin);
}
/**
* @override
*/
;
_proto.invert = function invert(value) {
var base = this.base;
var max = log(base, this.max);
var rangeMin = this.rangeMin();
var range = this.rangeMax() - rangeMin;
var min;
var positiveMin = this.positiveMin;
if (positiveMin) {
if (value === 0) {
return 0;
}
min = log(base, positiveMin / base);
var appendPercent = 1 / (max - min) * range; // 0 到 positiveMin的占比
if (value < appendPercent) {
// 落到 0 - positiveMin 之间
return value / appendPercent * positiveMin;
}
} else {
min = log(base, this.min);
}
var percent = (value - rangeMin) / range;
var tmp = percent * (max - min) + min;
return Math.pow(base, tmp);
};
return Log;
}(Linear);
Base.Log = Log;
module.exports = Log;
/***/ }),
/* 25 */
/***/ (function(module, exports, __webpack_require__) {
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
/**
* @fileOverview 使用pow进行度量计算
* @author dxq613@gmail.com
*/
var Base = __webpack_require__(0);
var Linear = __webpack_require__(4); // 求以a为次幂，结果为b的基数，如 x^^a = b;求x
function calBase(a, b) {
var e = Math.E;
var value = Math.pow(e, Math.log(b) / a); // 使用换底公式求底
return value;
}
/**
* 度量的Pow计算
* @class Scale.Log
*/
var Pow = /*#__PURE__*/function (_Linear) {
_inheritsLoose(Pow, _Linear);
function Pow() {
return _Linear.apply(this, arguments) || this;
}
var _proto = Pow.prototype;
_proto._initDefaultCfg = function _initDefaultCfg() {
_Linear.prototype._initDefaultCfg.call(this);
this.type = 'pow';
/**
* @override
* pow 的坐标点的个数控制在10个以下
* @type {Number}
*/
this.tickCount = 10;
/**
* 进行pow计算的基数
* @type {Number}
*/
this.exponent = 2;
}
/**
* @override
*/
;
_proto.calculateTicks = function calculateTicks() {
var self = this;
var exponent = self.exponent;
var min;
var max = Math.ceil(calBase(exponent, self.max));
if (self.min >= 0) {
min = Math.floor(calBase(exponent, self.min));
} else {
min = 0;
}
if (min > max) {
var tmp = max;
max = min;
min = tmp;
}
var count = max - min;
var tickCount = self.tickCount;
var avg = Math.ceil(count / tickCount);
var ticks = [];
for (var i = min; i < max + avg; i = i + avg) {
ticks.push(Math.pow(i, exponent));
}
return ticks;
} // 获取度量计算时，value占的定义域百分比
;
_proto._getScalePercent = function _getScalePercent(value) {
var max = this.max;
var min = this.min;
if (max === min) {
return 0;
}
var exponent = this.exponent;
var percent = (calBase(exponent, value) - calBase(exponent, min)) / (calBase(exponent, max) - calBase(exponent, min));
return percent;
}
/**
* @override
*/
;
_proto.scale = function scale(value) {
var percent = this._getScalePercent(value);
var rangeMin = this.rangeMin();
var rangeMax = this.rangeMax();
return rangeMin + percent * (rangeMax - rangeMin);
}
/**
* @override
*/
;
_proto.invert = function invert(value) {
var percent = (value - this.rangeMin()) / (this.rangeMax() - this.rangeMin());
var exponent = this.exponent;
var max = calBase(exponent, this.max);
var min = calBase(exponent, this.min);
var tmp = percent * (max - min) + min;
return Math.pow(tmp, exponent);
};
return Pow;
}(Linear);
Base.Pow = Pow;
module.exports = Pow;
/***/ })
/******/ ]);
});
//# sourceMappingURL=scale.js.map
Reference in New Issue Copy Permalink