@antv/f2
Version:
Charts for mobile visualization.
1,750 lines (1,654 loc) • 620 kB
JavaScript
(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.F2 = {}));
}(this, (function (exports) { 'use strict';
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
function createCommonjsModule(fn, basedir, module) {
return module = {
path: basedir,
exports: {},
require: function (path, base) {
return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
}
}, fn(module, module.exports), module.exports;
}
function commonjsRequire () {
throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
}
var _typeof_1 = createCommonjsModule(function (module) {
function _typeof(obj) {
"@babel/helpers - typeof";
return (module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
return typeof obj;
} : function (obj) {
return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
}, module.exports.__esModule = true, module.exports["default"] = module.exports), _typeof(obj);
}
module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports;
});
var _typeof = /*@__PURE__*/getDefaultExportFromCjs(_typeof_1);
var toPrimitive = createCommonjsModule(function (module) {
var _typeof = _typeof_1["default"];
function _toPrimitive(input, hint) {
if (_typeof(input) !== "object" || input === null) return input;
var prim = input[Symbol.toPrimitive];
if (prim !== undefined) {
var res = prim.call(input, hint || "default");
if (_typeof(res) !== "object") return res;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return (hint === "string" ? String : Number)(input);
}
module.exports = _toPrimitive, module.exports.__esModule = true, module.exports["default"] = module.exports;
});
var toPropertyKey = createCommonjsModule(function (module) {
var _typeof = _typeof_1["default"];
function _toPropertyKey(arg) {
var key = toPrimitive(arg, "string");
return _typeof(key) === "symbol" ? key : String(key);
}
module.exports = _toPropertyKey, module.exports.__esModule = true, module.exports["default"] = module.exports;
});
var defineProperty = createCommonjsModule(function (module) {
function _defineProperty(obj, key, value) {
key = toPropertyKey(key);
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
});
var _defineProperty = /*@__PURE__*/getDefaultExportFromCjs(defineProperty);
var objectSpread2 = createCommonjsModule(function (module) {
function ownKeys(object, enumerableOnly) {
var keys = Object.keys(object);
if (Object.getOwnPropertySymbols) {
var symbols = Object.getOwnPropertySymbols(object);
enumerableOnly && (symbols = symbols.filter(function (sym) {
return Object.getOwnPropertyDescriptor(object, sym).enumerable;
})), keys.push.apply(keys, symbols);
}
return keys;
}
function _objectSpread2(target) {
for (var i = 1; i < arguments.length; i++) {
var source = null != arguments[i] ? arguments[i] : {};
i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
defineProperty(target, key, source[key]);
}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
});
}
return target;
}
module.exports = _objectSpread2, module.exports.__esModule = true, module.exports["default"] = module.exports;
});
var _objectSpread = /*@__PURE__*/getDefaultExportFromCjs(objectSpread2);
var isArrayLike = function (value) {
/**
* isArrayLike([1, 2, 3]) => true
* isArrayLike(document.body.children) => true
* isArrayLike('abc') => true
* isArrayLike(Function) => false
*/
return value !== null && typeof value !== 'function' && isFinite(value.length);
};
var filter = function (arr, func) {
if (!isArrayLike(arr)) {
return arr;
}
var result = [];
for (var index = 0; index < arr.length; index++) {
var value = arr[index];
if (func(value, index)) {
result.push(value);
}
}
return result;
};
var toString = {}.toString;
var isType = function (value, type) { return toString.call(value) === '[object ' + type + ']'; };
/**
* 是否为函数
* @param {*} fn 对象
* @return {Boolean} 是否函数
*/
var isFunction = (function (value) {
return isType(value, 'Function');
});
// isFinite,
var isNil = function (value) {
/**
* isNil(null) => true
* isNil() => true
*/
return value === null || value === undefined;
};
var isArray = (function (value) {
return Array.isArray ?
Array.isArray(value) :
isType(value, 'Array');
});
var isObject = (function (value) {
/**
* isObject({}) => true
* isObject([1, 2, 3]) => true
* isObject(Function) => true
* isObject(null) => false
*/
var type = typeof value;
return value !== null && type === 'object' || type === 'function';
});
function each(elements, func) {
if (!elements) {
return;
}
var rst;
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;
}
}
}
}
}
var keys = Object.keys ? function (obj) { return Object.keys(obj); } : function (obj) {
var result = [];
each(obj, function (value, key) {
if (!(isFunction(obj) && key === 'prototype')) {
result.push(key);
}
});
return result;
};
function isMatch(obj, attrs) {
var _keys = keys(attrs);
var length = _keys.length;
if (isNil(obj))
return !length;
for (var i = 0; i < length; i += 1) {
var key = _keys[i];
if (attrs[key] !== obj[key] || !(key in obj)) {
return false;
}
}
return true;
}
var isObjectLike = function (value) {
/**
* isObjectLike({}) => true
* isObjectLike([1, 2, 3]) => true
* isObjectLike(Function) => false
* isObjectLike(null) => false
*/
return typeof value === 'object' && value !== null;
};
var isPlainObject = function (value) {
/**
* isObjectLike(new Foo) => false
* isObjectLike([1, 2, 3]) => false
* isObjectLike({ x: 0, y: 0 }) => true
* isObjectLike(Object.create(null)) => true
*/
if (!isObjectLike(value) || !isType(value, 'Object')) {
return false;
}
if (Object.getPrototypeOf(value) === null) {
return true;
}
var proto = value;
while (Object.getPrototypeOf(proto) !== null) {
proto = Object.getPrototypeOf(proto);
}
return Object.getPrototypeOf(value) === proto;
};
function find(arr, predicate) {
if (!isArray(arr))
return null;
var _predicate;
if (isFunction(predicate)) {
_predicate = predicate;
}
if (isPlainObject(predicate)) {
_predicate = function (a) { return isMatch(a, predicate); };
}
if (_predicate) {
for (var i = 0; i < arr.length; i += 1) {
if (_predicate(arr[i])) {
return arr[i];
}
}
}
return null;
}
function findIndex(arr, predicate, fromIndex) {
if (fromIndex === void 0) { fromIndex = 0; }
for (var i = fromIndex; i < arr.length; i++) {
if (predicate(arr[i], i)) {
// 找到终止循环
return i;
}
}
return -1;
}
/**
* Flattens `array` a single level deep.
*
* @param {Array} arr The array to flatten.
* @return {Array} Returns the new flattened array.
* @example
*
* flatten([1, [2, [3, [4]], 5]]); // => [1, 2, [3, [4]], 5]
*/
var flatten = function (arr) {
if (!isArray(arr)) {
return [];
}
var rst = [];
for (var i = 0; i < arr.length; i++) {
rst = rst.concat(arr[i]);
}
return rst;
};
/**
* @param {Array} arr The array to iterate over.
* @return {*} Returns the maximum value.
* @example
*
* max([1, 2]);
* // => 2
*
* max([]);
* // => undefined
*
* const data = new Array(1250010).fill(1).map((d,idx) => idx);
*
* max(data);
* // => 1250010
* // Math.max(...data) will encounter "Maximum call stack size exceeded" error
*/
var getMax = (function (arr) {
if (!isArray(arr)) {
return undefined;
}
return arr.reduce(function (prev, curr) {
return Math.max(prev, curr);
}, arr[0]);
});
/**
* @param {Array} arr The array to iterate over.
* @return {*} Returns the minimum value.
* @example
*
* min([1, 2]);
* // => 1
*
* min([]);
* // => undefined
*
* const data = new Array(1250010).fill(1).map((d,idx) => idx);
*
* min(data);
* // => 1250010
* // Math.min(...data) will encounter "Maximum call stack size exceeded" error
*/
var getMin = (function (arr) {
if (!isArray(arr)) {
return undefined;
}
return arr.reduce(function (prev, curr) {
return Math.min(prev, curr);
}, arr[0]);
});
var getRange = function (values) {
// 存在 NaN 时，min,max 判定会出问题
var filterValues = values.filter(function (v) { return !isNaN(v); });
if (!filterValues.length) {
// 如果没有数值则直接返回0
return {
min: 0,
max: 0,
};
}
if (isArray(values[0])) {
var tmp = [];
for (var i = 0; i < values.length; i++) {
tmp = tmp.concat(values[i]);
}
filterValues = tmp;
}
var max = getMax(filterValues);
var min = getMin(filterValues);
return {
min: min,
max: max,
};
};
var reduce = function (arr, fn, init) {
if (!isArray(arr) && !isPlainObject(arr)) {
return arr;
}
var result = init;
each(arr, function (data, i) {
result = fn(result, data, i);
});
return result;
};
var isString = (function (str) {
return isType(str, 'String');
});
var valuesOfKey = (function (data, name) {
var rst = [];
var tmpMap = {};
for (var i = 0; i < data.length; i++) {
var obj = data[i];
var value = obj[name];
if (!isNil(value)) {
// flatten
if (!isArray(value)) {
value = [value];
}
for (var j = 0; j < value.length; j++) {
var val = value[j];
// unique
if (!tmpMap[val]) {
rst.push(val);
tmpMap[val] = true;
}
}
}
}
return rst;
});
function head(o) {
if (isArrayLike(o)) {
return o[0];
}
return undefined;
}
function last(o) {
if (isArrayLike(o)) {
var arr = o;
return arr[arr.length - 1];
}
return undefined;
}
var hasOwnProperty = Object.prototype.hasOwnProperty;
function groupBy(data, condition) {
if (!condition || !isArray(data)) {
return {};
}
var result = {};
// 兼容方法和 字符串的写法
var predicate = isFunction(condition) ? condition : function (item) { return item[condition]; };
var key;
for (var i = 0; i < data.length; i++) {
var item = data[i];
key = predicate(item);
if (hasOwnProperty.call(result, key)) {
result[key].push(item);
}
else {
result[key] = [item];
}
}
return result;
}
/**
* 将数据分组成 map
* @param data
* @param condition
*/
function groupToMap(data, condition) {
if (!condition) {
return {
0: data,
};
}
if (!isFunction(condition)) {
// 如果是字符串，则按照 a*b 风格成数组
var paramscondition_1 = isArray(condition) ? condition : condition.replace(/\s+/g, '').split('*');
condition = function (row) {
var unique = '_'; // 避免出现数字作为Key的情况，会进行按照数字的排序
// 根据字段列表的值，拼接成 key
for (var i = 0, l = paramscondition_1.length; i < l; i++) {
unique += row[paramscondition_1[i]] && row[paramscondition_1[i]].toString();
}
return unique;
};
}
return groupBy(data, condition);
}
var group = (function (data, condition) {
if (!condition) {
// 没有条件，则自身改成数组
return [data];
}
var groups = groupToMap(data, condition);
var array = [];
for (var i in groups) {
array.push(groups[i]);
}
return array;
});
var fixedBase = function (v, base) {
var str = base.toString();
var index = str.indexOf('.');
if (index === -1) {
return Math.round(v);
}
var length = str.substr(index + 1).length;
if (length > 20) {
length = 20;
}
return parseFloat(v.toFixed(length));
};
/**
* 判断是否数字
* @return {Boolean} 是否数字
*/
var isNumber = function (value) {
return isType(value, 'Number');
};
var PRECISION = 0.00001; // numbers less than this is considered as 0
function isNumberEqual(a, b, precision) {
if (precision === void 0) { precision = PRECISION; }
return Math.abs((a - b)) < precision;
}
// @ts-ignore
var values = Object.values ? function (obj) { return Object.values(obj); } : function (obj) {
var result = [];
each(obj, function (value, key) {
if (!(isFunction(obj) && key === 'prototype')) {
result.push(value);
}
});
return result;
};
var toString$1 = (function (value) {
if (isNil(value))
return '';
return value.toString();
});
function substitute(str, o) {
if (!str || !o) {
return str;
}
return str.replace(/\\?\{([^{}]+)\}/g, function (match, name) {
if (match.charAt(0) === '\\') {
return match.slice(1);
}
return (o[name] === undefined) ? '' : o[name];
});
}
var upperFirst = function (value) {
var str = toString$1(value);
return str.charAt(0).toUpperCase() + str.substring(1);
};
var toString$2 = {}.toString;
var getType = function (value) {
return toString$2.call(value).replace(/^\[object /, '').replace(/]$/, '');
};
/**
* 是否是布尔类型
*
* @param {Object} value 测试的值
* @return {Boolean}
*/
var isBoolean = function (value) {
return isType(value, 'Boolean');
};
var isDate = function (value) {
return isType(value, 'Date');
};
var objectProto = Object.prototype;
var isPrototype = function (value) {
var Ctor = value && value.constructor;
var proto = (typeof Ctor === 'function' && Ctor.prototype) || objectProto;
return value === proto;
};
var isUndefined = function (value) {
return value === undefined;
};
// FIXME: Mutable param should be forbidden in static lang.
function _mix(dist, obj) {
for (var key in obj) {
if (obj.hasOwnProperty(key) && key !== 'constructor' && obj[key] !== undefined) {
dist[key] = obj[key];
}
}
}
function mix(dist, src1, src2, src3) {
if (src1)
_mix(dist, src1);
if (src2)
_mix(dist, src2);
if (src3)
_mix(dist, src3);
return dist;
}
var clone = function (obj) {
if (typeof obj !== 'object' || obj === null) {
return obj;
}
var rst;
if (isArray(obj)) {
rst = [];
for (var i = 0, l = obj.length; i < l; i++) {
if (typeof obj[i] === 'object' && obj[i] != null) {
rst[i] = clone(obj[i]);
}
else {
rst[i] = obj[i];
}
}
}
else {
rst = {};
for (var k in obj) {
if (typeof obj[k] === 'object' && obj[k] != null) {
rst[k] = clone(obj[k]);
}
else {
rst[k] = obj[k];
}
}
}
return rst;
};
/**
* _.memoize(calColor);
* _.memoize(calColor, (...args) => args[0]);
* @param f
* @param resolver
*/
var memoize = (function (f, resolver) {
if (!isFunction(f)) {
throw new TypeError('Expected a function');
}
var memoized = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
// 使用方法构造 key，如果不存在 resolver，则直接取第一个参数作为 key
var key = resolver ? resolver.apply(this, args) : args[0];
var cache = memoized.cache;
if (cache.has(key)) {
return cache.get(key);
}
var result = f.apply(this, args);
// 缓存起来
cache.set(key, result);
return result;
};
memoized.cache = new Map();
return memoized;
});
var MAX_MIX_LEVEL = 5;
function _deepMix(dist, src, level, maxLevel) {
level = level || 0;
maxLevel = maxLevel || MAX_MIX_LEVEL;
for (var key in src) {
if (src.hasOwnProperty(key)) {
var value = src[key];
if (value !== null && isPlainObject(value)) {
if (!isPlainObject(dist[key])) {
dist[key] = {};
}
if (level < maxLevel) {
_deepMix(dist[key], value, level + 1, maxLevel);
}
else {
dist[key] = src[key];
}
}
else if (isArray(value)) {
dist[key] = [];
dist[key] = dist[key].concat(value);
}
else if (value !== undefined) {
dist[key] = value;
}
}
}
}
// todo 重写
var deepMix = function (rst) {
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
for (var i = 0; i < args.length; i += 1) {
_deepMix(rst, args[i]);
}
return rst;
};
var indexOf = function (arr, obj) {
if (!isArrayLike(arr)) {
return -1;
}
var m = Array.prototype.indexOf;
if (m) {
return m.call(arr, obj);
}
var index = -1;
for (var i = 0; i < arr.length; i++) {
if (arr[i] === obj) {
index = i;
break;
}
}
return index;
};
var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
function isEmpty(value) {
/**
* isEmpty(null) => true
* isEmpty() => true
* isEmpty(true) => true
* isEmpty(1) => true
* isEmpty([1, 2, 3]) => false
* isEmpty('abc') => false
* isEmpty({ a: 1 }) => false
*/
if (isNil(value)) {
return true;
}
if (isArrayLike(value)) {
return !value.length;
}
var type = getType(value);
if (type === 'Map' || type === 'Set') {
return !value.size;
}
if (isPrototype(value)) {
return !Object.keys(value).length;
}
for (var key in value) {
if (hasOwnProperty$1.call(value, key)) {
return false;
}
}
return true;
}
var map = function (arr, func) {
if (!isArrayLike(arr)) {
// @ts-ignore
return arr;
}
var result = [];
for (var index = 0; index < arr.length; index++) {
var value = arr[index];
result.push(func(value, index));
}
return result;
};
var identity = function (v) { return v; };
var mapValues = (function (object, func) {
if (func === void 0) { func = identity; }
var r = {};
if (isObject(object) && !isNil(object)) {
Object.keys(object).forEach(function (key) {
// @ts-ignore
r[key] = func(object[key], key);
});
}
return r;
});
/**
* https://github.com/developit/dlv/blob/master/index.js
* @param obj
* @param key
* @param defaultValue
*/
var get = (function (obj, key, defaultValue) {
var p = 0;
var keyArr = isString(key) ? key.split('.') : key;
while (obj && p < keyArr.length) {
obj = obj[keyArr[p++]];
}
return (obj === undefined || p < keyArr.length) ? defaultValue : obj;
});
var hasOwnProperty$2 = Object.prototype.hasOwnProperty;
var pick = (function (object, keys) {
if (object === null || !isPlainObject(object)) {
return {};
}
var result = {};
each(keys, function (key) {
if (hasOwnProperty$2.call(object, key)) {
result[key] = object[key];
}
});
return result;
});
var omit = (function (obj, keys) {
return reduce(obj, function (r, curr, key) {
if (!keys.includes(key)) {
r[key] = curr;
}
return r;
}, {});
});
function size(o) {
if (isNil(o)) {
return 0;
}
if (isArrayLike(o)) {
return o.length;
}
return Object.keys(o).length;
}
/******************************************************************************
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 __assign = function() {
__assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
/** @deprecated */
function __spreadArrays() {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
}
var ctx;
/**
* 计算文本的宽度
*/
memoize(function (text, font) {
if (font === void 0) { font = {}; }
var fontSize = font.fontSize, fontFamily = font.fontFamily, fontWeight = font.fontWeight, fontStyle = font.fontStyle, fontVariant = font.fontVariant;
if (!ctx) {
ctx = document.createElement('canvas').getContext('2d');
}
ctx.font = [fontStyle, fontVariant, fontWeight, fontSize + "px", fontFamily].join(' ');
return ctx.measureText(isString(text) ? text : '').width;
}, function (text, font) {
if (font === void 0) { font = {}; }
return __spreadArrays([text], values(font)).join('');
});
/**
* k-v 存储
*/
var default_1 = /** @class */ (function () {
function default_1() {
this.map = {};
}
default_1.prototype.has = function (key) {
return this.map[key] !== undefined;
};
default_1.prototype.get = function (key, def) {
var v = this.map[key];
return v === undefined ? def : v;
};
default_1.prototype.set = function (key, value) {
this.map[key] = value;
};
default_1.prototype.clear = function () {
this.map = {};
};
default_1.prototype.delete = function (key) {
delete this.map[key];
};
default_1.prototype.size = function () {
return Object.keys(this.map).length;
};
return default_1;
}());
function cloneElement(element, props) {
if (!element) return element;
return _objectSpread(_objectSpread({}, element), {}, {
props: _objectSpread(_objectSpread({}, element.props), props)
});
}
function map$1(children, fn) {
if (!children) {
return fn(children);
}
if (isArray(children)) {
return children.map(function (child) {
return map$1(child, fn);
});
}
return fn(children);
}
function compareArray(nextElements, lastElements, callback) {
var keyed = {};
var nextLength = nextElements.length;
var lastLength = lastElements.length;
for (var i = 0, len = lastLength; i < len; i++) {
var element = lastElements[i];
if (element && !isNil(element.key)) {
var key = element.key;
keyed[key] = element;
}
}
// 比较元素
for (var _i = 0, _len = Math.max(nextLength, lastLength); _i < _len; _i++) {
var _element = nextElements[_i];
if (!_element) {
compare(_element, lastElements[_i], callback);
continue;
}
var _key = _element.key;
// 有key值定义
if (!isNil(_element.key)) {
var lastElement = keyed[_key];
if (lastElement) delete keyed[_key];
compare(_element, lastElement, callback);
continue;
}
compare(_element, lastElements[_i], callback);
}
// 说明是删除的元素
Object.keys(keyed).forEach(function (key) {
compare(null, keyed[key], callback);
});
}
// 比较2棵树
function compare(nextElement, lastElement, callback) {
// 有一个为空
if (!nextElement || !lastElement) {
callback(nextElement, lastElement);
return;
}
if (isArray(nextElement) || isArray(lastElement)) {
var nextElementArray = isArray(nextElement) ? nextElement : [nextElement];
var lastElementArray = isArray(lastElement) ? lastElement : [lastElement];
compareArray(nextElementArray, lastElementArray, callback);
return;
}
callback(nextElement, lastElement);
}
function toArray(element) {
if (!element) {
return element;
}
if (!isArray(element)) {
return [element];
}
var newArray = [];
for (var i = 0, len = element.length; i < len; i++) {
var item = element[i];
if (isArray(item)) {
// @ts-ignore
newArray = newArray.concat(toArray(item));
} else {
newArray.push(item);
}
}
return newArray;
}
var Children = {
cloneElement: cloneElement,
map: map$1,
toArray: toArray,
compare: compare
};
var classCallCheck = createCommonjsModule(function (module) {
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
module.exports = _classCallCheck, module.exports.__esModule = true, module.exports["default"] = module.exports;
});
var _classCallCheck = /*@__PURE__*/getDefaultExportFromCjs(classCallCheck);
var createClass = createCommonjsModule(function (module) {
function _defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, toPropertyKey(descriptor.key), descriptor);
}
}
function _createClass(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
if (staticProps) _defineProperties(Constructor, staticProps);
Object.defineProperty(Constructor, "prototype", {
writable: false
});
return Constructor;
}
module.exports = _createClass, module.exports.__esModule = true, module.exports["default"] = module.exports;
});
var _createClass = /*@__PURE__*/getDefaultExportFromCjs(createClass);
var Component = /*#__PURE__*/function () {
function Component(props, context, updater) {
_classCallCheck(this, Component);
this.destroyed = false;
this.props = props;
this.state = {};
this.context = context;
this.updater = updater;
}
_createClass(Component, [{
key: "willMount",
value: function willMount() {}
}, {
key: "didMount",
value: function didMount() {}
}, {
key: "willReceiveProps",
value: function willReceiveProps(_props, context) {}
}, {
key: "willUpdate",
value: function willUpdate() {}
}, {
key: "didUpdate",
value: function didUpdate() {}
}, {
key: "render",
value: function render() {
return null;
}
}, {
key: "didUnmount",
value: function didUnmount() {}
}, {
key: "setState",
value: function setState(partialState, callback) {
this.updater.enqueueSetState(this, partialState, callback);
}
}, {
key: "forceUpdate",
value: function forceUpdate(callback) {
this.updater.enqueueForceUpdate(this, {}, callback);
}
}, {
key: "setAnimate",
value: function setAnimate(animate) {
this.animate = animate;
}
}, {
key: "destroy",
value: function destroy() {
this.destroyed = true;
}
}]);
return Component;
}(); // 标识是否是组件
// @ts-ignore
Component.prototype.isF2Component = true;
var assertThisInitialized = createCommonjsModule(function (module) {
function _assertThisInitialized(self) {
if (self === void 0) {
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
}
return self;
}
module.exports = _assertThisInitialized, module.exports.__esModule = true, module.exports["default"] = module.exports;
});
var _assertThisInitialized = /*@__PURE__*/getDefaultExportFromCjs(assertThisInitialized);
var setPrototypeOf = createCommonjsModule(function (module) {
function _setPrototypeOf(o, p) {
module.exports = _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
o.__proto__ = p;
return o;
}, module.exports.__esModule = true, module.exports["default"] = module.exports;
return _setPrototypeOf(o, p);
}
module.exports = _setPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;
});
var inherits = createCommonjsModule(function (module) {
function _inherits(subClass, superClass) {
if (typeof superClass !== "function" && superClass !== null) {
throw new TypeError("Super expression must either be null or a function");
}
subClass.prototype = Object.create(superClass && superClass.prototype, {
constructor: {
value: subClass,
writable: true,
configurable: true
}
});
Object.defineProperty(subClass, "prototype", {
writable: false
});
if (superClass) setPrototypeOf(subClass, superClass);
}
module.exports = _inherits, module.exports.__esModule = true, module.exports["default"] = module.exports;
});
var _inherits = /*@__PURE__*/getDefaultExportFromCjs(inherits);
var getPrototypeOf = createCommonjsModule(function (module) {
function _getPrototypeOf(o) {
module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
return o.__proto__ || Object.getPrototypeOf(o);
}, module.exports.__esModule = true, module.exports["default"] = module.exports;
return _getPrototypeOf(o);
}
module.exports = _getPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;
});
var _getPrototypeOf = /*@__PURE__*/getDefaultExportFromCjs(getPrototypeOf);
var isNativeReflectConstruct = createCommonjsModule(function (module) {
function _isNativeReflectConstruct() {
if (typeof Reflect === "undefined" || !Reflect.construct) return false;
if (Reflect.construct.sham) return false;
if (typeof Proxy === "function") return true;
try {
Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
return true;
} catch (e) {
return false;
}
}
module.exports = _isNativeReflectConstruct, module.exports.__esModule = true, module.exports["default"] = module.exports;
});
var possibleConstructorReturn = createCommonjsModule(function (module) {
var _typeof = _typeof_1["default"];
function _possibleConstructorReturn(self, call) {
if (call && (_typeof(call) === "object" || typeof call === "function")) {
return call;
} else if (call !== void 0) {
throw new TypeError("Derived constructors may only return object or undefined");
}
return assertThisInitialized(self);
}
module.exports = _possibleConstructorReturn, module.exports.__esModule = true, module.exports["default"] = module.exports;
});
var _possibleConstructorReturn = /*@__PURE__*/getDefaultExportFromCjs(possibleConstructorReturn);
var createSuper = createCommonjsModule(function (module) {
function _createSuper(Derived) {
var hasNativeReflectConstruct = isNativeReflectConstruct();
return function _createSuperInternal() {
var Super = getPrototypeOf(Derived),
result;
if (hasNativeReflectConstruct) {
var NewTarget = getPrototypeOf(this).constructor;
result = Reflect.construct(Super, arguments, NewTarget);
} else {
result = Super.apply(this, arguments);
}
return possibleConstructorReturn(this, result);
};
}
module.exports = _createSuper, module.exports.__esModule = true, module.exports["default"] = module.exports;
});
var _createSuper = /*@__PURE__*/getDefaultExportFromCjs(createSuper);
var Timeline = /*#__PURE__*/function (_Component) {
_inherits(Timeline, _Component);
var _super = _createSuper(Timeline);
function Timeline(props) {
var _this;
_classCallCheck(this, Timeline);
_this = _super.call(this, props);
_this.next = function () {
var _assertThisInitialize = _assertThisInitialized(_this),
state = _assertThisInitialize.state,
props = _assertThisInitialize.props;
var index = state.index,
count = state.count,
delay = state.delay;
var loop = props.loop;
var next = loop ? (index + 1) % count : index + 1;
if (next < count) {
setTimeout(function () {
_this.setState({
index: next
});
}, delay || 0);
}
};
var delay = props.delay,
_props$start = props.start,
start = _props$start === void 0 ? 0 : _props$start,
children = props.children;
var count = Children.toArray(children).length;
_this.state = {
delay: delay,
count: count,
index: start
};
return _this;
}
_createClass(Timeline, [{
key: "didMount",
value: function didMount() {
var context = this.context;
var root = context.root;
root.on('animationEnd', this.next);
}
}, {
key: "didUnmount",
value: function didUnmount() {
var context = this.context;
var root = context.root;
root.off('animationEnd', this.next);
}
}, {
key: "render",
value: function render() {
var state = this.state,
props = this.props;
var children = props.children;
var index = state.index;
var childrenArray = Children.toArray(children);
return childrenArray[index];
}
}]);
return Timeline;
}(Component);
var WILDCARD = '*';
/* event-emitter */
var EventEmitter = /** @class */ (function () {
function EventEmitter() {
this._events = {};
}
/**
* 监听一个事件
* @param evt
* @param callback
* @param once
*/
EventEmitter.prototype.on = function (evt, callback, once) {
if (!this._events[evt]) {
this._events[evt] = [];
}
this._events[evt].push({
callback: callback,
once: !!once,
});
return this;
};
/**
* 监听一个事件一次
* @param evt
* @param callback
*/
EventEmitter.prototype.once = function (evt, callback) {
return this.on(evt, callback, true);
};
/**
* 触发一个事件
* @param evt
* @param args
*/
EventEmitter.prototype.emit = function (evt) {
var _this = this;
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
var events = this._events[evt] || [];
var wildcardEvents = this._events[WILDCARD] || [];
// 实际的处理 emit 方法
var doEmit = function (es) {
var length = es.length;
for (var i = 0; i < length; i++) {
if (!es[i]) {
continue;
}
var _a = es[i], callback = _a.callback, once = _a.once;
if (once) {
es.splice(i, 1);
if (es.length === 0) {
delete _this._events[evt];
}
length--;
i--;
}
callback.apply(_this, args);
}
};
doEmit(events);
doEmit(wildcardEvents);
};
/**
* 取消监听一个事件，或者一个channel
* @param evt
* @param callback
*/
EventEmitter.prototype.off = function (evt, callback) {
if (!evt) {
// evt 为空全部清除
this._events = {};
}
else {
if (!callback) {
// evt 存在，callback 为空，清除事件所有方法
delete this._events[evt];
}
else {
// evt 存在，callback 存在，清除匹配的
var events = this._events[evt] || [];
var length_1 = events.length;
for (var i = 0; i < length_1; i++) {
if (events[i].callback === callback) {
events.splice(i, 1);
length_1--;
i--;
}
}
if (events.length === 0) {
delete this._events[evt];
}
}
}
return this;
};
/* 当前所有的事件 */
EventEmitter.prototype.getEvents = function () {
return this._events;
};
return EventEmitter;
}());
var Matrix = {
generateDefault: function generateDefault() {
return [1, 0, 0, 1, 0, 0];
},
isChanged: function isChanged(m) {
return m[0] !== 1 || m[1] !== 0 || m[2] !== 0 || m[3] !== 1 || m[4] !== 0 || m[5] !== 0;
},
multiply: function multiply(m1, m2) {
var m11 = m1[0] * m2[0] + m1[2] * m2[1];
var m12 = m1[1] * m2[0] + m1[3] * m2[1];
var m21 = m1[0] * m2[2] + m1[2] * m2[3];
var m22 = m1[1] * m2[2] + m1[3] * m2[3];
var dx = m1[0] * m2[4] + m1[2] * m2[5] + m1[4];
var dy = m1[1] * m2[4] + m1[3] * m2[5] + m1[5];
return [m11, m12, m21, m22, dx, dy];
},
scale: function scale(out, m, v) {
out[0] = m[0] * v[0];
out[1] = m[1] * v[0];
out[2] = m[2] * v[1];
out[3] = m[3] * v[1];
out[4] = m[4];
out[5] = m[5];
return out;
},
rotate: function rotate(out, m, radian) {
var c = Math.cos(radian);
var s = Math.sin(radian);
var m11 = m[0] * c + m[2] * s;
var m12 = m[1] * c + m[3] * s;
var m21 = m[0] * -s + m[2] * c;
var m22 = m[1] * -s + m[3] * c;
out[0] = m11;
out[1] = m12;
out[2] = m21;
out[3] = m22;
out[4] = m[4];
out[5] = m[5];
return out;
},
translate: function translate(out, m, v) {
out[0] = m[0];
out[1] = m[1];
out[2] = m[2];
out[3] = m[3];
out[4] = m[4] + m[0] * v[0] + m[2] * v[1];
out[5] = m[5] + m[1] * v[0] + m[3] * v[1];
return out;
},
transform: function transform(m, actions) {
var out = [].concat(m);
for (var i = 0, len = actions.length; i < len; i++) {
var action = actions[i];
switch (action[0]) {
case 't':
Matrix.translate(out, out, [action[1], action[2]]);
break;
case 's':
Matrix.scale(out, out, [action[1], action[2]]);
break;
case 'r':
Matrix.rotate(out, out, action[1]);
break;
}
}
return out;
}
};
/**
* 2 Dimensional Vector
* @module vector2
*/
var Vector2 = {
/**
* Creates a new, empty vector2
*
* @return {vector2} a new 2D vector
*/
create: function create() {
return [0, 0];
},
/**
* Calculates the length of a vector2
*
* @param {vector2} v vector to calculate length of
* @return {Number} length of v
*/
length: function length(v) {
var x = v[0];
var y = v[1];
return Math.sqrt(x * x + y * y);
},
/**
* Normalize a vector2
*
* @param {vector2} out the receiving vector
* @param {vector2} v vector to normalize
* @return {vector2} out
*/
normalize: function normalize(out, v) {
var len = this.length(v);
if (len === 0) {
out[0] = 0;
out[1] = 0;
} else {
out[0] = v[0] / len;
out[1] = v[1] / len;
}
return out;
},
/**
* Adds two vector2's
*
* @param {vector2} out the receiving vector
* @param {vector2} v1 the first operand
* @param {vector2} v2 the second operand
* @return {vector2} out
*/
add: function add(out, v1, v2) {
out[0] = v1[0] + v2[0];
out[1] = v1[1] + v2[1];
return out;
},
/**
* Subtracts vector v2 from vector v1
*
* @param {vector2} out the receiving vector
* @param {vector2} v1 the first operand
* @param {vector2} v2 the second operand
* @return {vector2} out
*/
sub: function sub(out, v1, v2) {
out[0] = v1[0] - v2[0];
out[1] = v1[1] - v2[1];
return out;
},
/**
* Scales a vector2 by a scalar number
*
* @param {vector2} out the receiving vector
* @param {vector2} v the vector to scale
* @param {Number} s amount to scale the vector by
* @return {vector2} out
*/
scale: function scale(out, v, s) {
out[0] = v[0] * s;
out[1] = v[1] * s;
return out;
},
/**
* Calculates the dot product of two vector2's
*
* @param {vector2} v1 the first operand
* @param {vector2} v2 the second operand
* @return {Number} dot product of v1 and v2
*/
dot: function dot(v1, v2) {
return v1[0] * v2[0] + v1[1] * v2[1];
},
/**
* Calculates the direction of two vector2's
*
* @param {vector2} v1 the first operand
* @param {vector2} v2 the second operand
* @return {Boolean} the direction of v1 and v2
*/
direction: function direction(v1, v2) {
return v1[0] * v2[1] - v2[0] * v1[1];
},
/**
* Calculates the angle of two vector2's
*
* @param {vector2} v1 the first operand
* @param {vector2} v2 the second operand
* @return {Number} angle of v1 and v2
*/
angle: function angle(v1, v2) {
var theta = this.dot(v1, v2) / (this.length(v1) * this.length(v2));
return Math.acos(theta);
},
/**
* Calculates the angle of two vector2's with direction
*
* @param {vector2} v1 the first operand
* @param {vector2} v2 the second operand
* @param {Boolean} direction the direction of two vector2's
* @return {Number} angle of v1 and v2
*/
angleTo: function angleTo(v1, v2, direction) {
var angle = this.angle(v1, v2);
var angleLargeThanPI = this.direction(v1, v2) >= 0;
if (direction) {
if (angleLargeThanPI) {
return Math.PI * 2 - angle;
}
return angle;
}
if (angleLargeThanPI) {
return angle;
}
return Math.PI * 2 - angle;
},
/**
* whether a vector2 is zero vector
*
* @param {vector2} v vector to calculate
* @return {Boolean} is or not a zero vector
*/
zero: function zero(v) {
return v[0] === 0 && v[1] === 0;
},
/**
* Calculates the euclidian distance between two vector2's
*
* @param {vector2} v1 the first operand
* @param {vector2} v2 the second operand
* @return {Number} distance between a and b
*/
distance: function distance(v1, v2) {
var x = v2[0] - v1[0];
var y = v2[1] - v1[1];
return Math.sqrt(x * x + y * y);
},
/**
* Creates a new vector2 initialized with values from an existing vector
*
* @param {vector2} v vector to clone
* @return {Array} a new 2D vector
*/
clone: function clone(v) {
return [v[0], v[1]];
},
/**
* Return the minimum of two vector2's
*
* @param {vector2} out the receiving vector
* @param {vector2} v1 the first operand
* @param {vector2} v2 the second operand
* @return {vector2} out
*/
min: function min(out, v1, v2) {
out[0] = Math.min(v1[0], v2[0]);
out[1] = Math.min(v1[1], v2[1]);
return out;
},
/**
* Return the maximum of two vector2's
*
* @param {vector2} out the receiving vector
* @param {vector2} v1 the first operand
* @param {vector2} v2 the second operand
* @return {vector2} out
*/
max: function max(out, v1, v2) {
out[0] = Math.max(v1[0], v2[0]);
out[1] = Math.max(v1[1], v2[1]);
return out;
},
/**
* Transforms the vector2 with a mat2d
*
* @param {vector2} out the receiving vector
* @param {vector2} v the vector to transform
* @param {mat2d} m matrix to transform with
* @return {vector2} out
*/
transformMat2d: function transformMat2d(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;
}
};
/**
* @fileOverview convert the line to curve
* @author dxq613@gmail.com
*/
function getPoint(v) {
return [v.x, v.y];
}
function smoothBezier(points, smooth, isLoop, constraint) {
var cps = [];
var prevPoint;
var nextPoint;
var hasConstraint = !!constraint;
var min;
var max;
var point;
var len;
var l;
var i;
if (hasConstraint) {
min = [Infinity, Infinity];
max = [-Infinity, -Infinity];
for (i = 0, l = points.length; i < l; i++) {
point = getPoint(points[i]);
Vector2.min(min, min, point);
Vector2.max(max, max, point);
}
Vector2.min(min, min, constraint[0]);
Vector2.max(max, max, constraint[1]);
}
for (i = 0, len = points.length; i < len; i++) {
point = getPoint(points[i]);
if (isLoop) {
prevPoint = getPoint(points[i ? i - 1 : len - 1]);
nextPoint = getPoint(points[(i + 1) % len]);
} else {
if (i === 0 || i === len - 1) {
cps.push([point[0], point[1]]);
continue;
} else {
prevPoint = getPoint(points[i - 1]);
nextPoint = getPoint(points[i + 1]);
}
}
var v = Vector2.sub([], nextPoint, prevPoint);
Vector2.scale(v, v, smooth);
var d0 = Vector2.distance(point, prevPoint);
var d1 = Vector2.distance(point, nextPoint);
var sum = d0 + d1;
if (sum !== 0) {
d0 /= sum;
d1 /= sum;
}
var v1 = Vector2.scale([], v, -d0);
var v2 = Vector2.scale([], v, d1);
var cp0 = Vector2.add([], point, v1);
var cp1 = Vector2.add([], point, v2);
if (hasConstraint) {
Vector2.max(cp0, cp0, min);
Vector2.min(cp0, cp0, max);
Vector2.max(cp1, cp1, min);
Vector2.min(cp1, cp1, max);
}
cps.push([cp0[0], cp0[1]]);
cps.push([cp1[0], cp1[1]]);
}
if (isLoop) {
cps.push(cps.shift());
}
return cps;
}
function catmullRom2bezier(pointList, z, constraint) {
var isLoop = !!z;
var controlPointList = smoothBezier(pointList, 0.4, isLoop, constraint);
var len = pointList.length;
var d1 = [];
var cp1;
var cp2;
var p;
for (var i = 0; i < len - 1; i++) {
cp1 = controlPointList[i * 2];
cp2 = controlPointList[i * 2 + 1];
p = pointList[i + 1];
d1.push(['C', cp1[0], cp1[1], cp2[0], cp2[1], p.x, p.y]);
}
if (isLoop) {
cp1 = controlPointList[len];
cp2 = controlPointList[len + 1];
p = pointList[0];
d1.push(['C', cp1[0], cp1[1],