@opentiny/vue-renderless 3.6.0 → 3.6.1-alpha.2

package/chart-core/modules/animation.js

@@ -1,10 +1,12 @@
-export default (function (_ref) {
-  var options = _ref.options,
-    animation = _ref.animation;
+import "../../chunk-PKUHTIDK.js";
+var animation_default = ({ options, animation }) => {
   if (!animation) {
     return;
   }
-  Object.keys(animation).forEach(function (key) {
+  Object.keys(animation).forEach((key) => {
     options[key] = animation[key];
   });
-});
+};
+export {
+  animation_default as default
+};

package/chart-core/modules/extend.js

@@ -1,36 +1,35 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-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 { set, isObject, merge } from '../deps/utils';
-var isArr = Array.isArray;
-export default (function (_ref) {
-  var options = _ref.options,
-    extend = _ref.extend;
+import {
+  __spreadValues
+} from "../../chunk-PKUHTIDK.js";
+import { set, isObject, merge } from "../deps/utils";
+const isArr = Array.isArray;
+var extend_default = ({ options, extend }) => {
   if (!extend) {
     return;
   }
-  Object.keys(extend).forEach(function (key) {
-    var value = extend[key];
-    if (~key.indexOf('.')) {
+  Object.keys(extend).forEach((key) => {
+    const value = extend[key];
+    if (~key.indexOf(".")) {
       set(options, key, value);
-    } else if (typeof value === 'function') {
+    } else if (typeof value === "function") {
       options[key] = value(options[key]);
     } else if (isArr(options[key]) && isArr(value)) {
-      var attrList = ['series', 'yAxis', 'xAxis', 'color', 'dataZoom', 'legend', 'toolbox', 'grid', 'graphic', 'timeline', 'visualMap', 'brush'];
+      const attrList = ["series", "yAxis", "xAxis", "color", "dataZoom", "legend", "toolbox", "grid", "graphic", "timeline", "visualMap", "brush"];
       if (~attrList.indexOf(key)) {
         options[key] = merge(options[key], value);
       }
     } else {
       if (isArr(options[key]) && isObject(options[key][0])) {
-        options[key].forEach(function (option, i) {
-          return options[key][i] = _objectSpread(_objectSpread({}, option), value);
-        });
+        options[key].forEach((option, i) => options[key][i] = __spreadValues(__spreadValues({}, option), value));
       } else if (isObject(options[key])) {
-        var optionBase = options[key];
-        options[key] = _objectSpread(_objectSpread({}, optionBase), value);
+        let optionBase = options[key];
+        options[key] = __spreadValues(__spreadValues({}, optionBase), value);
       } else {
         options[key] = value;
       }
     }
   });
-});
+};
+export {
+  extend_default as default
+};

package/chart-core/modules/mark.js

@@ -1,7 +1,11 @@
-export default (function (seriesItem, marks) {
-  Object.keys(marks).forEach(function (key) {
+import "../../chunk-PKUHTIDK.js";
+var mark_default = (seriesItem, marks) => {
+  Object.keys(marks).forEach((key) => {
     if (marks[key]) {
       seriesItem[key] = marks[key];
     }
   });
-});
+};
+export {
+  mark_default as default
+};

package/chart-core/vue.js

@@ -1,128 +1,89 @@
-import { computedCanvasStyle, computedChartColor, dataHandler, nextTickResize, resize, echartsResize, optionsHandler, judgeWidthHandler, resizeableHandler, init, addResizeListener, removeResizeListener, addWatchToProps, createEventProxy, themeChange, clean, mounted, changeHandler, resizeHandler } from './index';
-import { camelToKebab } from './deps/utils';
-export var api = ['state', 'camelToKebab', 'dataHandler', 'nextTickResize', 'resize', 'echartsResize', 'optionsHandler', 'judgeWidthHandler', 'resizeableHandler', 'init', 'addResizeListener', 'removeResizeListener', 'addWatchToProps', 'createEventProxy', 'themeChange', 'clean', 'mounted', 'changeHandler', 'resizeHandler'];
-export var renderless = function renderless(props, _ref, _ref2, _ref3) {
-  var computed = _ref.computed,
-    onBeforeUnmount = _ref.onBeforeUnmount,
-    onMounted = _ref.onMounted,
-    reactive = _ref.reactive,
-    watch = _ref.watch,
-    markRaw = _ref.markRaw;
-  var t = _ref2.t,
-    vm = _ref2.vm,
-    refs = _ref2.refs,
-    emit = _ref2.emit,
-    nextTick = _ref2.nextTick;
-  var echartsLib = _ref3.echartsLib;
-  var api = {};
-  var state = reactive({
-    chartColor: computed(function () {
-      return api.computedChartColor();
-    }),
-    canvasStyle: computed(function () {
-      return api.computedCanvasStyle();
-    })
+import "../chunk-PKUHTIDK.js";
+import {
+  computedCanvasStyle,
+  computedChartColor,
+  dataHandler,
+  nextTickResize,
+  resize,
+  echartsResize,
+  optionsHandler,
+  judgeWidthHandler,
+  resizeableHandler,
+  init,
+  addResizeListener,
+  removeResizeListener,
+  addWatchToProps,
+  createEventProxy,
+  themeChange,
+  clean,
+  mounted,
+  changeHandler,
+  resizeHandler
+} from "./index";
+import { camelToKebab } from "./deps/utils";
+const api = [
+  "state",
+  "camelToKebab",
+  "dataHandler",
+  "nextTickResize",
+  "resize",
+  "echartsResize",
+  "optionsHandler",
+  "judgeWidthHandler",
+  "resizeableHandler",
+  "init",
+  "addResizeListener",
+  "removeResizeListener",
+  "addWatchToProps",
+  "createEventProxy",
+  "themeChange",
+  "clean",
+  "mounted",
+  "changeHandler",
+  "resizeHandler"
+];
+const renderless = (props, { computed, onBeforeUnmount, onMounted, reactive, watch, markRaw }, { t, vm, refs, emit, nextTick }, { echartsLib }) => {
+  let api2 = {};
+  const state = reactive({
+    chartColor: computed(() => api2.computedChartColor()),
+    canvasStyle: computed(() => api2.computedCanvasStyle())
   });
-  api = {
-    state: state,
-    camelToKebab: camelToKebab,
+  api2 = {
+    state,
+    camelToKebab,
     computedChartColor: computedChartColor(props),
     computedCanvasStyle: computedCanvasStyle(props)
   };
-  onMounted(function () {
-    return api.mounted();
-  });
-  onBeforeUnmount(function () {
-    return api.clean();
-  });
-  return Object.assign(api, {
-    resize: resize({
-      props: props,
-      vm: vm,
-      api: api
-    }),
+  onMounted(() => api2.mounted());
+  onBeforeUnmount(() => api2.clean());
+  return Object.assign(api2, {
+    resize: resize({ props, vm, api: api2 }),
     echartsResize: echartsResize(state),
-    clean: clean({
-      props: props,
-      state: state,
-      api: api
-    }),
-    themeChange: themeChange({
-      api: api,
-      state: state
-    }),
-    changeHandler: changeHandler({
-      api: api,
-      props: props
-    }),
-    resizeHandler: resizeHandler({
-      api: api,
-      props: props
-    }),
-    nextTickResize: nextTickResize({
-      api: api,
-      nextTick: nextTick
-    }),
-    init: init({
-      state: state,
-      props: props,
-      api: api,
-      refs: refs,
-      echartsLib: echartsLib,
-      markRaw: markRaw
-    }),
-    createEventProxy: createEventProxy({
-      api: api,
-      props: props,
-      state: state
-    }),
-    addResizeListener: addResizeListener({
-      state: state,
-      api: api
-    }),
-    resizeableHandler: resizeableHandler({
-      api: api,
-      state: state
-    }),
-    mounted: mounted({
-      api: api,
-      state: state,
-      vm: vm,
-      props: props,
-      watch: watch,
-      t: t
-    }),
-    removeResizeListener: removeResizeListener({
-      state: state,
-      api: api
-    }),
-    addWatchToProps: addWatchToProps({
-      vm: vm,
-      props: props,
-      watch: watch,
-      api: api
-    }),
-    dataHandler: dataHandler({
-      api: api,
-      props: props,
-      state: state,
-      echartsLib: echartsLib,
-      t: t,
-      vm: vm
-    }),
-    judgeWidthHandler: judgeWidthHandler({
-      props: props,
-      api: api,
-      vm: vm,
-      nextTick: nextTick
-    }),
+    clean: clean({ props, state, api: api2 }),
+    themeChange: themeChange({ api: api2, state }),
+    changeHandler: changeHandler({ api: api2, props }),
+    resizeHandler: resizeHandler({ api: api2, props }),
+    nextTickResize: nextTickResize({ api: api2, nextTick }),
+    init: init({ state, props, api: api2, refs, echartsLib, markRaw }),
+    createEventProxy: createEventProxy({ api: api2, props, state }),
+    addResizeListener: addResizeListener({ state, api: api2 }),
+    resizeableHandler: resizeableHandler({ api: api2, state }),
+    mounted: mounted({ api: api2, state, vm, props, watch, t }),
+    removeResizeListener: removeResizeListener({ state, api: api2 }),
+    addWatchToProps: addWatchToProps({ vm, props, watch, api: api2 }),
+    dataHandler: dataHandler({ api: api2, props, state, echartsLib, t, vm }),
+    judgeWidthHandler: judgeWidthHandler({ props, api: api2, vm, nextTick }),
     optionsHandler: optionsHandler({
-      props: props,
-      state: state,
-      emit: emit,
-      echartsLib: echartsLib,
-      api: api,
-      vm: vm
+      props,
+      state,
+      emit,
+      echartsLib,
+      api: api2,
+      vm
     })
   });
-};
+};
+export {
+  api,
+  renderless
+};

package/chart-funnel/index.js

@@ -1,155 +1,76 @@
-import { getFormated } from '@opentiny/vue-renderless/chart-core/deps/utils';
-import { itemPoint, itemLabel, itemContent } from '@opentiny/vue-renderless/chart-core/deps/constants';
-import { isNull } from '@opentiny/vue-renderless/common/type';
-var getFunnelTooltip = function getFunnelTooltip(dataType, digit) {
+import "../chunk-PKUHTIDK.js";
+import { getFormated } from "@opentiny/vue-renderless/chart-core/deps/utils";
+import { itemPoint, itemLabel, itemContent } from "@opentiny/vue-renderless/chart-core/deps/constants";
+import { isNull } from "@opentiny/vue-renderless/common/type";
+const getFunnelTooltip = (dataType, digit) => {
   function formatter(item) {
-    var tpl = [];
+    let tpl = [];
     tpl.push(itemPoint(item.color));
-    tpl.push("".concat(itemLabel(item.name)).concat(itemContent(getFormated(item.data.realValue, dataType, digit))));
-    return tpl.join('');
+    tpl.push(`${itemLabel(item.name)}${itemContent(getFormated(item.data.realValue, dataType, digit))}`);
+    return tpl.join("");
   }
-  return {
-    trigger: 'item',
-    formatter: formatter
-  };
+  return { trigger: "item", formatter };
 };
-var getFunnelLegend = function getFunnelLegend(args) {
-  var data = args.data,
-    legendName = args.legendName;
+const getFunnelLegend = (args) => {
+  const { data, legendName } = args;
   function formatter(name) {
     return isNull(legendName[name]) ? name : legendName[name];
   }
-  return {
-    data: data,
-    formatter: formatter
-  };
+  return { data, formatter };
 };
-var getFunnelSeries = function getFunnelSeries(args) {
-  var ascending = args.ascending,
-    dimension = args.dimension,
-    itemStyle = args.itemStyle,
-    label = args.label,
-    labelLine = args.labelLine,
-    metrics = args.metrics,
-    rows = args.rows,
-    sequence = args.sequence,
-    useDefaultOrder = args.useDefaultOrder;
-  var _ref = {},
-    _ref$series = _ref.series,
-    series = _ref$series === void 0 ? {
-      type: 'funnel'
-    } : _ref$series,
-    _ref$falseFunnel = _ref.falseFunnel,
-    falseFunnel = _ref$falseFunnel === void 0 ? false : _ref$falseFunnel;
+const getFunnelSeries = (args) => {
+  const { ascending, dimension, itemStyle, label, labelLine, metrics, rows, sequence, useDefaultOrder } = args;
+  let { series = { type: "funnel" }, falseFunnel = false } = {};
   series.minSize = 8;
-  var innerRows = rows.sort(function (a, b) {
-    return sequence.indexOf(a[dimension]) - sequence.indexOf(b[dimension]);
-  });
-  innerRows.some(function (row, index) {
-    return index && row[metrics] > innerRows[index - 1][metrics] && (falseFunnel = true);
-  });
-  var step = 100 / innerRows.length;
+  let innerRows = rows.sort((a, b) => sequence.indexOf(a[dimension]) - sequence.indexOf(b[dimension]));
+  innerRows.some((row, index) => index && row[metrics] > innerRows[index - 1][metrics] && (falseFunnel = true));
+  const step = 100 / innerRows.length;
   if (falseFunnel && !useDefaultOrder) {
-    var handler = function handler(row, index) {
-      return {
-        name: row[dimension],
-        value: (index + 1) * step,
-        realValue: row[metrics]
-      };
-    };
+    const handler = (row, index) => ({ name: row[dimension], value: (index + 1) * step, realValue: row[metrics] });
     series.data = innerRows.slice().reverse().map(handler);
   } else {
-    series.data = innerRows.map(function (row) {
-      return {
-        name: row[dimension],
-        value: row[metrics],
-        realValue: row[metrics]
-      };
-    });
+    series.data = innerRows.map((row) => ({ name: row[dimension], value: row[metrics], realValue: row[metrics] }));
   }
-  var total = 0;
-  rows.forEach(function (row) {
+  let total = 0;
+  rows.forEach((row) => {
     total += row[metrics];
   });
   series.label = {
-    position: 'inside',
-    color: '#fff',
-    formatter: function formatter(item) {
-      var value = item.value;
-      return "".concat(Number(value / total).toFixed(2) * 100, "%");
+    position: "inside",
+    color: "#fff",
+    formatter(item) {
+      let { value } = item;
+      return `${Number(value / total).toFixed(2) * 100}%`;
     }
   };
-  ascending && (series.sort = 'ascending');
+  ascending && (series.sort = "ascending");
   label && (series.label = label);
   labelLine && (series.labelLine = labelLine);
   itemStyle && (series.itemStyle = itemStyle);
   return series;
 };
-export var funnel = function funnel(outerColumns, outerRows, settings, extra) {
-  var _ref2 = {},
-    _ref2$columns = _ref2.columns,
-    columns = _ref2$columns === void 0 ? outerColumns.slice() : _ref2$columns,
-    _ref2$rows = _ref2.rows,
-    rows = _ref2$rows === void 0 ? outerRows.slice() : _ref2$rows;
-  var _settings$dataType = settings.dataType,
-    dataType = _settings$dataType === void 0 ? 'normal' : _settings$dataType,
-    _settings$dimension = settings.dimension,
-    dimension = _settings$dimension === void 0 ? columns[0] : _settings$dimension,
-    _settings$sequence = settings.sequence,
-    sequence = _settings$sequence === void 0 ? rows.map(function (row) {
-      return row[dimension];
-    }) : _settings$sequence;
-  var _settings$digit = settings.digit,
-    digit = _settings$digit === void 0 ? 2 : _settings$digit,
-    ascending = settings.ascending,
-    label = settings.label,
-    labelLine = settings.labelLine,
-    _settings$legendName = settings.legendName,
-    legendName = _settings$legendName === void 0 ? {} : _settings$legendName,
-    itemStyle = settings.itemStyle,
-    filterZero = settings.filterZero,
-    useDefaultOrder = settings.useDefaultOrder;
-  var tooltipVisible = extra.tooltipVisible,
-    legendVisible = extra.legendVisible;
-  var metrics;
+const funnel = (outerColumns, outerRows, settings, extra) => {
+  const { columns = outerColumns.slice(), rows = outerRows.slice() } = {};
+  const { dataType = "normal", dimension = columns[0], sequence = rows.map((row) => row[dimension]) } = settings;
+  const { digit = 2, ascending, label, labelLine, legendName = {}, itemStyle, filterZero, useDefaultOrder } = settings;
+  const { tooltipVisible, legendVisible } = extra;
+  let metrics;
   if (settings.metrics) {
     metrics = settings.metrics;
   } else {
-    var temp = columns.slice();
+    let temp = columns.slice();
     temp.splice(columns.indexOf(dimension), 1);
     metrics = temp[0];
   }
-  var innerRows = rows.sort(function (a, b) {
-    return sequence.indexOf(a[dimension]) - sequence.indexOf(b[dimension]);
-  });
-  filterZero && (innerRows = innerRows.filter(function (row) {
-    return row[metrics];
-  }));
-  var tooltip = tooltipVisible && getFunnelTooltip(dataType, digit);
-  var legend = legendVisible && getFunnelLegend({
-    data: innerRows.map(function (row) {
-      return row[dimension];
-    }),
-    legendName: legendName
-  });
-  var seriesParam = {
-    dimension: dimension,
-    metrics: metrics,
-    rows: innerRows,
-    sequence: sequence,
-    ascending: ascending
-  };
-  Object.assign(seriesParam, {
-    label: label,
-    labelLine: labelLine,
-    itemStyle: itemStyle,
-    filterZero: filterZero,
-    useDefaultOrder: useDefaultOrder
-  });
-  var series = getFunnelSeries(seriesParam);
-  return {
-    tooltip: tooltip,
-    legend: legend,
-    series: series
-  };
-};
+  let innerRows = rows.sort((a, b) => sequence.indexOf(a[dimension]) - sequence.indexOf(b[dimension]));
+  filterZero && (innerRows = innerRows.filter((row) => row[metrics]));
+  const tooltip = tooltipVisible && getFunnelTooltip(dataType, digit);
+  const legend = legendVisible && getFunnelLegend({ data: innerRows.map((row) => row[dimension]), legendName });
+  const seriesParam = { dimension, metrics, rows: innerRows, sequence, ascending };
+  Object.assign(seriesParam, { label, labelLine, itemStyle, filterZero, useDefaultOrder });
+  const series = getFunnelSeries(seriesParam);
+  return { tooltip, legend, series };
+};
+export {
+  funnel
+};