/**
   * x축 rotate
   * @param chartOption
   * @param orient
   * @param categoryAxis
   * @param valueAxis
   * @returns {BaseOption}
   */
  public static convertXAxisRotate(chartOption: BaseOption, orient: Orient, categoryAxis, valueAxis): BaseOption {

    // orient 값이 없는경우 return
    if (_.isUndefined(orient)) return chartOption;

    // 데이터의 수치를 표현 축의 타입이 value인지 log인지 확인
    const subAxis: Axis[] = [];

    // 수치를 표현하던 축은 카테고리를 표현하는 축으로 변경
    valueAxis.map((axis, idx) => {
      if (_.eq(idx, 0)) {
        axis.type = AxisType.CATEGORY;
        axis.data = _.cloneDeep(categoryAxis[0].data);
      } else {
        // 보조축은 수치를 표현하는 축으로 이동
        subAxis.push(axis);
      }
    });

    if (_.eq(orient, Orient.VERTICAL)) chartOption.xAxis = [valueAxis[0]];
    if (!_.eq(orient, Orient.VERTICAL)) chartOption.yAxis = [valueAxis[0]];

    // 가로 모드일 경우에는 단위라벨 순서를 역으로 정렬
    if (_.eq(orient, Orient.VERTICAL)) delete chartOption.yAxis[0].inverse;
    else chartOption.yAxis[0].inverse = true;

    return chartOption;
  }

  /**
   * x축 가로/세로에 따라 축명 위치변경
   * @param chartOption
   * @param uiOption
   * @param axisType
   */
  public static convertXAxisRotateName(chartOption: BaseOption, uiOption: UIOption, fieldInfo: PivotTableInfo): BaseOption {

    // type이 없는경우 return
    if (!uiOption || _.isUndefined(uiOption['align'])) return chartOption;

    const axisList = _.compact(_.concat(uiOption.xAxis, uiOption.yAxis, uiOption.subAxis));
    const type = uiOption['align'];

    const yAxis = axisList.filter((item) => {
      return _.eq(item.mode, AxisLabelType.COLUMN) || _.eq(item.mode, AxisLabelType.SUBCOLUMN);
    });

    // 앞에서 category / value위치를 변경하였으므로 변경된 type에 따라서 위치변경
    let copiedOption = _.cloneDeep(chartOption);

    let yAxisType: AxisType;

    // default일때(세로모드, x축 category, y축 value)에는 변경하지않음
    if (_.eq(type, UIOrient.VERTICAL) && copiedOption.yAxis[0].type == AxisType.VALUE && copiedOption.xAxis[0].type == AxisType.CATEGORY) return chartOption;

    // 세로모드일때
    if (_.eq(type, UIOrient.VERTICAL)) {

      // y축이 value이면 => y축 값을 x축으로 넣기
      yAxisType = AxisType.VALUE;

    // 가로모드일때
    } else {
      // y축이 category이면 => y축 값을 x축으로 넣기
      yAxisType = AxisType.CATEGORY;
    }

    // Y축 명칭
    const yName = uiOption.yAxis.customName ? uiOption.yAxis.customName : _.join(fieldInfo.aggs, CHART_STRING_DELIMITER);
    const yAxisName = _.join(fieldInfo.aggs, CHART_STRING_DELIMITER);

    // y축이 yAxisType이면 => y축 값을 x축으로 넣기
    copiedOption.yAxis.forEach((axis, axisIndex) => {
      chartOption.xAxis.forEach((item, index) => {

        if (axis.type == yAxisType && copiedOption.yAxis[index].axisName) {
          item.axisName = yAxisName;

          // customName이 없을때
          if (!yAxis[axisIndex].customName && copiedOption.yAxis[index].name) {
            item.name = yName;
          }
        }
      });
    })

    return chartOption;
  }

 createPagePrevNext() {
   return [
     {
       key: 'PREV',
       active: _.eq(PAGE_MIN_INDEX, this.pageIndex),
       handler: () => this.toPrevPage,
     }, {
       key: 'NEXT',
       active: _.eq(this.maxIndex, this.pageIndex),
       handler: () => this.toNextPage,
     },
   ]
 }

 createPageFirstLast() {
   return [
     {
       key: 'FIRST',
       active: _.eq(PAGE_MIN_INDEX, this.pageIndex),
       handler: () => this.toFirstPage,
     }, {
       key: 'LAST',
       active: _.eq(this.maxIndex, this.pageIndex),
       handler: () => this.toLastPage,
     },
   ]
 }

    _.each(series, (option) => {

      // 적용
      if( _.isUndefined(option.label) ) { option.label = {normal: {}} }
      if( label.textAlign && label.displayTypes && _.filter(label.displayTypes).length >= 2 ) {
        // Rich를 만든다. 포메터에서 사용
        let color: string = '#FFF';
        // textColor가 있는경우
        if( label.textColor && label.textColor !== ' ') {
          color = label.textColor;

        // textColor가 없는경우
        } else {
          if( label.pos ) {
            if( _.eq(label.pos, DataLabelPosition.CENTER) || String(label.pos).indexOf("INSIDE") != -1 ) {
              color = "#FFF";
            }
            else {
              color = null;
            }
          }
        }

        option.label.normal.rich = {
          align: {
            align: String(label.textAlign).toLowerCase(),
            color: color
          }
        }
      }
      else {
        if (' ' == option.label.normal.color) delete option.label.normal.color;
        delete option.label.normal.rich;
      }
    });

  /**
   * 범례 show / hide 설정
   * @param option
   * @param uiOption
   */
  public static convertLegendShow(option: BaseOption, uiOption: UIOption): BaseOption {

    // auto값이 없는경우 return
    if (!uiOption.legend || _.isNull(uiOption.legend.auto) || _.isUndefined(uiOption.legend.auto)) return option;

    const show = uiOption.legend.auto;

    if (_.isUndefined(option.visualMap)) {
      option.legend.show = show;
    } else {
      option.visualMap.show = show;

      // 범례가 있는경우에만
      if (option.legend) {
        option.legend.show = false;
      }
    }

    // Grid가 존재하는 경우 범례 표시 여부에 따라 크기 변경
    if (!_.isUndefined(option.grid) && !_.isUndefined(option.dataZoom)) {
      const sliderZooms = option.dataZoom.filter((dataZoom) => {
        return _.eq(dataZoom.type, DataZoomType.SLIDER);
      });
      if (!_.isEmpty(sliderZooms)) {
        // 가로/세로 슬라이더가 모두 존재 할 경우
        _.gt(sliderZooms.length, 1) ? Orient.BOTH
          // 가로 혹은 세로 슬라이더중 1개만 존재 할 경우
          : _.eq(sliderZooms[0].orient, Orient.HORIZONTAL)
            ? Orient.VERTICAL
            : Orient.HORIZONTAL;
      }
    }

    return option;
  }

    series.map((obj) => {

      // area 타입 설정
      obj.areaStyle = _.eq(type, LineMarkType.AREA) ? OptionGenerator.AreaStyle.customAreaStyle(0.5) : undefined;

      // stack 설정
      let stackName: string = '';
      // 모드에 따라 스택명, 수치값 라벨 위치 변경
      if (_.eq(uiOption['mark'], BarMarkType.STACKED)) {
        // 시리즈명을 delimiter로 분리, 현재 시리즈의 측정값 필드명 추출
        stackName = _.last(_.split(obj.name, CHART_STRING_DELIMITER));
        obj.stack = _.isEmpty(fieldInfo.rows) ? 'measureStack' : stackName;
      } else {
        delete obj.stack;
      }

    });

 return sizeList.map(pair => {
   const [pageSize, label] = pair
   return {
     value: pageSize,
     label: label,
     active: _.eq(pageSize, this.pageSize),
     onChange: () => this.setPageSize(pageSize),
   }
 })

 function validateSentenceCase(input, lang?) {
     const isValid = _.isEmpty(input) || (_.isString(input) && _.eq(input, _.capitalize(input.toLowerCase())));
     if (!isValid) {
         warnings.push({
             text: input,
             lang
         });
     }
     return isValid;
 }