echarts
Version:
Apache ECharts is a powerful, interactive charting and data visualization library for browser
1,482 lines (1,463 loc) • 2.23 MB
JavaScript
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
typeof define === 'function' && define.amd ? define(['exports'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.echarts = {}));
}(this, (function (exports) { 'use strict';
/*! *****************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var Browser = (function () {
function Browser() {
this.firefox = false;
this.ie = false;
this.edge = false;
this.newEdge = false;
this.weChat = false;
}
return Browser;
}());
var Env = (function () {
function Env() {
this.browser = new Browser();
this.node = false;
this.wxa = false;
this.worker = false;
this.svgSupported = false;
this.touchEventsSupported = false;
this.pointerEventsSupported = false;
this.domSupported = false;
this.transformSupported = false;
this.transform3dSupported = false;
this.hasGlobalWindow = typeof window !== 'undefined';
}
return Env;
}());
var env = new Env();
if (typeof wx === 'object' && typeof wx.getSystemInfoSync === 'function') {
env.wxa = true;
env.touchEventsSupported = true;
}
else if (typeof document === 'undefined' && typeof self !== 'undefined') {
env.worker = true;
}
else if (!env.hasGlobalWindow || 'Deno' in window) {
env.node = true;
env.svgSupported = true;
}
else {
detect(navigator.userAgent, env);
}
function detect(ua, env) {
var browser = env.browser;
var firefox = ua.match(/Firefox\/([\d.]+)/);
var ie = ua.match(/MSIE\s([\d.]+)/)
|| ua.match(/Trident\/.+?rv:(([\d.]+))/);
var edge = ua.match(/Edge?\/([\d.]+)/);
var weChat = (/micromessenger/i).test(ua);
if (firefox) {
browser.firefox = true;
browser.version = firefox[1];
}
if (ie) {
browser.ie = true;
browser.version = ie[1];
}
if (edge) {
browser.edge = true;
browser.version = edge[1];
browser.newEdge = +edge[1].split('.')[0] > 18;
}
if (weChat) {
browser.weChat = true;
}
env.svgSupported = typeof SVGRect !== 'undefined';
env.touchEventsSupported = 'ontouchstart' in window && !browser.ie && !browser.edge;
env.pointerEventsSupported = 'onpointerdown' in window
&& (browser.edge || (browser.ie && +browser.version >= 11));
env.domSupported = typeof document !== 'undefined';
var style = document.documentElement.style;
env.transform3dSupported = ((browser.ie && 'transition' in style)
|| browser.edge
|| (('WebKitCSSMatrix' in window) && ('m11' in new WebKitCSSMatrix()))
|| 'MozPerspective' in style)
&& !('OTransition' in style);
env.transformSupported = env.transform3dSupported
|| (browser.ie && +browser.version >= 9);
}
var DEFAULT_FONT_SIZE = 12;
var DEFAULT_FONT_FAMILY = 'sans-serif';
var DEFAULT_FONT = DEFAULT_FONT_SIZE + "px " + DEFAULT_FONT_FAMILY;
var OFFSET = 20;
var SCALE = 100;
var defaultWidthMapStr = "007LLmW'55;N0500LLLLLLLLLL00NNNLzWW\\\\WQb\\0FWLg\\bWb\\WQ\\WrWWQ000CL5LLFLL0LL**F*gLLLL5F0LF\\FFF5.5N";
function getTextWidthMap(mapStr) {
var map = {};
if (typeof JSON === 'undefined') {
return map;
}
for (var i = 0; i < mapStr.length; i++) {
var char = String.fromCharCode(i + 32);
var size = (mapStr.charCodeAt(i) - OFFSET) / SCALE;
map[char] = size;
}
return map;
}
var DEFAULT_TEXT_WIDTH_MAP = getTextWidthMap(defaultWidthMapStr);
var platformApi = {
createCanvas: function () {
return typeof document !== 'undefined'
&& document.createElement('canvas');
},
measureText: (function () {
var _ctx;
var _cachedFont;
return function (text, font) {
if (!_ctx) {
var canvas = platformApi.createCanvas();
_ctx = canvas && canvas.getContext('2d');
}
if (_ctx) {
if (_cachedFont !== font) {
_cachedFont = _ctx.font = font || DEFAULT_FONT;
}
return _ctx.measureText(text);
}
else {
text = text || '';
font = font || DEFAULT_FONT;
var res = /((?:\d+)?\.?\d*)px/.exec(font);
var fontSize = res && +res[1] || DEFAULT_FONT_SIZE;
var width = 0;
if (font.indexOf('mono') >= 0) {
width = fontSize * text.length;
}
else {
for (var i = 0; i < text.length; i++) {
var preCalcWidth = DEFAULT_TEXT_WIDTH_MAP[text[i]];
width += preCalcWidth == null ? fontSize : (preCalcWidth * fontSize);
}
}
return { width: width };
}
};
})(),
loadImage: function (src, onload, onerror) {
var image = new Image();
image.onload = onload;
image.onerror = onerror;
image.src = src;
return image;
}
};
function setPlatformAPI(newPlatformApis) {
for (var key in platformApi) {
if (newPlatformApis[key]) {
platformApi[key] = newPlatformApis[key];
}
}
}
var BUILTIN_OBJECT = reduce([
'Function',
'RegExp',
'Date',
'Error',
'CanvasGradient',
'CanvasPattern',
'Image',
'Canvas'
], function (obj, val) {
obj['[object ' + val + ']'] = true;
return obj;
}, {});
var TYPED_ARRAY = reduce([
'Int8',
'Uint8',
'Uint8Clamped',
'Int16',
'Uint16',
'Int32',
'Uint32',
'Float32',
'Float64'
], function (obj, val) {
obj['[object ' + val + 'Array]'] = true;
return obj;
}, {});
var objToString = Object.prototype.toString;
var arrayProto = Array.prototype;
var nativeForEach = arrayProto.forEach;
var nativeFilter = arrayProto.filter;
var nativeSlice = arrayProto.slice;
var nativeMap = arrayProto.map;
var ctorFunction = function () { }.constructor;
var protoFunction = ctorFunction ? ctorFunction.prototype : null;
var protoKey = '__proto__';
var idStart = 0x0907;
function guid() {
return idStart++;
}
function logError() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
if (typeof console !== 'undefined') {
console.error.apply(console, args);
}
}
function clone(source) {
if (source == null || typeof source !== 'object') {
return source;
}
var result = source;
var typeStr = objToString.call(source);
if (typeStr === '[object Array]') {
if (!isPrimitive(source)) {
result = [];
for (var i = 0, len = source.length; i < len; i++) {
result[i] = clone(source[i]);
}
}
}
else if (TYPED_ARRAY[typeStr]) {
if (!isPrimitive(source)) {
var Ctor = source.constructor;
if (Ctor.from) {
result = Ctor.from(source);
}
else {
result = new Ctor(source.length);
for (var i = 0, len = source.length; i < len; i++) {
result[i] = source[i];
}
}
}
}
else if (!BUILTIN_OBJECT[typeStr] && !isPrimitive(source) && !isDom(source)) {
result = {};
for (var key in source) {
if (source.hasOwnProperty(key) && key !== protoKey) {
result[key] = clone(source[key]);
}
}
}
return result;
}
function merge(target, source, overwrite) {
if (!isObject(source) || !isObject(target)) {
return overwrite ? clone(source) : target;
}
for (var key in source) {
if (source.hasOwnProperty(key) && key !== protoKey) {
var targetProp = target[key];
var sourceProp = source[key];
if (isObject(sourceProp)
&& isObject(targetProp)
&& !isArray(sourceProp)
&& !isArray(targetProp)
&& !isDom(sourceProp)
&& !isDom(targetProp)
&& !isBuiltInObject(sourceProp)
&& !isBuiltInObject(targetProp)
&& !isPrimitive(sourceProp)
&& !isPrimitive(targetProp)) {
merge(targetProp, sourceProp, overwrite);
}
else if (overwrite || !(key in target)) {
target[key] = clone(source[key]);
}
}
}
return target;
}
function mergeAll(targetAndSources, overwrite) {
var result = targetAndSources[0];
for (var i = 1, len = targetAndSources.length; i < len; i++) {
result = merge(result, targetAndSources[i], overwrite);
}
return result;
}
function extend(target, source) {
if (Object.assign) {
Object.assign(target, source);
}
else {
for (var key in source) {
if (source.hasOwnProperty(key) && key !== protoKey) {
target[key] = source[key];
}
}
}
return target;
}
function defaults(target, source, overlay) {
var keysArr = keys(source);
for (var i = 0, len = keysArr.length; i < len; i++) {
var key = keysArr[i];
if ((overlay ? source[key] != null : target[key] == null)) {
target[key] = source[key];
}
}
return target;
}
var createCanvas = platformApi.createCanvas;
function indexOf(array, value) {
if (array) {
if (array.indexOf) {
return array.indexOf(value);
}
for (var i = 0, len = array.length; i < len; i++) {
if (array[i] === value) {
return i;
}
}
}
return -1;
}
function inherits(clazz, baseClazz) {
var clazzPrototype = clazz.prototype;
function F() { }
F.prototype = baseClazz.prototype;
clazz.prototype = new F();
for (var prop in clazzPrototype) {
if (clazzPrototype.hasOwnProperty(prop)) {
clazz.prototype[prop] = clazzPrototype[prop];
}
}
clazz.prototype.constructor = clazz;
clazz.superClass = baseClazz;
}
function mixin(target, source, override) {
target = 'prototype' in target ? target.prototype : target;
source = 'prototype' in source ? source.prototype : source;
if (Object.getOwnPropertyNames) {
var keyList = Object.getOwnPropertyNames(source);
for (var i = 0; i < keyList.length; i++) {
var key = keyList[i];
if (key !== 'constructor') {
if ((override ? source[key] != null : target[key] == null)) {
target[key] = source[key];
}
}
}
}
else {
defaults(target, source, override);
}
}
function isArrayLike(data) {
if (!data) {
return false;
}
if (typeof data === 'string') {
return false;
}
return typeof data.length === 'number';
}
function each(arr, cb, context) {
if (!(arr && cb)) {
return;
}
if (arr.forEach && arr.forEach === nativeForEach) {
arr.forEach(cb, context);
}
else if (arr.length === +arr.length) {
for (var i = 0, len = arr.length; i < len; i++) {
cb.call(context, arr[i], i, arr);
}
}
else {
for (var key in arr) {
if (arr.hasOwnProperty(key)) {
cb.call(context, arr[key], key, arr);
}
}
}
}
function map(arr, cb, context) {
if (!arr) {
return [];
}
if (!cb) {
return slice(arr);
}
if (arr.map && arr.map === nativeMap) {
return arr.map(cb, context);
}
else {
var result = [];
for (var i = 0, len = arr.length; i < len; i++) {
result.push(cb.call(context, arr[i], i, arr));
}
return result;
}
}
function reduce(arr, cb, memo, context) {
if (!(arr && cb)) {
return;
}
for (var i = 0, len = arr.length; i < len; i++) {
memo = cb.call(context, memo, arr[i], i, arr);
}
return memo;
}
function filter(arr, cb, context) {
if (!arr) {
return [];
}
if (!cb) {
return slice(arr);
}
if (arr.filter && arr.filter === nativeFilter) {
return arr.filter(cb, context);
}
else {
var result = [];
for (var i = 0, len = arr.length; i < len; i++) {
if (cb.call(context, arr[i], i, arr)) {
result.push(arr[i]);
}
}
return result;
}
}
function find(arr, cb, context) {
if (!(arr && cb)) {
return;
}
for (var i = 0, len = arr.length; i < len; i++) {
if (cb.call(context, arr[i], i, arr)) {
return arr[i];
}
}
}
function keys(obj) {
if (!obj) {
return [];
}
if (Object.keys) {
return Object.keys(obj);
}
var keyList = [];
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
keyList.push(key);
}
}
return keyList;
}
function bindPolyfill(func, context) {
var args = [];
for (var _i = 2; _i < arguments.length; _i++) {
args[_i - 2] = arguments[_i];
}
return function () {
return func.apply(context, args.concat(nativeSlice.call(arguments)));
};
}
var bind = (protoFunction && isFunction(protoFunction.bind))
? protoFunction.call.bind(protoFunction.bind)
: bindPolyfill;
function curry(func) {
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
return function () {
return func.apply(this, args.concat(nativeSlice.call(arguments)));
};
}
function isArray(value) {
if (Array.isArray) {
return Array.isArray(value);
}
return objToString.call(value) === '[object Array]';
}
function isFunction(value) {
return typeof value === 'function';
}
function isString(value) {
return typeof value === 'string';
}
function isStringSafe(value) {
return objToString.call(value) === '[object String]';
}
function isNumber(value) {
return typeof value === 'number';
}
function isObject(value) {
var type = typeof value;
return type === 'function' || (!!value && type === 'object');
}
function isBuiltInObject(value) {
return !!BUILTIN_OBJECT[objToString.call(value)];
}
function isTypedArray(value) {
return !!TYPED_ARRAY[objToString.call(value)];
}
function isDom(value) {
return typeof value === 'object'
&& typeof value.nodeType === 'number'
&& typeof value.ownerDocument === 'object';
}
function isGradientObject(value) {
return value.colorStops != null;
}
function isImagePatternObject(value) {
return value.image != null;
}
function isRegExp(value) {
return objToString.call(value) === '[object RegExp]';
}
function eqNaN(value) {
return value !== value;
}
function retrieve() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
for (var i = 0, len = args.length; i < len; i++) {
if (args[i] != null) {
return args[i];
}
}
}
function retrieve2(value0, value1) {
return value0 != null
? value0
: value1;
}
function retrieve3(value0, value1, value2) {
return value0 != null
? value0
: value1 != null
? value1
: value2;
}
function slice(arr) {
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
return nativeSlice.apply(arr, args);
}
function normalizeCssArray(val) {
if (typeof (val) === 'number') {
return [val, val, val, val];
}
var len = val.length;
if (len === 2) {
return [val[0], val[1], val[0], val[1]];
}
else if (len === 3) {
return [val[0], val[1], val[2], val[1]];
}
return val;
}
function assert(condition, message) {
if (!condition) {
throw new Error(message);
}
}
function trim(str) {
if (str == null) {
return null;
}
else if (typeof str.trim === 'function') {
return str.trim();
}
else {
return str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
}
}
var primitiveKey = '__ec_primitive__';
function setAsPrimitive(obj) {
obj[primitiveKey] = true;
}
function isPrimitive(obj) {
return obj[primitiveKey];
}
var MapPolyfill = (function () {
function MapPolyfill() {
this.data = {};
}
MapPolyfill.prototype["delete"] = function (key) {
var existed = this.has(key);
if (existed) {
delete this.data[key];
}
return existed;
};
MapPolyfill.prototype.has = function (key) {
return this.data.hasOwnProperty(key);
};
MapPolyfill.prototype.get = function (key) {
return this.data[key];
};
MapPolyfill.prototype.set = function (key, value) {
this.data[key] = value;
return this;
};
MapPolyfill.prototype.keys = function () {
return keys(this.data);
};
MapPolyfill.prototype.forEach = function (callback) {
var data = this.data;
for (var key in data) {
if (data.hasOwnProperty(key)) {
callback(data[key], key);
}
}
};
return MapPolyfill;
}());
var isNativeMapSupported = typeof Map === 'function';
function maybeNativeMap() {
return (isNativeMapSupported ? new Map() : new MapPolyfill());
}
var HashMap = (function () {
function HashMap(obj) {
var isArr = isArray(obj);
this.data = maybeNativeMap();
var thisMap = this;
(obj instanceof HashMap)
? obj.each(visit)
: (obj && each(obj, visit));
function visit(value, key) {
isArr ? thisMap.set(value, key) : thisMap.set(key, value);
}
}
HashMap.prototype.hasKey = function (key) {
return this.data.has(key);
};
HashMap.prototype.get = function (key) {
return this.data.get(key);
};
HashMap.prototype.set = function (key, value) {
this.data.set(key, value);
return value;
};
HashMap.prototype.each = function (cb, context) {
this.data.forEach(function (value, key) {
cb.call(context, value, key);
});
};
HashMap.prototype.keys = function () {
var keys = this.data.keys();
return isNativeMapSupported
? Array.from(keys)
: keys;
};
HashMap.prototype.removeKey = function (key) {
this.data["delete"](key);
};
return HashMap;
}());
function createHashMap(obj) {
return new HashMap(obj);
}
function concatArray(a, b) {
var newArray = new a.constructor(a.length + b.length);
for (var i = 0; i < a.length; i++) {
newArray[i] = a[i];
}
var offset = a.length;
for (var i = 0; i < b.length; i++) {
newArray[i + offset] = b[i];
}
return newArray;
}
function createObject(proto, properties) {
var obj;
if (Object.create) {
obj = Object.create(proto);
}
else {
var StyleCtor = function () { };
StyleCtor.prototype = proto;
obj = new StyleCtor();
}
if (properties) {
extend(obj, properties);
}
return obj;
}
function disableUserSelect(dom) {
var domStyle = dom.style;
domStyle.webkitUserSelect = 'none';
domStyle.userSelect = 'none';
domStyle.webkitTapHighlightColor = 'rgba(0,0,0,0)';
domStyle['-webkit-touch-callout'] = 'none';
}
function hasOwn(own, prop) {
return own.hasOwnProperty(prop);
}
function noop() { }
var RADIAN_TO_DEGREE = 180 / Math.PI;
var util = /*#__PURE__*/Object.freeze({
__proto__: null,
guid: guid,
logError: logError,
clone: clone,
merge: merge,
mergeAll: mergeAll,
extend: extend,
defaults: defaults,
createCanvas: createCanvas,
indexOf: indexOf,
inherits: inherits,
mixin: mixin,
isArrayLike: isArrayLike,
each: each,
map: map,
reduce: reduce,
filter: filter,
find: find,
keys: keys,
bind: bind,
curry: curry,
isArray: isArray,
isFunction: isFunction,
isString: isString,
isStringSafe: isStringSafe,
isNumber: isNumber,
isObject: isObject,
isBuiltInObject: isBuiltInObject,
isTypedArray: isTypedArray,
isDom: isDom,
isGradientObject: isGradientObject,
isImagePatternObject: isImagePatternObject,
isRegExp: isRegExp,
eqNaN: eqNaN,
retrieve: retrieve,
retrieve2: retrieve2,
retrieve3: retrieve3,
slice: slice,
normalizeCssArray: normalizeCssArray,
assert: assert,
trim: trim,
setAsPrimitive: setAsPrimitive,
isPrimitive: isPrimitive,
HashMap: HashMap,
createHashMap: createHashMap,
concatArray: concatArray,
createObject: createObject,
disableUserSelect: disableUserSelect,
hasOwn: hasOwn,
noop: noop,
RADIAN_TO_DEGREE: RADIAN_TO_DEGREE
});
function create(x, y) {
if (x == null) {
x = 0;
}
if (y == null) {
y = 0;
}
return [x, y];
}
function copy(out, v) {
out[0] = v[0];
out[1] = v[1];
return out;
}
function clone$1(v) {
return [v[0], v[1]];
}
function set(out, a, b) {
out[0] = a;
out[1] = b;
return out;
}
function add(out, v1, v2) {
out[0] = v1[0] + v2[0];
out[1] = v1[1] + v2[1];
return out;
}
function scaleAndAdd(out, v1, v2, a) {
out[0] = v1[0] + v2[0] * a;
out[1] = v1[1] + v2[1] * a;
return out;
}
function sub(out, v1, v2) {
out[0] = v1[0] - v2[0];
out[1] = v1[1] - v2[1];
return out;
}
function len(v) {
return Math.sqrt(lenSquare(v));
}
var length = len;
function lenSquare(v) {
return v[0] * v[0] + v[1] * v[1];
}
var lengthSquare = lenSquare;
function mul(out, v1, v2) {
out[0] = v1[0] * v2[0];
out[1] = v1[1] * v2[1];
return out;
}
function div(out, v1, v2) {
out[0] = v1[0] / v2[0];
out[1] = v1[1] / v2[1];
return out;
}
function dot(v1, v2) {
return v1[0] * v2[0] + v1[1] * v2[1];
}
function scale(out, v, s) {
out[0] = v[0] * s;
out[1] = v[1] * s;
return out;
}
function normalize(out, v) {
var d = len(v);
if (d === 0) {
out[0] = 0;
out[1] = 0;
}
else {
out[0] = v[0] / d;
out[1] = v[1] / d;
}
return out;
}
function distance(v1, v2) {
return Math.sqrt((v1[0] - v2[0]) * (v1[0] - v2[0])
+ (v1[1] - v2[1]) * (v1[1] - v2[1]));
}
var dist = distance;
function distanceSquare(v1, v2) {
return (v1[0] - v2[0]) * (v1[0] - v2[0])
+ (v1[1] - v2[1]) * (v1[1] - v2[1]);
}
var distSquare = distanceSquare;
function negate(out, v) {
out[0] = -v[0];
out[1] = -v[1];
return out;
}
function lerp(out, v1, v2, t) {
out[0] = v1[0] + t * (v2[0] - v1[0]);
out[1] = v1[1] + t * (v2[1] - v1[1]);
return out;
}
function applyTransform(out, v, m) {
var x = v[0];
var y = v[1];
out[0] = m[0] * x + m[2] * y + m[4];
out[1] = m[1] * x + m[3] * y + m[5];
return out;
}
function min(out, v1, v2) {
out[0] = Math.min(v1[0], v2[0]);
out[1] = Math.min(v1[1], v2[1]);
return out;
}
function max(out, v1, v2) {
out[0] = Math.max(v1[0], v2[0]);
out[1] = Math.max(v1[1], v2[1]);
return out;
}
var vector = /*#__PURE__*/Object.freeze({
__proto__: null,
create: create,
copy: copy,
clone: clone$1,
set: set,
add: add,
scaleAndAdd: scaleAndAdd,
sub: sub,
len: len,
length: length,
lenSquare: lenSquare,
lengthSquare: lengthSquare,
mul: mul,
div: div,
dot: dot,
scale: scale,
normalize: normalize,
distance: distance,
dist: dist,
distanceSquare: distanceSquare,
distSquare: distSquare,
negate: negate,
lerp: lerp,
applyTransform: applyTransform,
min: min,
max: max
});
var Param = (function () {
function Param(target, e) {
this.target = target;
this.topTarget = e && e.topTarget;
}
return Param;
}());
var Draggable = (function () {
function Draggable(handler) {
this.handler = handler;
handler.on('mousedown', this._dragStart, this);
handler.on('mousemove', this._drag, this);
handler.on('mouseup', this._dragEnd, this);
}
Draggable.prototype._dragStart = function (e) {
var draggingTarget = e.target;
while (draggingTarget && !draggingTarget.draggable) {
draggingTarget = draggingTarget.parent || draggingTarget.__hostTarget;
}
if (draggingTarget) {
this._draggingTarget = draggingTarget;
draggingTarget.dragging = true;
this._x = e.offsetX;
this._y = e.offsetY;
this.handler.dispatchToElement(new Param(draggingTarget, e), 'dragstart', e.event);
}
};
Draggable.prototype._drag = function (e) {
var draggingTarget = this._draggingTarget;
if (draggingTarget) {
var x = e.offsetX;
var y = e.offsetY;
var dx = x - this._x;
var dy = y - this._y;
this._x = x;
this._y = y;
draggingTarget.drift(dx, dy, e);
this.handler.dispatchToElement(new Param(draggingTarget, e), 'drag', e.event);
var dropTarget = this.handler.findHover(x, y, draggingTarget).target;
var lastDropTarget = this._dropTarget;
this._dropTarget = dropTarget;
if (draggingTarget !== dropTarget) {
if (lastDropTarget && dropTarget !== lastDropTarget) {
this.handler.dispatchToElement(new Param(lastDropTarget, e), 'dragleave', e.event);
}
if (dropTarget && dropTarget !== lastDropTarget) {
this.handler.dispatchToElement(new Param(dropTarget, e), 'dragenter', e.event);
}
}
}
};
Draggable.prototype._dragEnd = function (e) {
var draggingTarget = this._draggingTarget;
if (draggingTarget) {
draggingTarget.dragging = false;
}
this.handler.dispatchToElement(new Param(draggingTarget, e), 'dragend', e.event);
if (this._dropTarget) {
this.handler.dispatchToElement(new Param(this._dropTarget, e), 'drop', e.event);
}
this._draggingTarget = null;
this._dropTarget = null;
};
return Draggable;
}());
var Eventful = (function () {
function Eventful(eventProcessors) {
if (eventProcessors) {
this._$eventProcessor = eventProcessors;
}
}
Eventful.prototype.on = function (event, query, handler, context) {
if (!this._$handlers) {
this._$handlers = {};
}
var _h = this._$handlers;
if (typeof query === 'function') {
context = handler;
handler = query;
query = null;
}
if (!handler || !event) {
return this;
}
var eventProcessor = this._$eventProcessor;
if (query != null && eventProcessor && eventProcessor.normalizeQuery) {
query = eventProcessor.normalizeQuery(query);
}
if (!_h[event]) {
_h[event] = [];
}
for (var i = 0; i < _h[event].length; i++) {
if (_h[event][i].h === handler) {
return this;
}
}
var wrap = {
h: handler,
query: query,
ctx: (context || this),
callAtLast: handler.zrEventfulCallAtLast
};
var lastIndex = _h[event].length - 1;
var lastWrap = _h[event][lastIndex];
(lastWrap && lastWrap.callAtLast)
? _h[event].splice(lastIndex, 0, wrap)
: _h[event].push(wrap);
return this;
};
Eventful.prototype.isSilent = function (eventName) {
var _h = this._$handlers;
return !_h || !_h[eventName] || !_h[eventName].length;
};
Eventful.prototype.off = function (eventType, handler) {
var _h = this._$handlers;
if (!_h) {
return this;
}
if (!eventType) {
this._$handlers = {};
return this;
}
if (handler) {
if (_h[eventType]) {
var newList = [];
for (var i = 0, l = _h[eventType].length; i < l; i++) {
if (_h[eventType][i].h !== handler) {
newList.push(_h[eventType][i]);
}
}
_h[eventType] = newList;
}
if (_h[eventType] && _h[eventType].length === 0) {
delete _h[eventType];
}
}
else {
delete _h[eventType];
}
return this;
};
Eventful.prototype.trigger = function (eventType) {
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
if (!this._$handlers) {
return this;
}
var _h = this._$handlers[eventType];
var eventProcessor = this._$eventProcessor;
if (_h) {
var argLen = args.length;
var len = _h.length;
for (var i = 0; i < len; i++) {
var hItem = _h[i];
if (eventProcessor
&& eventProcessor.filter
&& hItem.query != null
&& !eventProcessor.filter(eventType, hItem.query)) {
continue;
}
switch (argLen) {
case 0:
hItem.h.call(hItem.ctx);
break;
case 1:
hItem.h.call(hItem.ctx, args[0]);
break;
case 2:
hItem.h.call(hItem.ctx, args[0], args[1]);
break;
default:
hItem.h.apply(hItem.ctx, args);
break;
}
}
}
eventProcessor && eventProcessor.afterTrigger
&& eventProcessor.afterTrigger(eventType);
return this;
};
Eventful.prototype.triggerWithContext = function (type) {
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
if (!this._$handlers) {
return this;
}
var _h = this._$handlers[type];
var eventProcessor = this._$eventProcessor;
if (_h) {
var argLen = args.length;
var ctx = args[argLen - 1];
var len = _h.length;
for (var i = 0; i < len; i++) {
var hItem = _h[i];
if (eventProcessor
&& eventProcessor.filter
&& hItem.query != null
&& !eventProcessor.filter(type, hItem.query)) {
continue;
}
switch (argLen) {
case 0:
hItem.h.call(ctx);
break;
case 1:
hItem.h.call(ctx, args[0]);
break;
case 2:
hItem.h.call(ctx, args[0], args[1]);
break;
default:
hItem.h.apply(ctx, args.slice(1, argLen - 1));
break;
}
}
}
eventProcessor && eventProcessor.afterTrigger
&& eventProcessor.afterTrigger(type);
return this;
};
return Eventful;
}());
var LN2 = Math.log(2);
function determinant(rows, rank, rowStart, rowMask, colMask, detCache) {
var cacheKey = rowMask + '-' + colMask;
var fullRank = rows.length;
if (detCache.hasOwnProperty(cacheKey)) {
return detCache[cacheKey];
}
if (rank === 1) {
var colStart = Math.round(Math.log(((1 << fullRank) - 1) & ~colMask) / LN2);
return rows[rowStart][colStart];
}
var subRowMask = rowMask | (1 << rowStart);
var subRowStart = rowStart + 1;
while (rowMask & (1 << subRowStart)) {
subRowStart++;
}
var sum = 0;
for (var j = 0, colLocalIdx = 0; j < fullRank; j++) {
var colTag = 1 << j;
if (!(colTag & colMask)) {
sum += (colLocalIdx % 2 ? -1 : 1) * rows[rowStart][j]
* determinant(rows, rank - 1, subRowStart, subRowMask, colMask | colTag, detCache);
colLocalIdx++;
}
}
detCache[cacheKey] = sum;
return sum;
}
function buildTransformer(src, dest) {
var mA = [
[src[0], src[1], 1, 0, 0, 0, -dest[0] * src[0], -dest[0] * src[1]],
[0, 0, 0, src[0], src[1], 1, -dest[1] * src[0], -dest[1] * src[1]],
[src[2], src[3], 1, 0, 0, 0, -dest[2] * src[2], -dest[2] * src[3]],
[0, 0, 0, src[2], src[3], 1, -dest[3] * src[2], -dest[3] * src[3]],
[src[4], src[5], 1, 0, 0, 0, -dest[4] * src[4], -dest[4] * src[5]],
[0, 0, 0, src[4], src[5], 1, -dest[5] * src[4], -dest[5] * src[5]],
[src[6], src[7], 1, 0, 0, 0, -dest[6] * src[6], -dest[6] * src[7]],
[0, 0, 0, src[6], src[7], 1, -dest[7] * src[6], -dest[7] * src[7]]
];
var detCache = {};
var det = determinant(mA, 8, 0, 0, 0, detCache);
if (det === 0) {
return;
}
var vh = [];
for (var i = 0; i < 8; i++) {
for (var j = 0; j < 8; j++) {
vh[j] == null && (vh[j] = 0);
vh[j] += ((i + j) % 2 ? -1 : 1)
* determinant(mA, 7, i === 0 ? 1 : 0, 1 << i, 1 << j, detCache)
/ det * dest[i];
}
}
return function (out, srcPointX, srcPointY) {
var pk = srcPointX * vh[6] + srcPointY * vh[7] + 1;
out[0] = (srcPointX * vh[0] + srcPointY * vh[1] + vh[2]) / pk;
out[1] = (srcPointX * vh[3] + srcPointY * vh[4] + vh[5]) / pk;
};
}
var EVENT_SAVED_PROP = '___zrEVENTSAVED';
var _calcOut = [];
function transformLocalCoord(out, elFrom, elTarget, inX, inY) {
return transformCoordWithViewport(_calcOut, elFrom, inX, inY, true)
&& transformCoordWithViewport(out, elTarget, _calcOut[0], _calcOut[1]);
}
function transformCoordWithViewport(out, el, inX, inY, inverse) {
if (el.getBoundingClientRect && env.domSupported && !isCanvasEl(el)) {
var saved = el[EVENT_SAVED_PROP] || (el[EVENT_SAVED_PROP] = {});
var markers = prepareCoordMarkers(el, saved);
var transformer = preparePointerTransformer(markers, saved, inverse);
if (transformer) {
transformer(out, inX, inY);
return true;
}
}
return false;
}
function prepareCoordMarkers(el, saved) {
var markers = saved.markers;
if (markers) {
return markers;
}
markers = saved.markers = [];
var propLR = ['left', 'right'];
var propTB = ['top', 'bottom'];
for (var i = 0; i < 4; i++) {
var marker = document.createElement('div');
var stl = marker.style;
var idxLR = i % 2;
var idxTB = (i >> 1) % 2;
stl.cssText = [
'position: absolute',
'visibility: hidden',
'padding: 0',
'margin: 0',
'border-width: 0',
'user-select: none',
'width:0',
'height:0',
propLR[idxLR] + ':0',
propTB[idxTB] + ':0',
propLR[1 - idxLR] + ':auto',
propTB[1 - idxTB] + ':auto',
''
].join('!important;');
el.appendChild(marker);
markers.push(marker);
}
return markers;
}
function preparePointerTransformer(markers, saved, inverse) {
var transformerName = inverse ? 'invTrans' : 'trans';
var transformer = saved[transformerName];
var oldSrcCoords = saved.srcCoords;
var srcCoords = [];
var destCoords = [];
var oldCoordTheSame = true;
for (var i = 0; i < 4; i++) {
var rect = markers[i].getBoundingClientRect();
var ii = 2 * i;
var x = rect.left;
var y = rect.top;
srcCoords.push(x, y);
oldCoordTheSame = oldCoordTheSame && oldSrcCoords && x === oldSrcCoords[ii] && y === oldSrcCoords[ii + 1];
destCoords.push(markers[i].offsetLeft, markers[i].offsetTop);
}
return (oldCoordTheSame && transformer)
? transformer
: (saved.srcCoords = srcCoords,
saved[transformerName] = inverse
? buildTransformer(destCoords, srcCoords)
: buildTransformer(srcCoords, destCoords));
}
function isCanvasEl(el) {
return el.nodeName.toUpperCase() === 'CANVAS';
}
var replaceReg = /([&<>"'])/g;
var replaceMap = {
'&': '&',
'<': '<',
'>': '>',
'"': '"',
'\'': '''
};
function encodeHTML(source) {
return source == null
? ''
: (source + '').replace(replaceReg, function (str, c) {
return replaceMap[c];
});
}
var MOUSE_EVENT_REG = /^(?:mouse|pointer|contextmenu|drag|drop)|click/;
var _calcOut$1 = [];
var firefoxNotSupportOffsetXY = env.browser.firefox
&& +env.browser.version.split('.')[0] < 39;
function clientToLocal(el, e, out, calculate) {
out = out || {};
if (calculate) {
calculateZrXY(el, e, out);
}
else if (firefoxNotSupportOffsetXY
&& e.layerX != null
&& e.layerX !== e.offsetX) {
out.zrX = e.layerX;
out.zrY = e.layerY;
}
else if (e.offsetX != null) {
out.zrX = e.offsetX;
out.zrY = e.offsetY;
}
else {
calculateZrXY(el, e, out);
}
return out;
}
function calculateZrXY(el, e, out) {
if (env.domSupported && el.getBoundingClientRect) {
var ex = e.clientX;
var ey = e.clientY;
if (isCanvasEl(el)) {
var box = el.getBoundingClientRect();
out.zrX = ex - box.left;
out.zrY = ey - box.top;
return;
}
else {
if (transformCoordWithViewport(_calcOut$1, el, ex, ey)) {
out.zrX = _calcOut$1[0];
out.zrY = _calcOut$1[1];
return;
}
}
}
out.zrX = out.zrY = 0;
}
function getNativeEvent(e) {
return e
|| window.event;
}
function normalizeEvent(el, e, calculate) {
e = getNativeEvent(e);
if (e.zrX != null) {
return e;
}
var eventType = e.type;
var isTouch = eventType && eventType.indexOf('touch') >= 0;
if (!isTouch) {
clientToLocal(el, e, e, calculate);
var wheelDelta = getWheelDeltaMayPolyfill(e);
e.zrDelta = wheelDelta ? wheelDelta / 120 : -(e.detail || 0) / 3;
}
else {
var touch = eventType !== 'touchend'
? e.targetTouches[0]
: e.changedTouches[0];
touch && clientToLocal(el, touch, e, calculate);
}
var button = e.button;
if (e.which == null && button !== undefined && MOUSE_EVENT_REG.test(e.type)) {
e.which = (button & 1 ? 1 : (button & 2 ? 3 : (button & 4 ? 2 : 0)));
}
return e;
}
function getWheelDeltaMayPolyfill(e) {
var rawWheelDelta = e.wheelDelta;
if (rawWheelDelta) {
return rawWheelDelta;
}
var deltaX = e.deltaX;
var deltaY = e.deltaY;
if (deltaX == null || deltaY == null) {
return rawWheelDelta;
}
var delta = deltaY !== 0 ? Math.abs(deltaY) : Math.abs(deltaX);
var sign = deltaY > 0 ? -1
: deltaY < 0 ? 1
: deltaX > 0 ? -1
: 1;
return 3 * delta * sign;
}
function addEventListener(el, name, handler, opt) {
el.addEventListener(name, handler, opt);
}
function removeEventListener(el, name, handler, opt) {
el.removeEventListener(name, handler, opt);
}
var stop = function (e) {
e.preventDefault();
e.stopPropagation();
e.cancelBubble = true;
};
function isMiddleOrRightButtonOnMouseUpDown(e) {
return e.which === 2 || e.which === 3;
}
var GestureMgr = (function () {
function GestureMgr() {
this._track = [];
}
GestureMgr.prototype.recognize = function (event, target, root) {
this._doTrack(event, target, root);
return this._recognize(event);
};
GestureMgr.prototype.clear = function () {
this._track.length = 0;
return this;
};
GestureMgr.prototype._doTrack = function (event, target, root) {
var touches = event.touches;
if (!touches) {
return;
}
var trackItem = {
points: [],
touches: [],
target: target,
event: event
};
for (var i = 0, len = touches.length; i < len; i++) {
var touch = touches[i];
var pos = clientToLocal(root, touch, {});
trackItem.points.push([pos.zrX, pos.zrY]);
trackItem.touches.push(touch);
}
this._track.push(trackItem);
};
GestureMgr.prototype._recognize = function (event) {
for (var eventName in recognizers) {
if (recognizers.hasOwnProperty(eventName)) {
var gestureInfo = recognizers[eventName](this._track, event);
if (gestureInfo) {
return gestureInfo;
}
}
}
};
return GestureMgr;
}());
function dist$1(pointPair) {
var dx = pointPair[1][0] - pointPair[0][0];
var dy = pointPair[1][1] - pointPair[0][1];
return Math.sqrt(dx * dx + dy * dy);
}
function center(pointPair) {
return [
(pointPair[0][0] + pointPair[1][0]) / 2,
(pointPair[0][1] +