super-page-designer 0.0.1-tmp1

package/dist/es/components/design/utils/chart-design-util.js

@@ -0,0 +1,1494 @@
+function generateChartHeader(configure) {
+  const haderJson = {};
+  const props = configure.props ? configure.props : {};
+  const style = configure.style ? configure.style : {};
+  if (props.title || (!props.groupSource || props.groupSource == "fix") && props.groupPosition) {
+    haderJson.showHeader = true;
+    haderJson.title = props.title;
+    haderJson.textAlign = style.titleTextAlign;
+    if ((!props.groupSource || props.groupSource == "fix") && props.groupPosition) {
+      haderJson.showGroup = true;
+      haderJson.groupPosition = props.groupPosition;
+      haderJson.groupComponent = props.groupComponent;
+    }
+  }
+  const options = [];
+  if (props.groups) {
+    for (let g of props.groups) {
+      if (g.group && g.target) {
+        options.push({
+          value: g.group,
+          label: g.group,
+          target: g.target
+        });
+      }
+    }
+  }
+  haderJson.options = options;
+  const titleStyle = {};
+  if (style.titleFontWeight) {
+    titleStyle["font-weight"] = "bold";
+  }
+  if (style.titleIncline) {
+    titleStyle["font-style"] = "italic";
+  }
+  if (style.titleFontSize) {
+    titleStyle["font-size"] = style.titleFontSize + "px";
+  }
+  if (style.titleColor) {
+    titleStyle["color"] = style.titleColor;
+  }
+  haderJson.style = titleStyle;
+  return haderJson;
+}
+function generateChartOption(configure, chartOption) {
+  const thisProps = configure.props ? configure.props : {};
+  const thisStyle = configure.style ? configure.style : {};
+  const tempOption = {
+    title: [
+      {
+        textStyle: {},
+        //标题样式
+        subtextStyle: {}
+        //副标题样式
+      }
+    ],
+    toolbox: {
+      show: false,
+      feature: {
+        saveAsImage: {
+          show: false
+        },
+        restore: {
+          show: false
+        },
+        dataView: {
+          show: false
+        },
+        dataZoom: {
+          show: false
+        },
+        magicType: {
+          show: false
+        },
+        brush: {
+          show: false
+        }
+      }
+    },
+    grid: {},
+    xAxis: [
+      {
+        axisLabel: {},
+        nameTruncate: {}
+      }
+    ],
+    yAxis: [
+      {
+        show: false,
+        position: "left",
+        nameTextStyle: {},
+        axisLine: {},
+        splitLine: {},
+        axisLabel: {}
+      },
+      {
+        show: false,
+        position: "right",
+        nameTextStyle: {},
+        axisLine: {},
+        splitLine: {},
+        axisLabel: {}
+      }
+    ],
+    tooltip: {
+      textStyle: {}
+    },
+    dataZoom: [],
+    series: []
+  };
+  const isColumnLine = configure.name == "chart-column-line";
+  const isPie = configure.name == "chart-pie";
+  const isGauge = configure.name == "chart-gauge";
+  const isRadar = configure.name == "chart-radar";
+  const isScatter = configure.name == "chart-scatter";
+  if (thisProps.title)
+    ;
+  if (thisProps.subTitle) {
+    tempOption.title[0].subtext = thisProps.subTitle;
+    if (thisStyle.subtitleTextAlign) {
+      tempOption.title[0].left = thisStyle.subtitleTextAlign;
+    }
+    const subTtileJson = generateSubtitleJson(thisStyle);
+    Object.assign(tempOption.title[0], subTtileJson);
+  }
+  if (thisProps.enableDownloadBtn || thisProps.enableDataBtn) {
+    tempOption.toolbox.show = true;
+  }
+  if (thisProps.enableDownloadBtn != void 0) {
+    tempOption.toolbox.feature.saveAsImage.show = thisProps.enableDownloadBtn;
+  }
+  if (thisProps.enableDataBtn != void 0) {
+    tempOption.toolbox.feature.dataView.show = thisProps.enableDataBtn;
+  }
+  if (isColumnLine || isPie || isRadar || isScatter) {
+    if (thisStyle.enableLegend != void 0) {
+      if (tempOption.legend == void 0) {
+        tempOption.legend = {};
+      }
+      tempOption.legend.show = thisStyle.enableLegend;
+      if (thisStyle.enableLegend) {
+        if (thisStyle.legendLayout) {
+          tempOption.legend.orient = thisStyle.legendLayout;
+        }
+        if (thisStyle.legendAlign) {
+          tempOption.legend.left = thisStyle.legendAlign;
+        }
+        if (thisStyle.legendVerticalAlign) {
+          tempOption.legend.top = thisStyle.legendVerticalAlign;
+        }
+        if (thisStyle.legendPadding) {
+          tempOption.legend.padding = thisStyle.legendPadding;
+        }
+        if (thisStyle.customLegend) {
+          tempOption.legend.formatter = thisStyle.customLegend;
+        }
+      }
+    }
+  }
+  if (thisStyle.gridBackgroundColor) {
+    tempOption.grid.show = true;
+    tempOption.grid.backgroundColor = thisStyle.gridBackgroundColor;
+  }
+  if (thisStyle.gridPaddingTop) {
+    tempOption.grid.top = thisStyle.gridPaddingTop;
+  }
+  if (thisStyle.gridPaddingRight) {
+    tempOption.grid.right = thisStyle.gridPaddingRight;
+  }
+  if (thisStyle.gridPaddingBottom) {
+    tempOption.grid.bottom = thisStyle.gridPaddingBottom;
+  }
+  if (thisStyle.gridPaddingLeft) {
+    tempOption.grid.left = thisStyle.gridPaddingLeft;
+  }
+  if (thisStyle.enableGridLine) {
+    tempOption.grid.show = true;
+    if (thisStyle.gridLineWidth) {
+      tempOption.grid.borderWidth = thisStyle.gridLineWidth;
+    }
+    if (thisStyle.gridLineColor) {
+      tempOption.grid.show = true;
+      tempOption.grid.borderColor = thisStyle.gridLineColor;
+    }
+  } else if (!thisStyle.gridShadowColor) {
+    tempOption.grid.borderWidth = 0;
+  }
+  if (thisStyle.gridShadowColor) {
+    tempOption.grid.show = true;
+    tempOption.grid.shadowColor = thisStyle.gridShadowColor;
+    if (thisStyle.gridShadowX) {
+      tempOption.grid.shadowOffsetX = thisStyle.gridShadowX;
+    }
+    if (thisStyle.gridShadowY) {
+      tempOption.grid.shadowOffsetY = thisStyle.gridShadowY;
+    }
+    if (thisStyle.gridShadowBlur) {
+      tempOption.grid.shadowBlur = thisStyle.gridShadowBlur;
+    }
+  }
+  if (isColumnLine || isScatter) {
+    if (isColumnLine) {
+      if (!thisStyle.xaxisTestdatas) {
+        thisStyle.xaxisTestdatas = "项1,项2,项3,项4,项5,项6,项7,项8";
+      }
+      tempOption.xAxis[0].data = thisStyle.xaxisTestdatas.split(",");
+    }
+    if (thisStyle.enableXaxis != void 0) {
+      tempOption.xAxis[0].show = thisStyle.enableXaxis;
+      if (thisStyle.enableXaxis) {
+        if (tempOption.xAxis[0].axisLabel == void 0) {
+          tempOption.xAxis[0].axisLabel = {};
+        }
+        if (thisStyle.xaxisAngle) {
+          tempOption.xAxis[0].axisLabel.rotate = thisStyle.xaxisAngle;
+        }
+        if (thisStyle.xaxisOffset) {
+          tempOption.xAxis[0].offset = thisStyle.xaxisOffset;
+        }
+        if (thisStyle.xaxisWidth) {
+          tempOption.xAxis[0].axisLabel.overflow = "truncate";
+          tempOption.xAxis[0].axisLabel.width = thisStyle.xaxisWidth;
+        }
+        if (thisStyle.xaxisEllipsis) {
+          tempOption.xAxis[0].axisLabel.overflow = "truncate";
+          tempOption.xAxis[0].axisLabel.ellipsis = thisStyle.xaxisEllipsis;
+        }
+        if (thisStyle.xaxisFormatter) {
+          tempOption.xAxis[0].axisLabel.formatter = thisStyle.xaxisFormatter;
+        }
+      }
+      if (isColumnLine && tempOption.xAxis[0].show != false) {
+        tempOption.xAxis[0].data = thisStyle.xaxisTestdatas.split(",");
+      }
+    }
+    if (thisStyle.xaxisMin) {
+      tempOption.xAxis[0].min = thisStyle.xaxisMin;
+    }
+    if (thisStyle.xaxisMax) {
+      tempOption.xAxis[0].max = thisStyle.xaxisMax;
+    }
+    const tempYaxis = [thisStyle.yaxisLeft, thisStyle.yaxisRight];
+    for (let index = 0; index < tempYaxis.length; index++) {
+      const styleYaxis = tempYaxis[index];
+      const optionYaxis = tempOption.yAxis[index];
+      generateYaxisJson(styleYaxis, optionYaxis);
+    }
+  }
+  if (isColumnLine || isScatter) {
+    if (thisStyle.enableDatazoom) {
+      const tempZoom = {
+        type: "slider"
+      };
+      if (thisStyle.dataZoomType) {
+        tempZoom.type = thisStyle.dataZoomType;
+      }
+      if (thisStyle.dataZoomStart) {
+        tempZoom.start = thisStyle.dataZoomStart;
+      }
+      if (thisStyle.dataZoomEnd) {
+        tempZoom.end = thisStyle.dataZoomEnd;
+      }
+      tempOption.dataZoom.push(tempZoom);
+    }
+  }
+  if (thisStyle.enableTooltip != void 0) {
+    generateTooltipJson(thisStyle, tempOption);
+  }
+  const thisItems = configure.items ? configure.items : [];
+  for (let thisItem of thisItems) {
+    let tempSerie = null;
+    if (thisItem.type == "radar") {
+      tempSerie = generateRadarSeriesJson(thisItem, tempOption);
+    } else if (thisItem.type == "scatter") {
+      tempSerie = generateScatterSeriesJson(thisItem);
+    } else {
+      tempSerie = generateSeriesJson(thisItem);
+    }
+    if (isColumnLine || isScatter) {
+      if (thisItem.props.yAxisIndex == "1") {
+        tempSerie.yAxisIndex = 1;
+        tempOption.yAxis[1].show = true;
+      } else {
+        tempOption.yAxis[0].show = true;
+      }
+      if (tempSerie.type == "bar") {
+        if (thisStyle.barGap != null && thisStyle.barGap != void 0 && thisStyle.barGap != "") {
+          tempSerie.barGap = thisStyle.barGap + "%";
+        }
+        if (thisStyle.barCategoryGap != null && thisStyle.barCategoryGap != void 0 && thisStyle.barCategoryGap != "") {
+          tempSerie.barCategoryGap = thisStyle.barCategoryGap + "%";
+        }
+      }
+    }
+    if (isPie || isGauge) {
+      if (thisItem.props.subTitle) {
+        const subTitleJson = generateSubtitleJson(thisItem.style);
+        subTitleJson.subtext = thisItem.props.subTitle;
+        tempOption.title.push(subTitleJson);
+      }
+    }
+    tempOption.series.push(tempSerie);
+  }
+  if (isPie) {
+    if (thisStyle.enableLegend == false) {
+      tempOption.legend = void 0;
+    }
+    tempOption.xAxis[0].show = false;
+  }
+  if (isGauge || isRadar) {
+    tempOption.xAxis[0].show = false;
+  }
+  if (thisProps.isBar) {
+    for (let tempYaxis of tempOption.yAxis) {
+      if (tempYaxis.show) {
+        tempYaxis.type = "category";
+        tempYaxis.data = tempOption.xAxis[0].data;
+      }
+    }
+    tempOption.xAxis[0].data = void 0;
+  }
+  const customAttrJson = convertStrToJson(thisStyle.customAttr);
+  if (customAttrJson) {
+    Object.assign(tempOption, customAttrJson);
+  }
+  chartOption.value = tempOption;
+  console.log("tempOption", tempOption);
+}
+function generateSubtitleJson(thisStyle) {
+  const subtitleJson = {
+    subtextStyle: {}
+  };
+  if (thisStyle.subtitleFontWeight) {
+    subtitleJson.subtextStyle.fontWeight = thisStyle.subtitleFontWeight;
+  }
+  if (thisStyle.subtitleIncline) {
+    subtitleJson.subtextStyle.fontStyle = "italic";
+  }
+  if (thisStyle.subtitleFontSize) {
+    subtitleJson.subtextStyle.fontSize = thisStyle.subtitleFontSize;
+  }
+  if (thisStyle.subtitleColor) {
+    subtitleJson.subtextStyle.color = thisStyle.subtitleColor;
+  }
+  if (thisStyle.subtitleLeft) {
+    subtitleJson.left = thisStyle.subtitleLeft;
+  }
+  if (thisStyle.subtitleTop) {
+    subtitleJson.top = thisStyle.subtitleTop;
+  }
+  return subtitleJson;
+}
+function generateTooltipJson(thisStyle, tempOption) {
+  tempOption.tooltip.show = thisStyle.enableTooltip;
+  if (thisStyle.tooltipTrigger) {
+    tempOption.tooltip.trigger = thisStyle.tooltipTrigger;
+  }
+  if (thisStyle.tooltipPosition) {
+    tempOption.tooltip.position = thisStyle.tooltipPosition;
+  }
+  if (thisStyle.tooltipNumFormat) {
+    tempOption.tooltip.valueFormatter = getNumFormatter(
+      thisStyle.tooltipNumFormat,
+      thisStyle.tooltipNumPrecision,
+      thisStyle.tooltipNumPrefix,
+      thisStyle.tooltipNumAppend,
+      true
+    );
+  }
+  if (thisStyle.tooltipFormatter) {
+    tempOption.tooltip.formatter = thisStyle.tooltipFormatter;
+  }
+  if (thisStyle.tooltipFontSize) {
+    tempOption.tooltip.textStyle.fontSize = thisStyle.tooltipFontSize;
+  }
+  if (thisStyle.tooltipColor) {
+    tempOption.tooltip.textStyle.color = thisStyle.tooltipColor;
+  }
+  if (thisStyle.tooltipWeight) {
+    tempOption.tooltip.textStyle.fontWeight = thisStyle.tooltipWeight;
+  }
+  if (thisStyle.tooltipFormatter) {
+    tempOption.tooltip.formatter = thisStyle.tooltipFormatter;
+  }
+}
+function generateYaxisJson(styleYaxis, optionYaxis) {
+  if (styleYaxis.offset != void 0 && styleYaxis.offset != "") {
+    optionYaxis.offset = styleYaxis.offset;
+  }
+  if (styleYaxis.name) {
+    optionYaxis.name = styleYaxis.name;
+  }
+  if (styleYaxis.nameLocation) {
+    optionYaxis.nameLocation = styleYaxis.nameLocation;
+  }
+  if (styleYaxis.namePadding) {
+    optionYaxis.nameTextStyle.padding = styleYaxis.namePadding;
+  }
+  if (styleYaxis.nameAlign) {
+    optionYaxis.nameTextStyle.align = styleYaxis.nameAlign;
+  }
+  if (styleYaxis.nameVerticalAlign) {
+    optionYaxis.nameTextStyle.verticalAlign = styleYaxis.nameVerticalAlign;
+  }
+  if (styleYaxis.nameColor) {
+    optionYaxis.nameTextStyle.color = styleYaxis.nameColor;
+  }
+  if (styleYaxis.nameFontSize) {
+    optionYaxis.nameTextStyle.fontSize = styleYaxis.nameFontSize;
+  }
+  optionYaxis.min = styleYaxis.min;
+  optionYaxis.max = styleYaxis.max;
+  if (styleYaxis.enableAxisLine != void 0) {
+    optionYaxis.splitLine.show = styleYaxis.enableAxisLine;
+    if (styleYaxis.enableAxisLine) {
+      if (styleYaxis.splitNumber) {
+        optionYaxis.splitNumber = styleYaxis.splitNumber;
+      }
+    }
+  }
+  if (styleYaxis.formatter) {
+    optionYaxis.axisLabel.formatter = styleYaxis.formatter;
+  }
+  if (styleYaxis.labelColor) {
+    optionYaxis.axisLabel.color = styleYaxis.labelColor;
+  }
+  if (styleYaxis.labelFontSize) {
+    optionYaxis.axisLabel.fontSize = styleYaxis.labelFontSize;
+  }
+}
+function generateSeriesJson(serieConfigure) {
+  const itemProps = serieConfigure.props ? serieConfigure.props : {};
+  const itemStyle = serieConfigure.style ? serieConfigure.style : {};
+  const tempSerie = {
+    name: itemProps.title,
+    type: serieConfigure.type,
+    label: {},
+    itemStyle: {},
+    lineStyle: {}
+  };
+  if (itemStyle.enableLabel != void 0) {
+    tempSerie.label.show = itemStyle.enableLabel;
+    if (itemStyle.labelPosition) {
+      tempSerie.label.position = itemStyle.labelPosition;
+    }
+    if (itemStyle.labelFontSize) {
+      tempSerie.label.fontSize = itemStyle.labelFontSize;
+    }
+    if (itemStyle.labelColor) {
+      tempSerie.label.color = itemStyle.labelColor;
+    }
+    if (itemStyle.labelWeight) {
+      tempSerie.label.fontWeight = itemStyle.labelWeight;
+    }
+    if (itemStyle.textAlign) {
+      tempSerie.label.align = itemStyle.textAlign;
+    }
+    if (itemStyle.verticalAlign) {
+      tempSerie.label.verticalAlign = itemStyle.verticalAlign;
+    }
+    if (itemStyle.labelAngle) {
+      tempSerie.label.rotate = itemStyle.labelAngle;
+    }
+    if (itemStyle.labelLeft || itemStyle.labelTop) {
+      const offset = [0, 0];
+      if (itemStyle.labelLeft && !isNaN(itemStyle.labelLeft)) {
+        offset[0] = parseFloat(itemStyle.labelLeft);
+      }
+      if (itemStyle.labelTop && !isNaN(itemStyle.labelTop)) {
+        offset[1] = parseFloat(itemStyle.labelTop);
+      }
+      tempSerie.label.offset = offset;
+    } else {
+      tempSerie.label.offset = [0, 0];
+    }
+    if (itemStyle.labelAlignTo) {
+      tempSerie.label.alignTo = itemStyle.labelAlignTo;
+    }
+    if (itemStyle.labelNumFormat && itemStyle.labelNumFormat.length > 0) {
+      tempSerie.label.formatter = getNumFormatter(
+        itemStyle.labelNumFormat,
+        itemStyle.labelNumPrecision,
+        itemStyle.labelNumPrefix,
+        itemStyle.labelNumAppend,
+        false
+      );
+    } else if (itemStyle.labelFormatter) {
+      tempSerie.label.formatter = itemStyle.labelFormatter;
+    }
+  }
+  if (serieConfigure.type == "bar") {
+    generateBarSeriesJson(tempSerie, serieConfigure);
+  }
+  if (serieConfigure.type == "line") {
+    generateLineSeriesJson(tempSerie, serieConfigure);
+  }
+  const isPieChart = serieConfigure.type == "pie";
+  const pieColorMap = {};
+  const pieColors = [];
+  if (isPieChart) {
+    generatePieSeriesJson(tempSerie, serieConfigure);
+    if (itemStyle.colors && itemStyle.colors.length > 0) {
+      for (let item of itemStyle.colors) {
+        if (item.color) {
+          if (item.name) {
+            pieColorMap[item.name] = item.color;
+          } else {
+            pieColors.push(item.color);
+          }
+        }
+      }
+    }
+  }
+  const isGauge = serieConfigure.type == "gauge";
+  if (isGauge) {
+    generateGaugeSeriesJson(tempSerie, serieConfigure);
+  }
+  const customAttrJson = convertStrToJson(itemStyle.customAttr);
+  if (customAttrJson) {
+    Object.assign(tempSerie, customAttrJson);
+  }
+  if (!itemProps.testdatas) {
+    const min = 0, max = 100;
+    let tempDatas = [];
+    for (let i = 0; i < 8; i++) {
+      const newMin = Math.ceil(min);
+      const newMax = Math.floor(max);
+      tempDatas.push(Math.floor(Math.random() * (newMax - newMin + 1)) + newMin);
+    }
+    if (isPieChart) {
+      const pieDatas = [];
+      for (let i = 0; i < 8; i++) {
+        pieDatas.push("项" + (i + 1) + ":" + tempDatas[i]);
+      }
+      tempDatas = pieDatas;
+    }
+    if (isGauge) {
+      tempDatas = ["名称:" + tempDatas[0]];
+    }
+    itemProps.testdatas = tempDatas.join(",");
+  }
+  if (isPieChart || isGauge) {
+    const testDatas = itemProps.testdatas.split(",");
+    const pieDatas = [];
+    for (let index = 0; index < testDatas.length; index++) {
+      const testData = testDatas[index];
+      if (!testData) {
+        continue;
+      }
+      const strs = testData.split(":");
+      if (strs.length < 2) {
+        continue;
+      }
+      const data = {
+        value: strs[1],
+        name: strs[0]
+      };
+      if (index < pieColors.length || pieColorMap[data.name]) {
+        let color = pieColorMap[data.name];
+        if (!color) {
+          color = pieColors[index];
+        }
+        if (color) {
+          data.itemStyle = {
+            color
+          };
+        }
+      }
+      pieDatas.push(data);
+    }
+    if (isGauge && itemStyle.enableGaugeTitle != void 0) {
+      const gaugeTitleJson = generateGaugeTitleJson(itemStyle);
+      for (let data of pieDatas) {
+        data.title = gaugeTitleJson;
+      }
+      console.log("gaugeTitleJson", pieDatas);
+    }
+    tempSerie.data = pieDatas;
+  } else {
+    tempSerie.data = itemProps.testdatas.split(",");
+  }
+  return tempSerie;
+}
+function generateRadarSeriesJson(serieConfigure, tempOption) {
+  const itemProps = serieConfigure.props ? serieConfigure.props : {};
+  const itemStyle = serieConfigure.style ? serieConfigure.style : {};
+  const tempSerie = {
+    name: itemProps.title,
+    type: serieConfigure.type
+  };
+  if (tempOption.radar == void 0) {
+    tempOption.radar = [];
+  }
+  const tempRadar = {};
+  if (itemStyle.shape) {
+    tempRadar.shape = itemStyle.shape;
+  }
+  if (itemStyle.centerLeft || itemStyle.centerTop) {
+    const centerStrs = ["50%", "50%"];
+    if (itemStyle.centerLeft) {
+      centerStrs[0] = itemStyle.centerLeft;
+    }
+    if (itemStyle.centerTop) {
+      centerStrs[1] = itemStyle.centerTop;
+    }
+    tempRadar.center = centerStrs;
+  }
+  if (itemStyle.radiusOuter) {
+    tempRadar.radius = itemStyle.radiusOuter;
+  }
+  if (itemStyle.splitNumber || itemStyle.splitNumber == "0") {
+    tempRadar.splitNumber = itemStyle.splitNumber;
+  }
+  if (itemStyle.startAngle || itemStyle.startAngle == "0") {
+    tempRadar.startAngle = itemStyle.startAngle;
+  }
+  if (itemStyle.enableXaxisName != void 0) {
+    if (itemStyle.nameGap || itemStyle.nameGap == "0") {
+      tempRadar.nameGap = itemStyle.nameGap;
+    }
+    if (tempRadar.axisName == void 0) {
+      tempRadar.axisName = {};
+    }
+    tempRadar.axisName.show = itemStyle.enableXaxisName;
+    if (itemStyle.enableXaxisName) {
+      if (itemStyle.axisNameColor) {
+        tempRadar.axisName.color = itemStyle.axisNameColor;
+      }
+      if (itemStyle.axisNameFontSize) {
+        tempRadar.axisName.fontSize = itemStyle.axisNameFontSize;
+      }
+      if (itemStyle.axisNameFontWeight) {
+        tempRadar.axisName.fontWeight = itemStyle.axisNameFontWeight;
+      }
+      if (itemStyle.xaxisNameWidth) {
+        tempRadar.axisName.width = itemStyle.xaxisNameWidth;
+      }
+      if (itemStyle.xaxisNameEllipsis) {
+        tempRadar.axisName.overflow = "truncate";
+        tempRadar.axisName.ellipsis = itemStyle.xaxisNameEllipsis;
+      }
+      if (itemStyle.xaxisNameFormatter) {
+        tempRadar.axisName.formatter = itemStyle.xaxisNameFormatter;
+      }
+    }
+  }
+  if (itemStyle.enableAxis != void 0) {
+    if (tempRadar.axisLine == void 0) {
+      tempRadar.axisLine = {};
+    }
+    tempRadar.axisLine.show = itemStyle.enableAxis;
+    if (itemStyle.enableAxis) {
+      if (tempRadar.axisLine.lineStyle == void 0) {
+        tempRadar.axisLine.lineStyle = {};
+      }
+      if (itemStyle.axisColor) {
+        tempRadar.axisLine.lineStyle.color = itemStyle.axisColor;
+      }
+      if (itemStyle.axisOpacity) {
+        tempRadar.axisLine.lineStyle.opacity = itemStyle.axisOpacity;
+      }
+      if (itemStyle.axisWidth || itemStyle.axisWidth == "0") {
+        tempRadar.axisLine.lineStyle.width = itemStyle.axisWidth;
+      }
+    }
+  }
+  if (itemStyle.enableSplit != void 0) {
+    if (tempRadar.splitLine == void 0) {
+      tempRadar.splitLine = {};
+    }
+    tempRadar.splitLine.show = itemStyle.enableSplit;
+    if (itemStyle.enableSplit) {
+      if (tempRadar.splitLine.lineStyle == void 0) {
+        tempRadar.splitLine.lineStyle = {};
+      }
+      if (itemStyle.splitColor) {
+        tempRadar.splitLine.lineStyle.color = itemStyle.splitColor;
+      }
+      if (itemStyle.splitOpacity) {
+        tempRadar.splitLine.lineStyle.opacity = itemStyle.splitOpacity;
+      }
+      if (itemStyle.splitWidth || itemStyle.splitWidth == "0") {
+        tempRadar.splitLine.lineStyle.width = itemStyle.splitWidth;
+      }
+      if (itemStyle.splitLength || itemStyle.splitLength == "0") {
+        tempRadar.splitLine.length = itemStyle.splitLength;
+      }
+      if (itemStyle.splitLineType) {
+        tempRadar.splitLine.lineStyle.type = itemStyle.splitLineType;
+      }
+    }
+  }
+  if (itemStyle.enableSplitArea != void 0) {
+    if (tempRadar.splitArea == void 0) {
+      tempRadar.splitArea = {};
+    }
+    tempRadar.splitArea.show = itemStyle.enableSplitArea;
+    if (itemStyle.enableSplitArea) {
+      if (tempRadar.splitArea.areaStyle == void 0) {
+        tempRadar.splitArea.areaStyle = {};
+      }
+      if (itemStyle.splitAreaColor) {
+        tempRadar.splitArea.areaStyle.color = [itemStyle.splitAreaColor, "#ffffff"];
+      }
+      if (itemStyle.splitAreaOpacity) {
+        tempRadar.splitArea.areaStyle.opacity = itemStyle.splitAreaOpacity;
+      }
+      if (itemStyle.splitAreaShadowColor) {
+        tempRadar.splitArea.areaStyle.shadowColor = itemStyle.splitAreaShadowColor;
+      }
+      if (itemStyle.splitAreaShadowBlur) {
+        tempRadar.splitArea.areaStyle.shadowBlur = itemStyle.splitAreaShadowBlur;
+      }
+      if (itemStyle.splitAreaShadowX) {
+        tempRadar.splitArea.areaStyle.shadowOffsetX = itemStyle.splitAreaShadowX;
+      }
+      if (itemStyle.splitAreaShadowY) {
+        tempRadar.splitArea.areaStyle.shadowOffsetY = itemStyle.splitAreaShadowY;
+      }
+    }
+  }
+  if (itemStyle.enableLabel != void 0) {
+    if (tempSerie.label == void 0) {
+      tempSerie.label = {};
+    }
+    tempSerie.label.show = itemStyle.enableLabel;
+    if (itemStyle.labelPosition) {
+      tempSerie.label.position = itemStyle.labelPosition;
+    }
+    if (itemStyle.labelFontSize) {
+      tempSerie.label.fontSize = itemStyle.labelFontSize;
+    }
+    if (itemStyle.labelColor) {
+      tempSerie.label.color = itemStyle.labelColor;
+    }
+    if (itemStyle.labelWeight) {
+      tempSerie.label.fontWeight = itemStyle.labelWeight;
+    }
+    if (itemStyle.labelAngle) {
+      tempSerie.label.rotate = itemStyle.labelAngle;
+    }
+    if (itemStyle.labelLeft || itemStyle.labelTop) {
+      const offset = [0, 0];
+      if (itemStyle.labelLeft && !isNaN(itemStyle.labelLeft)) {
+        offset[0] = parseFloat(itemStyle.labelLeft);
+      }
+      if (itemStyle.labelTop && !isNaN(itemStyle.labelTop)) {
+        offset[1] = parseFloat(itemStyle.labelTop);
+      }
+      tempSerie.label.offset = offset;
+    } else {
+      tempSerie.label.offset = [0, 0];
+    }
+    if (itemStyle.labelNumFormat && itemStyle.labelNumFormat.length > 0) {
+      tempSerie.label.formatter = getNumFormatter(
+        itemStyle.labelNumFormat,
+        itemStyle.labelNumPrecision,
+        itemStyle.labelNumPrefix,
+        itemStyle.labelNumAppend,
+        false
+      );
+    } else if (itemStyle.labelFormatter) {
+      tempSerie.label.formatter = itemStyle.labelFormatter;
+    }
+  }
+  if (tempSerie.lineStyle == void 0) {
+    tempSerie.lineStyle = {};
+  }
+  if (itemStyle.lineColor) {
+    tempSerie.lineStyle.color = itemStyle.lineColor;
+  }
+  if (itemStyle.lineOpacity) {
+    tempSerie.lineStyle.opacity = itemStyle.lineOpacity;
+  }
+  if (itemStyle.lineType) {
+    tempSerie.lineStyle.type = itemStyle.lineType;
+  }
+  if (itemStyle.lineWidth > 0) {
+    tempSerie.lineStyle.width = itemStyle.lineWidth;
+  }
+  if (itemStyle.lineShadowColor) {
+    tempSerie.lineStyle.shadowColor = itemStyle.lineShadowColor;
+    if (itemStyle.lineShadowBlur) {
+      tempSerie.lineStyle.shadowBlur = itemStyle.lineShadowBlur;
+    }
+    if (itemStyle.lineShadowX) {
+      tempSerie.lineStyle.shadowOffsetX = itemStyle.lineShadowX;
+    }
+    if (itemStyle.lineShadowY) {
+      tempSerie.lineStyle.shadowOffsetY = itemStyle.lineShadowY;
+    }
+  }
+  if (itemStyle.lineSymbol) {
+    tempSerie.symbol = itemStyle.lineSymbol;
+  }
+  if (itemStyle.lineSymbolSize > -1) {
+    tempSerie.symbolSize = itemStyle.lineSymbolSize;
+  }
+  if (itemStyle.lineSymbolColor) {
+    if (tempSerie.itemStyle == void 0) {
+      tempSerie.itemStyle = {};
+    }
+    tempSerie.itemStyle.color = itemStyle.lineSymbolColor;
+  }
+  if (itemStyle.enableSplitLineArea != void 0) {
+    if (tempSerie.areaStyle == void 0) {
+      tempSerie.areaStyle = {};
+    }
+    tempSerie.areaStyle.show = itemStyle.enableSplitLineArea;
+    if (itemStyle.enableSplitLineArea) {
+      if (itemStyle.splitLineAreaColor) {
+        tempSerie.areaStyle.color = itemStyle.splitLineAreaColor;
+      }
+      if (itemStyle.splitLineAreaOpacity) {
+        tempSerie.areaStyle.opacity = itemStyle.splitLineAreaOpacity;
+      }
+      if (itemStyle.splitLineAreaShadowColor) {
+        tempSerie.areaStyle.shadowColor = itemStyle.splitLineAreaShadowColor;
+      }
+      if (itemStyle.splitLineAreaShadowBlur) {
+        tempSerie.areaStyle.shadowBlur = itemStyle.splitLineAreaShadowBlur;
+      }
+      if (itemStyle.splitLineAreaShadowX) {
+        tempSerie.areaStyle.shadowOffsetX = itemStyle.splitLineAreaShadowX;
+      }
+      if (itemStyle.splitLineAreaShadowY) {
+        tempSerie.areaStyle.shadowOffsetY = itemStyle.splitLineAreaShadowY;
+      }
+    }
+  }
+  const customAttrJson = convertStrToJson(itemStyle.customAttr);
+  if (customAttrJson) {
+    Object.assign(tempSerie, customAttrJson);
+  }
+  if (!itemProps.testitems) {
+    itemProps.testitems = "项1,项2,项3,项4,项5,项6,项7,项8";
+  }
+  if (!itemProps.testdatas) {
+    const min = 0, max = 100;
+    let tempDatas = [];
+    for (let i = 0; i < 8; i++) {
+      const newMin = Math.ceil(min);
+      const newMax = Math.floor(max);
+      tempDatas.push(Math.floor(Math.random() * (newMax - newMin + 1)) + newMin);
+    }
+    itemProps.testdatas = "名称:" + tempDatas.join(",");
+  }
+  const testItems = itemProps.testitems.split(",");
+  const indicatorDatas = [];
+  let maxValue = null;
+  if (itemStyle.maxValueSource == "fix" && itemStyle.maxValueFixed) {
+    maxValue = parseFloat(itemStyle.maxValueFixed);
+  }
+  if (!maxValue || !isNaN(maxValue)) {
+    maxValue = 100;
+  }
+  for (let item of testItems) {
+    indicatorDatas.push({
+      name: item,
+      max: maxValue
+    });
+  }
+  tempRadar.indicator = indicatorDatas;
+  tempOption.radar.push(tempRadar);
+  const testDatas = itemProps.testdatas.split(";");
+  const seriesDatas = [];
+  for (let index = 0; index < testDatas.length; index++) {
+    const testData = testDatas[index];
+    if (!testData) {
+      continue;
+    }
+    const strs = testData.split(":");
+    if (strs.length < 2) {
+      continue;
+    }
+    const values = strs[1].split(",");
+    const data = {
+      name: strs[0],
+      value: values
+    };
+    seriesDatas.push(data);
+  }
+  tempSerie.data = seriesDatas;
+  if (tempOption.radar.length > 1) {
+    tempSerie.radarIndex = tempOption.radar.length - 1;
+  }
+  return tempSerie;
+}
+function generateScatterSeriesJson(serieConfigure, tempOption) {
+  const itemProps = serieConfigure.props ? serieConfigure.props : {};
+  const itemStyle = serieConfigure.style ? serieConfigure.style : {};
+  const tempSerie = {
+    name: itemProps.title,
+    type: serieConfigure.type,
+    itemStyle: {}
+  };
+  if (itemStyle.symbol) {
+    tempSerie.symbol = itemStyle.symbol;
+  }
+  if (itemStyle.symbolSize) {
+    tempSerie.symbolSize = itemStyle.symbolSize;
+  }
+  if (itemStyle.symbolColor) {
+    tempSerie.itemStyle.color = itemStyle.symbolColor;
+  }
+  if (itemStyle.symbolRotate) {
+    tempSerie.symbolRotate = itemStyle.symbolRotate;
+  }
+  if (itemStyle.symbolLeft || itemStyle.symbolTop) {
+    const centerStrs = [0, 0];
+    if (itemStyle.symbolLeft) {
+      centerStrs[0] = itemStyle.symbolLeft;
+    }
+    if (itemStyle.symbolTop) {
+      centerStrs[1] = itemStyle.symbolTop;
+    }
+    tempSerie.symbolOffset = centerStrs;
+  }
+  if (itemStyle.shadowColor) {
+    tempSerie.itemStyle.shadowColor = itemStyle.shadowColor;
+  }
+  if (itemStyle.shadowBlur) {
+    tempSerie.itemStyle.shadowBlur = itemStyle.shadowBlur;
+  }
+  if (itemStyle.shadowX) {
+    tempSerie.itemStyle.shadowOffsetX = itemStyle.shadowX;
+  }
+  if (itemStyle.shadowY) {
+    tempSerie.itemStyle.shadowOffsetY = itemStyle.shadowY;
+  }
+  if (itemStyle.enableLabel != void 0) {
+    if (tempSerie.label == void 0) {
+      tempSerie.label = {};
+    }
+    tempSerie.label.show = itemStyle.enableLabel;
+    if (itemStyle.labelPosition) {
+      tempSerie.label.position = itemStyle.labelPosition;
+    }
+    if (itemStyle.labelFontSize) {
+      tempSerie.label.fontSize = itemStyle.labelFontSize;
+    }
+    if (itemStyle.labelColor) {
+      tempSerie.label.color = itemStyle.labelColor;
+    }
+    if (itemStyle.labelWeight) {
+      tempSerie.label.fontWeight = itemStyle.labelWeight;
+    }
+    if (itemStyle.labelAngle) {
+      tempSerie.label.rotate = itemStyle.labelAngle;
+    }
+    if (itemStyle.labelLeft || itemStyle.labelTop) {
+      const offset = [0, 0];
+      if (itemStyle.labelLeft && !isNaN(itemStyle.labelLeft)) {
+        offset[0] = parseFloat(itemStyle.labelLeft);
+      }
+      if (itemStyle.labelTop && !isNaN(itemStyle.labelTop)) {
+        offset[1] = parseFloat(itemStyle.labelTop);
+      }
+      tempSerie.label.offset = offset;
+    } else {
+      tempSerie.label.offset = [0, 0];
+    }
+    if (itemStyle.labelNumFormat && itemStyle.labelNumFormat.length > 0) {
+      tempSerie.label.formatter = getNumFormatter(
+        itemStyle.labelNumFormat,
+        itemStyle.labelNumPrecision,
+        itemStyle.labelNumPrefix,
+        itemStyle.labelNumAppend,
+        false
+      );
+    } else if (itemStyle.labelFormatter) {
+      tempSerie.label.formatter = itemStyle.labelFormatter;
+    }
+  }
+  const customAttrJson = convertStrToJson(itemStyle.customAttr);
+  if (customAttrJson) {
+    Object.assign(tempSerie, customAttrJson);
+  }
+  if (!itemProps.testitems) {
+    let tempDatas = [];
+    const min = 0, max = 10;
+    for (let i = 0; i < 8; i++) {
+      const newMin = Math.ceil(min);
+      const newMax = Math.floor(max);
+      tempDatas.push(Math.floor(Math.random() * (newMax - newMin + 1)) + newMin);
+    }
+    itemProps.testitems = tempDatas.join(",");
+  }
+  if (!itemProps.testdatas) {
+    const min = 0, max = 100;
+    let tempDatas = [];
+    for (let i = 0; i < 8; i++) {
+      const newMin = Math.ceil(min);
+      const newMax = Math.floor(max);
+      tempDatas.push(Math.floor(Math.random() * (newMax - newMin + 1)) + newMin);
+    }
+    itemProps.testdatas = tempDatas.join(",");
+  }
+  const testItems = itemProps.testitems.split(",");
+  const testdatas = itemProps.testitems.split(",");
+  const seriesDatas = [];
+  for (let index = 0; index < testItems.length && index < testdatas.length; index++) {
+    const itemData = parseFloat(testItems[index]);
+    const numData = parseFloat(testdatas[index]);
+    if (isNaN(itemData) || isNaN(numData)) {
+      continue;
+    }
+    const data = [itemData, numData];
+    seriesDatas.push(data);
+  }
+  tempSerie.data = seriesDatas;
+  return tempSerie;
+}
+function generateBarSeriesJson(tempSerie, serieConfigure) {
+  const itemStyle = serieConfigure.style ? serieConfigure.style : {};
+  if (itemStyle.barWidth) {
+    tempSerie.barWidth = itemStyle.barWidth;
+  }
+  if (itemStyle.barWidth) {
+    tempSerie.barWidth = itemStyle.barWidth;
+  }
+  if (itemStyle.minWidth) {
+    tempSerie.barMinWidth = itemStyle.minWidth;
+  }
+  if (itemStyle.maxWidth) {
+    tempSerie.barMaxWidth = itemStyle.maxWidth;
+  }
+  if (itemStyle.color) {
+    tempSerie.itemStyle.color = itemStyle.color;
+  }
+  if (itemStyle.opacity) {
+    tempSerie.itemStyle.opacity = itemStyle.opacity;
+  }
+  if (itemStyle.barBackgroundColor) {
+    tempSerie.showBackground = true;
+    if (!tempSerie.backgroundStyle) {
+      tempSerie.backgroundStyle = {};
+    }
+    tempSerie.backgroundStyle.color = itemStyle.barBackgroundColor;
+  }
+  if (itemStyle.borderColor) {
+    tempSerie.itemStyle.borderColor = itemStyle.borderColor;
+    if (itemStyle.borderWidth) {
+      tempSerie.itemStyle.borderWidth = itemStyle.borderWidth;
+    }
+    if (itemStyle.borderLineType) {
+      tempSerie.itemStyle.borderType = itemStyle.borderLineType;
+    }
+    if (itemStyle.borderRadius) {
+      tempSerie.itemStyle.borderRadius = itemStyle.borderRadius;
+    }
+  }
+  if (itemStyle.shadowColor) {
+    tempSerie.itemStyle.shadowColor = itemStyle.shadowColor;
+    if (itemStyle.borderRadius) {
+      tempSerie.itemStyle.borderColor = itemStyle.borderRadius;
+    }
+    if (itemStyle.shadowBlur) {
+      tempSerie.itemStyle.shadowBlur = itemStyle.shadowBlur;
+    }
+    if (itemStyle.shadowX) {
+      tempSerie.itemStyle.shadowOffsetX = itemStyle.shadowX;
+    }
+    if (itemStyle.shadowY) {
+      tempSerie.itemStyle.shadowOffsetY = itemStyle.shadowY;
+    }
+  }
+}
+function generateLineSeriesJson(tempSerie, serieConfigure) {
+  const itemStyle = serieConfigure.style ? serieConfigure.style : {};
+  tempSerie.smooth = itemStyle.isSmooth;
+  if (tempSerie.itemStyle == void 0) {
+    tempSerie.itemStyle = {};
+  }
+  if (itemStyle.color) {
+    tempSerie.itemStyle.color = itemStyle.color;
+  }
+  if (itemStyle.opacity) {
+    tempSerie.lineStyle.opacity = itemStyle.opacity;
+  }
+  if (itemStyle.lineType) {
+    tempSerie.lineStyle.type = itemStyle.lineType;
+  }
+  if (itemStyle.lineWidth > 0) {
+    tempSerie.lineStyle.width = itemStyle.lineWidth;
+  }
+  if (itemStyle.shadowColor) {
+    tempSerie.lineStyle.shadowColor = itemStyle.shadowColor;
+    if (itemStyle.shadowBlur) {
+      tempSerie.lineStyle.shadowBlur = itemStyle.shadowBlur;
+    }
+    if (itemStyle.shadowX) {
+      tempSerie.lineStyle.shadowOffsetX = itemStyle.shadowX;
+    }
+    if (itemStyle.shadowY) {
+      tempSerie.lineStyle.shadowOffsetY = itemStyle.shadowY;
+    }
+  }
+  if (itemStyle.symbol) {
+    tempSerie.symbol = itemStyle.symbol;
+  }
+  if (itemStyle.symbolSize > -1) {
+    tempSerie.symbolSize = itemStyle.symbolSize;
+  }
+  if (itemStyle.enableAreaColor) {
+    tempSerie.areaStyle = {};
+    if (itemStyle.areaColor) {
+      tempSerie.areaStyle.color = itemStyle.areaColor;
+    }
+    if (itemStyle.areaOrigin) {
+      tempSerie.areaStyle.origin = itemStyle.areaOrigin;
+    }
+    if (itemStyle.areaOpacity) {
+      tempSerie.areaStyle.opacity = itemStyle.areaOpacity;
+    }
+    if (itemStyle.areaShadowColor) {
+      tempSerie.areaStyle.shadowColor = itemStyle.areaShadowColor;
+      if (itemStyle.areaShadowBlur > -1) {
+        tempSerie.areaStyle.shadowBlur = itemStyle.areaShadowBlur;
+      }
+      if (itemStyle.areaShadowX > -1) {
+        tempSerie.areaStyle.shadowOffsetX = itemStyle.areaShadowX;
+      }
+      if (itemStyle.areaShadowY > -1) {
+        tempSerie.areaStyle.shadowOffsetY = itemStyle.areaShadowY;
+      }
+    }
+  }
+}
+function generatePieSeriesJson(tempSerie, serieConfigure) {
+  const itemStyle = serieConfigure.style ? serieConfigure.style : {};
+  if (itemStyle.roseType) {
+    tempSerie.roseType = itemStyle.roseType;
+  }
+  if (itemStyle.centerLeft || itemStyle.centerTop) {
+    tempSerie.center = [
+      itemStyle.centerLeft ? itemStyle.centerLeft : "50%",
+      itemStyle.centerTop ? itemStyle.centerTop : "50%"
+    ];
+  }
+  if (itemStyle.radiusInner || itemStyle.radiusOuter) {
+    tempSerie.radius = [
+      itemStyle.radiusInner ? itemStyle.radiusInner : "0%",
+      itemStyle.radiusOuter ? itemStyle.radiusOuter : "75%"
+    ];
+  }
+  if (itemStyle.padAngle) {
+    tempSerie.padAngle = itemStyle.padAngle;
+  }
+  if (itemStyle.opacity) {
+    tempSerie.itemStyle.opacity = itemStyle.opacity;
+  }
+  if (itemStyle.barBackgroundColor) {
+    tempSerie.showBackground = true;
+    if (!tempSerie.backgroundStyle) {
+      tempSerie.backgroundStyle = {};
+    }
+    tempSerie.backgroundStyle.color = itemStyle.barBackgroundColor;
+  }
+  if (itemStyle.borderColor) {
+    tempSerie.itemStyle.borderColor = itemStyle.borderColor;
+    if (itemStyle.borderWidth) {
+      tempSerie.itemStyle.borderWidth = itemStyle.borderWidth;
+    }
+    if (itemStyle.borderLineType) {
+      tempSerie.itemStyle.borderType = itemStyle.borderLineType;
+    }
+    if (itemStyle.borderRadius) {
+      tempSerie.itemStyle.borderRadius = itemStyle.borderRadius;
+    }
+  }
+  if (itemStyle.shadowColor) {
+    tempSerie.itemStyle.shadowColor = itemStyle.shadowColor;
+    if (itemStyle.borderRadius) {
+      tempSerie.itemStyle.borderColor = itemStyle.borderRadius;
+    }
+    if (itemStyle.shadowBlur) {
+      tempSerie.itemStyle.shadowBlur = itemStyle.shadowBlur;
+    }
+    if (itemStyle.shadowX) {
+      tempSerie.itemStyle.shadowOffsetX = itemStyle.shadowX;
+    }
+    if (itemStyle.shadowY) {
+      tempSerie.itemStyle.shadowOffsetY = itemStyle.shadowY;
+    }
+  }
+}
+function generateGaugeSeriesJson(tempSerie, serieConfigure) {
+  const itemStyle = serieConfigure.style ? serieConfigure.style : {};
+  if (itemStyle.min || itemStyle.min == "0") {
+    tempSerie.min = itemStyle.min;
+  }
+  if (itemStyle.max) {
+    tempSerie.max = itemStyle.max;
+  }
+  if (itemStyle.centerLeft || itemStyle.centerTop) {
+    const centerStrs = ["50%", "50%"];
+    if (itemStyle.centerLeft) {
+      centerStrs[0] = itemStyle.centerLeft;
+    }
+    if (itemStyle.centerTop) {
+      centerStrs[1] = itemStyle.centerTop;
+    }
+    tempSerie.center = centerStrs;
+  }
+  if (itemStyle.radiusOuter) {
+    tempSerie.radius = itemStyle.radiusOuter;
+  }
+  if (itemStyle.splitNumber) {
+    tempSerie.splitNumber = itemStyle.splitNumber;
+  }
+  if (itemStyle.startAngle) {
+    tempSerie.startAngle = itemStyle.startAngle;
+  }
+  if (itemStyle.endAngle) {
+    tempSerie.endAngle = itemStyle.endAngle;
+  }
+  if (itemStyle.enableDetail != void 0) {
+    if (tempSerie.detail == void 0) {
+      tempSerie.detail = {};
+    }
+    tempSerie.detail.show = itemStyle.enableDetail;
+    if (itemStyle.enableDetail) {
+      if (itemStyle.detailColor) {
+        tempSerie.detail.color = itemStyle.detailColor;
+      }
+      if (itemStyle.detailFontSize) {
+        tempSerie.detail.fontSize = itemStyle.detailFontSize;
+      }
+      if (itemStyle.detailWeight) {
+        tempSerie.detail.fontWeight = itemStyle.detailWeight;
+      }
+      if (itemStyle.detailLeft || itemStyle.detailTop) {
+        const centerStrs = ["0", "40%"];
+        if (itemStyle.detailLeft) {
+          centerStrs[0] = itemStyle.detailLeft;
+        }
+        if (itemStyle.detailTop) {
+          centerStrs[1] = itemStyle.detailTop;
+        }
+        tempSerie.detail.offsetCenter = centerStrs;
+      }
+      if (itemStyle.detailFormatter) {
+        tempSerie.detail.formatter = itemStyle.detailFormatter;
+      }
+    }
+  }
+  if (itemStyle.enableAxis != void 0) {
+    if (tempSerie.axisLine == void 0) {
+      tempSerie.axisLine = {};
+    }
+    tempSerie.axisLine.show = itemStyle.enableAxis;
+    if (itemStyle.enableAxis) {
+      if (tempSerie.axisLine.lineStyle == void 0) {
+        tempSerie.axisLine.lineStyle = {};
+      }
+      if (itemStyle.axisColor) {
+        tempSerie.axisLine.lineStyle.color = [[1, itemStyle.axisColor]];
+      }
+      if (itemStyle.axisOpacity) {
+        tempSerie.axisLine.lineStyle.opacity = itemStyle.axisOpacity;
+      }
+      if (itemStyle.axisWidth || itemStyle.axisWidth == "0") {
+        tempSerie.axisLine.lineStyle.width = itemStyle.axisWidth;
+      }
+    }
+  }
+  if (itemStyle.enableSplit != void 0) {
+    if (tempSerie.splitLine == void 0) {
+      tempSerie.splitLine = {};
+    }
+    tempSerie.splitLine.show = itemStyle.enableSplit;
+    if (itemStyle.enableSplit) {
+      if (tempSerie.splitLine.lineStyle == void 0) {
+        tempSerie.splitLine.lineStyle = {};
+      }
+      if (itemStyle.splitColor) {
+        tempSerie.splitLine.lineStyle.color = itemStyle.splitColor;
+      }
+      if (itemStyle.splitOpacity) {
+        tempSerie.splitLine.lineStyle.opacity = itemStyle.splitOpacity;
+      }
+      if (itemStyle.splitWidth || itemStyle.splitWidth == "0") {
+        tempSerie.splitLine.lineStyle.width = itemStyle.splitWidth;
+      }
+      if (itemStyle.splitLength || itemStyle.splitLength == "0") {
+        tempSerie.splitLine.length = itemStyle.splitLength;
+      }
+      if (itemStyle.splitLineType) {
+        tempSerie.splitLine.lineStyle.type = itemStyle.splitLineType;
+      }
+      if (itemStyle.splitDistance || itemStyle.splitDistance == "0") {
+        tempSerie.splitLine.distance = itemStyle.splitDistance;
+      }
+    }
+  }
+  if (itemStyle.enableAxistick != void 0) {
+    if (tempSerie.axisTick == void 0) {
+      tempSerie.axisTick = {};
+    }
+    tempSerie.axisTick.show = itemStyle.enableAxistick;
+    if (itemStyle.enableAxistick) {
+      if (itemStyle.axistickNum || itemStyle.axistickNum == "0") {
+        tempSerie.axisTick.splitNumber = itemStyle.axistickNum;
+      }
+      if (tempSerie.axisTick.lineStyle == void 0) {
+        tempSerie.axisTick.lineStyle = {};
+      }
+      if (itemStyle.axistickColor) {
+        tempSerie.axisTick.lineStyle.color = itemStyle.axistickColor;
+      }
+      if (itemStyle.axistickOpacity) {
+        tempSerie.axisTick.lineStyle.opacity = itemStyle.axistickOpacity;
+      }
+      if (itemStyle.axistickWidth || itemStyle.axistickWidth == "0") {
+        tempSerie.axisTick.lineStyle.width = itemStyle.axistickWidth;
+      }
+      if (itemStyle.axistickLength || itemStyle.axistickLength == "0") {
+        tempSerie.axisTick.length = itemStyle.axistickLength;
+      }
+      if (itemStyle.axistickDistance || itemStyle.axistickDistance == "0") {
+        tempSerie.axisTick.distance = itemStyle.axistickDistance;
+      }
+    }
+  }
+  if (itemStyle.enableAxisLabel != void 0) {
+    if (tempSerie.axisLabel == void 0) {
+      tempSerie.axisLabel = {};
+    }
+    tempSerie.axisLabel.show = itemStyle.enableAxisLabel;
+    if (itemStyle.enableAxisLabel) {
+      if (itemStyle.axisLabelDistance || itemStyle.axisLabelDistance == "0") {
+        tempSerie.axisLabel.distance = itemStyle.axisLabelDistance;
+      }
+      if (itemStyle.axisLabelFontSize) {
+        tempSerie.axisLabel.fontSize = itemStyle.axisLabelFontSize;
+      }
+      if (itemStyle.axisLabelColor) {
+        tempSerie.axisLabel.color = itemStyle.axisLabelColor;
+      }
+      if (itemStyle.axisLabelWeight) {
+        tempSerie.axisLabel.fontWeight = itemStyle.axisLabelWeight;
+      }
+      if (itemStyle.axisLabelAngle || itemStyle.axisLabelAngle == "0") {
+        tempSerie.axisLabel.rotate = itemStyle.axisLabelAngle;
+      }
+      if (itemStyle.axisLabelFormatter) {
+        tempSerie.axisLabel.formatter = itemStyle.axisLabelFormatter;
+      }
+    }
+  }
+  if (itemStyle.enablePointer != void 0) {
+    if (tempSerie.pointer == void 0) {
+      tempSerie.pointer = {};
+    }
+    tempSerie.pointer.show = itemStyle.enablePointer;
+    if (itemStyle.enablePointer) {
+      if (itemStyle.pointerIcon) {
+        tempSerie.pointer.icon = itemStyle.pointerIcon;
+      }
+      if (itemStyle.pointerWidth || itemStyle.pointerWidth == "0") {
+        tempSerie.pointer.width = itemStyle.pointerWidth;
+      }
+      if (itemStyle.pointerLength || itemStyle.pointerLength == "0") {
+        tempSerie.pointer.length = itemStyle.pointerLength;
+      }
+      if (itemStyle.pointerColor) {
+        if (tempSerie.pointer.itemStyle == void 0) {
+          tempSerie.pointer.itemStyle = {};
+        }
+        tempSerie.pointer.itemStyle.color = itemStyle.pointerColor;
+      }
+      if (itemStyle.pointerLeft || itemStyle.pointerTop) {
+        const centerStrs = [0, 0];
+        if (itemStyle.pointerLeft) {
+          centerStrs[0] = itemStyle.pointerLeft;
+        }
+        if (itemStyle.pointerTop) {
+          centerStrs[1] = itemStyle.pointerTop;
+        }
+        tempSerie.pointer.offsetCenter = centerStrs;
+      }
+    }
+  }
+  if (itemStyle.enableAnchor != void 0) {
+    if (tempSerie.anchor == void 0) {
+      tempSerie.anchor = {};
+    }
+    tempSerie.anchor.show = itemStyle.enableAnchor;
+    if (itemStyle.enablePointer) {
+      if (itemStyle.anchorColor) {
+        if (tempSerie.anchor.itemStyle == void 0) {
+          tempSerie.anchor.itemStyle = {};
+        }
+        tempSerie.anchor.itemStyle.color = itemStyle.anchorColor;
+      }
+      if (itemStyle.anchorSize || itemStyle.anchorSize == "0") {
+        tempSerie.anchor.size = itemStyle.anchorSize;
+      }
+      if (itemStyle.anchorMark) {
+        tempSerie.anchor.icon = itemStyle.anchorMark;
+      }
+      if (itemStyle.anchorLeft || itemStyle.anchorTop) {
+        const centerStrs = [0, 0];
+        if (itemStyle.anchorLeft) {
+          centerStrs[0] = itemStyle.anchorLeft;
+        }
+        if (itemStyle.anchorTop) {
+          centerStrs[1] = itemStyle.anchorTop;
+        }
+        tempSerie.anchor.offsetCenter = centerStrs;
+      }
+    }
+  }
+}
+function generateGaugeTitleJson(itemStyle) {
+  const titleJson = {
+    show: itemStyle.enableGaugeTitle
+  };
+  if (itemStyle.gaugeTitleColor) {
+    titleJson.color = itemStyle.gaugeTitleColor;
+  }
+  if (itemStyle.gaugeTitleFontSize) {
+    titleJson.fontSize = itemStyle.gaugeTitleFontSize;
+  }
+  if (itemStyle.gaugeTitleFontWeight) {
+    titleJson.fontWeight = itemStyle.gaugeTitleFontWeight;
+  }
+  if (itemStyle.gaugeTitleTop || itemStyle.gaugeTitleLeft) {
+    const centerStrs = [0, "20%"];
+    if (itemStyle.gaugeTitleLeft) {
+      centerStrs[0] = itemStyle.gaugeTitleLeft;
+    }
+    if (itemStyle.gaugeTitleTop) {
+      centerStrs[1] = itemStyle.gaugeTitleTop;
+    }
+    titleJson.offsetCenter = centerStrs;
+  }
+  return titleJson;
+}
+function getNumFormatter(labelNumFormat, numPrecision, numPrefix, numAppend, isValueFormatter) {
+  const func = function(params) {
+    let labelValue = params.value;
+    if (isValueFormatter) {
+      labelValue = params;
+    }
+    if (labelValue == void 0 || labelValue == null) {
+      return labelValue;
+    }
+    if (Array.isArray(labelValue)) {
+      console.log("numformatter is array", labelValue);
+      return labelValue;
+    }
+    if (isNaN(labelValue) || !labelNumFormat || !labelNumFormat.indexOf) {
+      return labelValue;
+    }
+    if (labelNumFormat.indexOf("precision") > -1) {
+      let precision = parseInt(numPrecision);
+      if (precision == null || isNaN(precision)) {
+        precision = 2;
+      }
+      labelValue = parseFloat(parseFloat(labelValue).toFixed(precision));
+    }
+    let prefix = "";
+    if (labelNumFormat.indexOf("prefix") > -1 && numPrefix) {
+      prefix = numPrefix;
+    }
+    let append = "";
+    if (labelNumFormat.indexOf("append") > -1 && numAppend) {
+      append = numAppend;
+    }
+    return prefix + labelValue.toLocaleString() + append;
+  };
+  return func;
+}
+function convertStrToJson(convertStr) {
+  if (convertStr) {
+    if (convertStr.trim) {
+      convertStr = convertStr.trim();
+    }
+    if (convertStr.indexOf && convertStr.indexOf("{") != 0) {
+      convertStr = "{" + convertStr + "}";
+    }
+    try {
+      return JSON.parse(convertStr);
+    } catch (ex) {
+      console.log("转换自定义的配置参数报错", convertStr, ex);
+    }
+  }
+  return null;
+}
+export {
+  generateChartHeader,
+  generateChartOption
+};