@opentiny/vue-renderless 3.1.0-alpha.0 → 3.5.0

package/chart-core/deps/constants.js

@@ -0,0 +1,65 @@
+var sf = function sf() {
+  return {
+    show: false
+  };
+};
+var DEFAULT_THEME = {
+  categoryAxis: {
+    axisLine: sf(),
+    axisTick: sf(),
+    splitLine: sf()
+  },
+  valueAxis: {
+    axisLine: sf()
+  },
+  line: {
+    smooth: true
+  },
+  grid: {
+    containLabel: true,
+    left: 10,
+    right: 10
+  }
+};
+var DEFAULT_COLORS = ['#19d4ae', '#5ab1ef', '#fa6e86', '#ffb980', '#0067a6', '#c4b4e4'];
+DEFAULT_COLORS = DEFAULT_COLORS.concat(['#d87a80', '#9cbbff', '#d9d0c7', '#87a997', '#d49ea2', '#5b4947', '#7ba3a8']);
+var HEAT_MAP_COLOR = ['#5990FD', '#2DA769', '#EEBA18', '#F43146'];
+var HEAT_BMAP_COLOR = ['blue', 'blue', 'green', 'yellow', 'red'];
+var SAAS_DEFAULT_COLORS_10 = ['#6d8ff0', '#00a874', '#bd72f0', '#54bcce', '#fdc000', '#9185f0', '#82dbb1', '#f46087', '#2070f3', '#ee8ddb'];
+var SAAS_DEFAULT_COLORS_18 = ['#2070f3', '#50c291', '#bd72f0', '#54bcce', '#fdc000', '#6d8ff0', '#71c14c', '#87d5e5', '#9185f0', '#82dbb1', '#ada6ed', '#97da7e', '#f46087', '#ee8ddb', '#f09596', '#f36900', '#daa61b', '#efb9e3'];
+var DEFAULT_CONFIG = {
+  tooltip: {
+    backgroundColor: '#fff',
+    borderColor: '#fff',
+    padding: [8, 16],
+    textStyle: {
+      color: '#191919',
+      fontSize: '14'
+    },
+    extraCssText: 'box-shadow:0 8px 20px rgba(0, 0, 0, 0.16);'
+  },
+  legend: {
+    icon: 'circle',
+    bottom: 0,
+    itemGap: 24,
+    itemWidth: 10,
+    itemHeight: 10,
+    itemStyle: {
+      borderColor: 'transparent'
+    }
+  }
+};
+var itemPoint = function itemPoint(color) {
+  return ['<span style="', "background-color:".concat(color, ";"), 'display: inline-block;', 'width: 6px;', 'height: 6px;', 'border-radius: 50%;', 'margin-right:8px;', 'vertical-align:middle;', '"></span>'].join('');
+};
+var itemLabel = function itemLabel(seriesName, onlyLabel) {
+  return ['<span style="', 'display:inline-block;', 'font-size:12px;', 'color:#4E4E4E;', "".concat(onlyLabel ? '' : 'margin-right:25px;'), "\">".concat(seriesName, "</span>")].join('');
+};
+var itemContent = function itemContent(content) {
+  return ['<span style="', 'float:right;', 'font-size:14px;', 'color:#191919;', "\">".concat(content, "</span>")].join('');
+};
+var STATIC_PROPS = ['initOptions', 'loading', 'dataEmpty', 'judgeWidth', 'widthChangeDelay'];
+var ECHARTS_SETTINGS = ['grid', 'dataZoom', 'visualMap', 'toolbox', 'title', 'legend', 'xAxis'];
+ECHARTS_SETTINGS = ECHARTS_SETTINGS.concat(['yAxis', 'radar', 'tooltip', 'axisPointer', 'brush', 'geo']);
+ECHARTS_SETTINGS = ECHARTS_SETTINGS.concat(['timeline', 'graphic', 'series', 'backgroundColor', 'textStyle']);
+export { DEFAULT_THEME, DEFAULT_COLORS, HEAT_MAP_COLOR, HEAT_BMAP_COLOR, itemPoint, itemLabel, itemContent, STATIC_PROPS, ECHARTS_SETTINGS, DEFAULT_CONFIG, SAAS_DEFAULT_COLORS_10, SAAS_DEFAULT_COLORS_18 };

package/chart-core/deps/numerify.js

@@ -0,0 +1,286 @@
+var ABBR = {
+  th: 3,
+  mi: 6,
+  bi: 9,
+  tr: 12
+};
+var abbrLabel = {
+  th: 'k',
+  mi: 'm',
+  bi: 'b',
+  tr: 't'
+};
+var DEFAULT_OPTIONS = {
+  zeroFormat: null,
+  nullFormat: null,
+  defaultFormat: '0,0',
+  scalePercentBy100: true,
+  abbrLabel: abbrLabel
+};
+var TRILLION = 1e12,
+  BILLION = 1e9,
+  MILLION = 1e6,
+  THOUSAND = 1e3;
+var numIsNaN = function numIsNaN(value) {
+  return typeof value === 'number' && isNaN(value);
+};
+var options = {};
+var formats = {};
+function getBoundedPrecision(value, maxDecimals, optionals) {
+  var splitValue = value.toString().split('e-');
+  var exponent = splitValue.length === 2 ? Number(splitValue[1]) : 0;
+  splitValue = splitValue[0].split('.');
+  exponent = splitValue.length === 2 ? splitValue[1].length + exponent : exponent;
+  var minDecimals = maxDecimals - (optionals || 0);
+  return Math.min(Math.max(exponent, minDecimals), maxDecimals);
+}
+function toFixed(value, maxDecimals, roundingFunction, optionals) {
+  var boundedPrecision = getBoundedPrecision(value, maxDecimals, optionals);
+  var power = Math.pow(10, boundedPrecision);
+  var output = (roundingFunction(value * "1e+".concat(boundedPrecision)) / power).toFixed(boundedPrecision);
+  if (optionals > maxDecimals - boundedPrecision) {
+    var optionalsRegExp = new RegExp('\\.?0{1,' + (optionals - (maxDecimals - boundedPrecision)) + '}$');
+    output = output.replace(optionalsRegExp, '');
+  }
+  return output;
+}
+function judgForFunc(num, abs, abbrForce) {
+  var flag;
+  if (num === 0) {
+    flag = abs >= TRILLION && !abbrForce || abbrForce === 't';
+  } else if (num === 1) {
+    flag = abs < TRILLION && abs >= BILLION && !abbrForce || abbrForce === 'b';
+  } else if (num === 2) {
+    flag = abs < BILLION && abs >= MILLION && !abbrForce || abbrForce === 'm';
+  } else if (num === 3) {
+    flag = abs < MILLION && abs >= THOUSAND && !abbrForce || abbrForce === 'k';
+  }
+  return flag;
+}
+var negativeSigned = function negativeSigned(_ref) {
+  var format = _ref.format,
+    value = _ref.value;
+  return ~format.indexOf('+') ? format.indexOf('+') : value < 0 ? format.indexOf('-') : -1;
+};
+var updateAbbrV = function updateAbbrV(params) {
+  var abbr = params.abbr,
+    abbrForce = params.abbrForce,
+    format = params.format,
+    value = params.value,
+    abs = params.abs;
+  abbrForce = format.match(/a(k|m|b|t)?/);
+  abbrForce = abbrForce ? abbrForce[1] : false;
+  if (~format.indexOf(' a')) {
+    abbr = ' ';
+  }
+  format = format.replace(new RegExp(abbr + 'a[kmbt]?'), '');
+  if (judgForFunc(0, abs, abbrForce)) {
+    abbr += options.abbrLabel.tr;
+    value = value / TRILLION;
+  } else if (judgForFunc(1, abs, abbrForce)) {
+    abbr += options.abbrLabel.bi;
+    value = value / BILLION;
+  } else if (judgForFunc(2, abs, abbrForce)) {
+    abbr += options.abbrLabel.mi;
+    value = value / MILLION;
+  } else if (judgForFunc(3, abs, abbrForce)) {
+    abbr += options.abbrLabel.th;
+    value = value / THOUSAND;
+  }
+  Object.assign(params, {
+    abbr: abbr,
+    abbrForce: abbrForce,
+    format: format,
+    value: value,
+    abs: abs
+  });
+};
+var handlePrecision = function handlePrecision(params) {
+  var roundingFunction = params.roundingFunction,
+    value = params.value,
+    format = params.format;
+  var number = value.toString().split('.')[0];
+  var precision = format.split('.')[1];
+  if (precision) {
+    if (~precision.indexOf('[')) {
+      precision = precision.replace(']', '');
+      precision = precision.split('[');
+      params.decimal = toFixed(value, precision[0].length + precision[1].length, roundingFunction, precision[1].length);
+    } else {
+      params.decimal = toFixed(value, precision.length, roundingFunction);
+    }
+    number = params.decimal.split('.')[0];
+    params.decimal = ~params.decimal.indexOf('.') ? '.' + params.decimal.split('.')[1] : '';
+    if (params.optDec && Number(params.decimal.slice(1)) === 0) {
+      params.decimal = '';
+    }
+  } else {
+    number = toFixed(value, 0, roundingFunction);
+  }
+  return number;
+};
+function formatNumber(params) {
+  var number = handlePrecision(params);
+  var thousands = params.format.indexOf(',');
+  var leadingCount = (params.format.split('.')[0].split(',')[0].match(/0/g) || []).length;
+  if (params.abbr && !params.abbrForce && Number(number) >= 1000 && params.abbr !== ABBR.trillion) {
+    number = String(Number(number) / 1000);
+    params.abbr = ABBR.million;
+  }
+  if (~number.indexOf('-')) {
+    number = number.slice(1);
+    params.neg = true;
+  }
+  if (number.length < leadingCount) {
+    for (var i = leadingCount - number.length; i > 0; i--) {
+      number = '0' + number;
+    }
+  }
+  if (thousands > -1) {
+    number = number.toString().replace(/(\d)(?=(\d{3})+(?!\d))/g, '$1,');
+  }
+  if (!params.format.indexOf('.')) {
+    number = '';
+  }
+  return number;
+}
+function getOutStr(_ref2, number) {
+  var decimal = _ref2.decimal,
+    negFlag = _ref2.negFlag,
+    neg = _ref2.neg,
+    signed = _ref2.signed,
+    abbr = _ref2.abbr;
+  var outStr = number + decimal + (abbr || '');
+  if (negFlag) {
+    outStr = negFlag && neg ? "(".concat(outStr, ")") : outStr;
+  } else {
+    if (signed >= 0) {
+      var symbol = neg ? '-' : '+';
+      outStr = signed === 0 ? symbol + outStr : outStr + symbol;
+    } else if (neg) {
+      outStr = '-' + outStr;
+    }
+  }
+  return outStr;
+}
+function numberToFormat(options, value, format, roundingFunction) {
+  var params = {
+    abs: Math.abs(value),
+    negFlag: false,
+    optDec: false,
+    abbr: '',
+    decimal: '',
+    neg: false,
+    abbrForce: void 0,
+    signed: void 0,
+    format: format || '',
+    value: value || 0,
+    roundingFunction: roundingFunction
+  };
+  if (~format.indexOf('(')) {
+    params.negFlag = true;
+    params.format = format.replace(/[(|)]/g, '');
+  } else if (~params.format.indexOf('+') || ~params.format.indexOf('-')) {
+    params.signed = negativeSigned(params);
+    params.format = format.replace(/[+|-]/g, '');
+  }
+  if (~params.format.indexOf('a')) {
+    updateAbbrV(params);
+  }
+  if (~params.format.indexOf('[.]')) {
+    params.optDec = true;
+    params.format = format.replace('[.]', '.');
+  }
+  var number = formatNumber(params);
+  return getOutStr(params, number);
+}
+function extend(target, sub) {
+  Object.keys(sub).forEach(function (key) {
+    target[key] = sub[key];
+  });
+}
+var numerifyPercent = {
+  regexp: /%/,
+  format: function format(value, formatType, roundingFunction, numerify) {
+    var space = ~formatType.indexOf(' %') ? ' ' : '';
+    var outStr = void 0;
+    if (numerify.options.scalePercentBy100) {
+      value = value * 100;
+    }
+    formatType = formatType.replace(/\s?%/, '');
+    outStr = numerify._numberToFormat(value, formatType, roundingFunction);
+    if (~outStr.indexOf(')')) {
+      outStr = outStr.split('');
+      outStr.splice(-1, 0, space + '%');
+      outStr = outStr.join('');
+    } else {
+      outStr = outStr + space + '%';
+    }
+    return outStr;
+  }
+};
+extend(options, DEFAULT_OPTIONS);
+var numerify;
+function format(value, formatType, roundingFunc) {
+  var zeroFormat = options.zeroFormat,
+    nullFormat = options.nullFormat,
+    defaultFormat = options.defaultFormat;
+  formatType = formatType || defaultFormat;
+  roundingFunc = roundingFunc || Math.round;
+  var _ref3 = {},
+    output = _ref3.output,
+    fmtFunc = _ref3.fmtFunc;
+  if (value === 0 && zeroFormat !== null) {
+    output = zeroFormat;
+  } else if (value === null && nullFormat !== null) {
+    output = nullFormat;
+  } else {
+    for (var key in formats) {
+      if (formats[key] && formatType.match(formats[key].regexp)) {
+        fmtFunc = formats[key].format;
+        break;
+      }
+    }
+    fmtFunc = fmtFunc || numberToFormat.bind(null, options);
+    output = fmtFunc(value, formatType, roundingFunc, numerify);
+  }
+  return output;
+}
+numerify = function numerify(input, formatType, roundingFunc) {
+  var zeroFormat = options.zeroFormat,
+    nullFormat = options.nullFormat;
+  var value = Number(input) || null;
+  if (typeof input === 'undefined' || input === 0) {
+    value = 0;
+  } else if (numIsNaN(input) || input === null) {
+    value = null;
+  } else if (typeof input === 'string') {
+    value = Number(input);
+    if (input === zeroFormat && zeroFormat) {
+      value = 0;
+    } else if (input === nullFormat && nullFormat || !input.replace(/[^0-9]+/g, '').length) {
+      value = null;
+    }
+  }
+  return format(value, formatType, roundingFunc);
+};
+var _register = function _register(name, format) {
+  formats[name] = format;
+};
+var _unregister = function _unregister(name) {
+  formats[name] = null;
+};
+var _setOptions = function _setOptions(opts) {
+  extend(options, opts);
+};
+var _reset = function _reset() {
+  extend(options, DEFAULT_OPTIONS);
+};
+numerify.options = options;
+numerify._numberToFormat = numberToFormat.bind(null, options);
+numerify.register = _register;
+numerify.unregister = _unregister;
+numerify.setOptions = _setOptions;
+numerify.reset = _reset;
+numerify.register('percentage', numerifyPercent);
+export default numerify;

package/chart-core/deps/utils.js

@@ -0,0 +1,205 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _typeof from "@babel/runtime/helpers/typeof";
+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 _objectSpread(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; }
+import { extend, copyArray } from '@opentiny/vue-renderless/common/object';
+import { isObject, typeOf as getType, isNull } from '@opentiny/vue-renderless/common/type';
+import _debounce from '@opentiny/vue-renderless/common/deps/debounce';
+import _numerify from './numerify';
+import { escapeHtml } from '@opentiny/vue-renderless/common/string';
+import { xss } from '@opentiny/vue-renderless/common';
+export { setObj as set, getObj as get, isEqual } from '@opentiny/vue-renderless/common/object';
+export { typeOf as getType, isObject } from '@opentiny/vue-renderless/common/type';
+export var debounce = function debounce(callback, delay) {
+  return _debounce(delay, false, callback);
+};
+export var camelToKebab = function camelToKebab(str) {
+  return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+};
+export var cloneDeep = function cloneDeep(data) {
+  if (isObject(data)) {
+    return extend(true, data);
+  } else if (Array.isArray(data)) {
+    return copyArray(data);
+  } else {
+    return data;
+  }
+};
+export var getFormated = function getFormated(value, type, digit) {
+  var defaultVal = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '-';
+  if (isNaN(value)) {
+    return defaultVal;
+  }
+  if (!type) {
+    return value;
+  }
+  if (getType(type) === 'function') {
+    return type(value, _numerify);
+  }
+  digit = !isNaN(digit) ? ++digit : 0;
+  var digitStr = ".[".concat(new Array(digit).join(0), "]");
+  var formatter = type;
+  if (type === 'KMB') {
+    formatter = digit ? "0,0".concat(digitStr, "a") : '0,0a';
+  } else if (type === 'normal') {
+    formatter = digit ? "0,0".concat(digitStr) : '0,0';
+  } else if (type === 'percent') {
+    formatter = digit ? "0,0".concat(digitStr, "%") : '0,0.[00]%';
+  }
+  return _numerify(value, formatter);
+};
+export var getStackMap = function getStackMap(stack) {
+  var result = {};
+  Object.keys(stack).forEach(function (item) {
+    stack[item].forEach(function (name) {
+      result[name] = item;
+    });
+  });
+  return result;
+};
+export var $get = function $get(url) {
+  return new Promise(function (resolve, reject) {
+    var http = new XMLHttpRequest();
+    url = xss.filterUrl(url);
+    http.open('GET', url);
+    http.send(null);
+    http.onload = function () {
+      resolve(JSON.parse(http.responseText));
+    };
+    http.onerror = function () {
+      reject(JSON.parse(http.responseText));
+    };
+  });
+};
+var mapPromise = {};
+export var getMapJSON = function getMapJSON(_ref) {
+  var position = _ref.position,
+    positionJsonLink = _ref.positionJsonLink,
+    beforeRegisterMapOnce = _ref.beforeRegisterMapOnce,
+    _ref$mapURLProfix = _ref.mapURLProfix,
+    mapURLProfix = _ref$mapURLProfix === void 0 ? '' : _ref$mapURLProfix;
+  var link = positionJsonLink || "".concat(mapURLProfix).concat(position, ".json");
+  if (!mapPromise[link]) {
+    mapPromise[link] = $get(link).then(function (res) {
+      if (beforeRegisterMapOnce) {
+        res = beforeRegisterMapOnce(res);
+      }
+      return res;
+    });
+  }
+  return mapPromise[link];
+};
+var _ref2 = {},
+  _ref2$amapPromise = _ref2.amapPromise,
+  amapPromise = _ref2$amapPromise === void 0 ? null : _ref2$amapPromise,
+  _ref2$bmapPromise = _ref2.bmapPromise,
+  bmapPromise = _ref2$bmapPromise === void 0 ? null : _ref2$bmapPromise;
+export var getAmap = function getAmap(_ref3) {
+  var key = _ref3.key,
+    version = _ref3.version,
+    url = _ref3.url;
+  if (!amapPromise) {
+    amapPromise = new Promise(function (resolve) {
+      var cbName = 'amap' + Date.now();
+      var script = document.createElement('script');
+      var ver = version || '1.4.3';
+      window[cbName] = resolve;
+      script.src = ["".concat(url, "?v=").concat(ver), "key=".concat(key), "callback=".concat(cbName)].join('&');
+      document.body.appendChild(script);
+    });
+  }
+  return amapPromise;
+};
+export var getBmap = function getBmap(_ref4) {
+  var key = _ref4.key,
+    version = _ref4.version,
+    url = _ref4.url;
+  if (!bmapPromise) {
+    bmapPromise = new Promise(function (resolve) {
+      var cbName = 'bmap' + Date.now();
+      var script = document.createElement('script');
+      var ver = version || '2.0';
+      window[cbName] = resolve;
+      script.src = ["".concat(url, "?v=").concat(ver), "ak=".concat(key), "callback=".concat(cbName)].join('&');
+      document.body.appendChild(script);
+    });
+  }
+  return bmapPromise;
+};
+export var setArrayValue = function setArrayValue(arr, index, value) {
+  var store = arr[index];
+  if (typeof store === 'undefined') {
+    arr[index] = [value];
+    return;
+  }
+  store.push(value);
+};
+export var numerify = _numerify;
+export var merge = function merge(source, other) {
+  if (_typeof(source) !== 'object' || _typeof(other) !== 'object') {
+    return other === undefined ? source : other;
+  }
+  return Object.keys(_objectSpread(_objectSpread({}, source), other)).reduce(function (acc, key) {
+    acc[key] = merge(source[key], other[key]);
+    return acc;
+  }, Array.isArray(source) ? [] : {});
+};
+export var htmlHandler = function htmlHandler(data) {
+  if (!data || !Array.isArray(data)) {
+    return data;
+  }
+  return cloneDeep(data).map(function (item) {
+    if (typeof item === 'string' && /<[a-z]+/i.test(item)) {
+      return escapeHtml(item);
+    } else if (_typeof(item) === 'object') {
+      for (var key in item) {
+        if (typeof item[key] === 'string' && /<[a-z]+/i.test(item[key])) {
+          item[key] = escapeHtml(item[key]);
+        }
+      }
+      return item;
+    } else {
+      return item;
+    }
+  });
+};
+export var getLegend = function getLegend(args, legendItemStyle) {
+  var metrics = args.metrics,
+    legendName = args.legendName,
+    labelMap = args.labelMap;
+  if (!labelMap && !legendName) {
+    return {
+      data: metrics
+    };
+  }
+  var data = labelMap ? metrics.map(function (item) {
+    return isNull(labelMap[item]) ? item : labelMap[item];
+  }) : metrics;
+  return _objectSpread(_objectSpread({}, legendItemStyle), {}, {
+    data: data,
+    formatter: function formatter(name) {
+      return isNull(legendName[name]) ? name : legendName[name];
+    }
+  });
+};
+export var hexToRgb = function hexToRgb(hex) {
+  var reg = /^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})/;
+  if (!reg.test(hex)) {
+    return;
+  }
+  hex = hex.replace(/#/g, '').toLowerCase();
+  var len = hex.length;
+  if (len === 3) {
+    var t = '';
+    for (var i = 0; i < len; i++) {
+      t += hex.slice(i, i + 1).concat(hex.slice(i, i + 1));
+    }
+    hex = t;
+  }
+  var rgbs = [];
+  for (var _i = 0; _i < 6; _i += 2) {
+    var s = hex.slice(_i, _i + 2);
+    rgbs.push(parseInt(s, 16));
+  }
+  return rgbs.join(',');
+};