module.exports =
/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ 		}
/******/ 	};
/******/
/******/ 	// define __esModule on exports
/******/ 	__webpack_require__.r = function(exports) {
/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 		}
/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
/******/ 	};
/******/
/******/ 	// create a fake namespace object
/******/ 	// mode & 1: value is a module id, require it
/******/ 	// mode & 2: merge all properties of value into the ns
/******/ 	// mode & 4: return value when already ns object
/******/ 	// mode & 8|1: behave like require
/******/ 	__webpack_require__.t = function(value, mode) {
/******/ 		if(mode & 1) value = __webpack_require__(value);
/******/ 		if(mode & 8) return value;
/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ 		var ns = Object.create(null);
/******/ 		__webpack_require__.r(ns);
/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ 		return ns;
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "lib/mapboxgl/";
/******/
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 900);
/******/ })
/************************************************************************/
/******/ ({

/***/ 0:
/***/ (function(module, exports) {

module.exports = require("@babel/runtime/helpers/interopRequireDefault");

/***/ }),

/***/ 119:
/***/ (function(module, exports) {

module.exports = require("lodash.max");

/***/ }),

/***/ 12:
/***/ (function(module, exports) {

module.exports = require("@supermap/vue-iclient-mapboxgl/lib/_utils/util.js");

/***/ }),

/***/ 120:
/***/ (function(module, exports) {

module.exports = require("@supermap/vue-iclient-mapboxgl/lib/_utils/statistics.js");

/***/ }),

/***/ 18:
/***/ (function(module, exports) {

module.exports = require("@babel/runtime/helpers/extends");

/***/ }),

/***/ 400:
/***/ (function(module, exports) {

module.exports = require("@supermap/vue-iclient-mapboxgl/lib/_utils/get-features.js");

/***/ }),

/***/ 900:
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var _interopRequireDefault = __webpack_require__(0);
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
exports.sortData = sortData;
exports.tranformSingleToMulti = tranformSingleToMulti;
var _extends2 = _interopRequireDefault(__webpack_require__(18));
var _getFeatures = _interopRequireDefault(__webpack_require__(400));
var _lodash = _interopRequireDefault(__webpack_require__(901));
var _lodash2 = _interopRequireDefault(__webpack_require__(119));
var _lodash3 = _interopRequireDefault(__webpack_require__(902));
var _util = __webpack_require__(12);
var _statistics = __webpack_require__(120);
// 三方服务请求的结果为单对象的时候，是否要转成多个features
function tranformSingleToMulti(data) {
  var dataInfo = (data.features[0] || {}).properties;
  if (dataInfo) {
    data.features = Object.entries(dataInfo).map(function (_ref) {
      var key = _ref[0],
        value = _ref[1];
      return {
        properties: {
          label: key,
          value: value
        }
      };
    });
    return Object.assign(data, (0, _statistics.statisticsFeatures)(data.features));
  }
  return data;
}
function sortData(features, datasetOptions, maxFeatures, xBar) {
  var matchItem = datasetOptions.find(function (item) {
    return item.sort && item.sort !== 'unsort';
  });
  var nextFeatures = [].concat(features);
  if (matchItem) {
    nextFeatures = (0, _lodash3.default)(features, function (feature) {
      return isNaN(+feature.properties[matchItem.yField]) ? -Number.MAX_VALUE : +feature.properties[matchItem.yField];
    }, matchItem.sort === 'ascending' ? 'asc' : 'desc');
  }
  var maxLen = +maxFeatures;
  if (maxLen && nextFeatures.length > maxLen) {
    nextFeatures.length = maxLen;
  }
  matchItem && xBar && nextFeatures.reverse();
  return nextFeatures;
}

/**
 * @class EchartsDataService
 * @classdesc 图表组件功能类
 * @param {Chart-dataset} dataset - 请求的参数
 * @param {Array.<Chart-datasetOption>} datasetOptions - 数据解析的配置。
 */

/**
 * @typedef {Object} Chart-dataset  - 数据来源
 * @property {string} [type = 'iServer'] - 服务类型 iServer, iPortal。
 * @property {string} url - 服务url地址。
 * @property {boolean} [withCredentials = false] - 设置请求是否带cookie
 * @property {SuperMap.FilterParameter} queryInfo - 查询条件
 */
/**
 * @typedef {Object} Chart-datasetOption  - 解析数据的配置
 * @property {string} seriesType - 图表类型line, bar, scatter, pie, radar, gauge。
 * @property {boolean} [isStastic = false] - 是否统计数据。
 * @property {boolean} [isStack = false] - 图表（line, bar, scatter）是否堆叠
 * @property {string} xField - 数据的字段，坐标值
 * @property {string} yField - 数据的字段，数据值
 */
var EchartsDataService = exports.default = /*#__PURE__*/function () {
  function EchartsDataService(dataset, datasetOptions) {
    // 设置默认值
    dataset.withCredentials = dataset.withCredentials || false; // 请求认证
    this.dataset = dataset;
    this.datasetOptions = datasetOptions;
    this.dataCache = null; // 缓存的是请求后的数据
    this.sortDataCache = null;
    this.axisDatas = []; // 坐标data
    this.serieDatas = []; // series data
    this.gridAxis = {
      xAxis: [],
      yAxis: {}
    }; // 直角坐标系
    this.radarAxis = {}; // 雷达图坐标系
    this.radarMax = 0; // 雷达图坐标最大值
  }

  /**
   * @function EchartsDataService.prototype.getDataOption
   * @description 获取符合echart data数据格式的数据, 入口函数。
   * @returns {Object}  带有请求的数据的promise对象
   */
  var _proto = EchartsDataService.prototype;
  _proto.getDataOption = function getDataOption(dataset, xBar) {
    var _this = this;
    if (xBar === void 0) {
      xBar = false;
    }
    // 设置datasets的默认配置type，withCredentials
    var promise = new Promise(function (resolve, reject) {
      // 请求数据，请求成功后，解析数据
      var matchItem = _this.datasetOptions.find(function (item) {
        return item.sort !== 'unsort';
      });
      var maxFeatures = matchItem ? '' : dataset.maxFeatures;
      (0, _getFeatures.default)((0, _extends2.default)({}, dataset, {
        maxFeatures: maxFeatures
      })).then(function (data) {
        // 兼容三方服务接口返回的一个普通的对象
        if (data.transformed && !!data.features.length) {
          data = tranformSingleToMulti(data);
        }
        // 解析数据，生成dataOption
        var options;
        if (_this.dataset.type === 'iPortal' || _this.dataset.type === 'iServer' || _this.dataset.type === 'rest' || _this.dataset.type === 'geoJSON') {
          options = _this.formatChartData(_this.datasetOptions, xBar, data);
        }
        resolve(options);
      }).catch(function (e) {
        reject(e);
      });
    });
    return promise;
  }

  /**
   * @function EchartsDataService.prototype.formatChartData
   * @description _requestData方法中返回的数据: 设置数据，转换数据格式。
   * @param {Object} data - 从superMap的iserver,iportal中请求返回的数据
   * @param {Object} datasetOptions - 数据解析的配置参数
   * @returns {Object}  符合echart格式的数据
   */;
  _proto.formatChartData = function formatChartData(datasetOptions, xBar, data) {
    var _this2 = this;
    if (xBar === void 0) {
      xBar = false;
    }
    if (data === void 0) {
      data = this.dataCache;
    }
    // 清除数据缓存
    this._clearChartCache();
    // 设置datasetOptions
    this.setDatasetOptions(datasetOptions);
    // 设置this.data
    data = this._setData(data, xBar);
    // 生成seriedata
    datasetOptions.forEach(function (item) {
      // 生成YData, XData
      var fieldData = _this2._fieldsData(data, item, xBar);
      // 解析YData, XData，生成EchartsOption的data
      var serieData = _this2._createDataOption(fieldData, item);
      // 设置坐标
      _this2._createAxisData(fieldData, item);
      if (!serieData.tooltip) {
        serieData.tooltip = _this2._fixToolTip(data, item);
      }
      _this2.serieDatas.push(serieData);
    });
    var gridAxis = (this.gridAxis.xAxis.length > 0 || JSON.stringify(this.gridAxis.yAxis) !== '{}') && this.gridAxis;
    var radarAxis = this.radarAxis;
    var series = this.serieDatas;
    return (0, _extends2.default)({}, gridAxis, radarAxis, {
      series: series
    });
  }

  /**
   * @function EchartsDataService.prototype.setDatasetOptions
   * @private
   * @description 设置datasetOptions
   * @param {Array.<Chart-datasetOption>} datasetOptions - 数据解析的配置
   */;
  _proto.setDatasetOptions = function setDatasetOptions(datasetOptions) {
    this.datasetOptions = datasetOptions;
  }

  /**
   * @function EchartsDataService.prototype._setData
   * @private
   * @description 给实例绑定data。
   * @param {Object} data - 从superMap的iserver,iportal中请求返回的数据
   */;
  _proto._setData = function _setData(data, xBar) {
    var nextData = data;
    if (data) {
      var nextFeatures = (0, _util.filterInvalidData)(this.datasetOptions, data.features);
      // 只过滤空数据但不排序的原数据
      this.dataCache = (0, _statistics.statisticsFeatures)(nextFeatures);
      nextFeatures = sortData(nextFeatures, this.datasetOptions, this.dataset.maxFeatures, xBar);
      nextData = (0, _statistics.statisticsFeatures)(nextFeatures);
      this.sortDataCache = nextData;
    }
    return nextData;
  }

  /**
   * @function EchartsDataService.prototype._clearChartCache
   * @private
   * @description 清除已经生成的chart数据的缓存。
   */;
  _proto._clearChartCache = function _clearChartCache() {
    this.axisDatas = []; // 坐标data
    this.serieDatas = []; // series data
    this.gridAxis = {
      xAxis: [],
      yAxis: {}
    }; // 直角坐标系
  }

  /**
   * @function EchartsDataService.prototype._createSeriesData
   * @private
   * @description 生成chart的serie。
   * @param {Object} fieldData - 解析后的数据{xData,yData}
   * @param {Chart-datasetOption} datasetOption - 数据解析的配置
   * @returns {Object}  配置好的serieData
   */;
  _proto._createDataOption = function _createDataOption(fieldData, datasetOption) {
    var chartType = datasetOption.seriesType;
    var XData = fieldData.xData;
    var YData = fieldData.yData;
    var serieData = {
      type: chartType,
      name: datasetOption.yField,
      data: []
    };
    if (chartType === 'pie') {
      YData.forEach(function (value, index) {
        serieData.data.push({
          value: value,
          name: XData[index]
        });
      });
    } else if (chartType === 'radar') {
      var yData = [].concat(YData);
      serieData.data.push({
        value: [].concat(YData),
        name: datasetOption.yField
      });
      // 获取雷达图的max最大值
      var maxValue = (0, _lodash2.default)(yData);
      this.radarMax = Math.max(maxValue, this.radarMax);
    } else {
      // line bar scatter gauge
      serieData.data = [].concat(YData);
      // 是否堆叠数据（line,bar,scatter）
      if (datasetOption.isStack) {
        serieData.stack = 1;
      } else {
        serieData.stack = 0;
      }
    }
    return serieData;
  }

  /**
   * @function EchartsDataService.prototype._fixToolTip
   * @private
   * @description 调整tooltip显示，Todo 考虑支持用户自定义tooltip内容
   * @param {Object} data - 数据
   * @param {Chart-datasetOption} datasetOption - 数据解析的配置
   * @returns {Object}  tooltip
   */;
  _proto._fixToolTip = function _fixToolTip(data, datasetOption) {
    if (data.transformed) {
      if (datasetOption.seriesType === 'pie') {
        return {
          trigger: 'item',
          formatter: '{b} : {c} ({d}%)'
        };
      }
      return {
        trigger: 'item',
        formatter: '{b} : {c}'
      };
    }
    return null;
  }

  /**
   * @function EchartsDataService.prototype._createSeriesData
   * @private
   * @description 生成chart的serie。
   * @param {Object} fieldData - 解析后的数据{xData,yData}
   * @param {Chart-datasetOption} datasetOption - 数据解析的配置
   * @returns {Object}  配置好的坐标data
   */;
  _proto._createAxisData = function _createAxisData(fieldData, datasetOption) {
    var chartType = datasetOption.seriesType;
    var XData = fieldData.xData;
    var radarData = [];
    var axisData;
    if (chartType === 'radar' && XData) {
      var radarMax = this.radarMax;
      XData.forEach(function (text) {
        radarData.push({
          text: text,
          max: radarMax
        });
      });
      this.radarAxis = {
        radar: {
          indicator: radarData
        }
      };
      axisData = this.radarAxis;
    } else if (['bar', 'line', 'scatter', '2.5Bar'].find(function (item) {
      return item === chartType;
    })) {
      var data = XData && [].concat(XData);
      if (!this.gridAxis.xAxis) {
        this.gridAxis.xAxis = [];
        this.gridAxis.yAxis = {};
      }
      if (this.gridAxis.xAxis.length === 0) {
        this.gridAxis.xAxis.push({
          data: data
        });
      } else {
        this.gridAxis.xAxis[0] = {
          data: data
        };
      }
      axisData = this.gridAxis;
    } else {
      axisData = {};
    }
    return axisData;
  }

  /**
   * @function EchartsDataService.prototype._fieldsData
   * @private
   * @description 将请求回来的数据，转换成适用于chart配置的数据。
   * @param {Object} data - 从superMap的iserver,iportal中请求返回的数据
   * @param {Chart-datasetOption} datasetOption - 数据解析的配置
   * @returns {Object}  解析好的Ydata，xdata
   */;
  _proto._fieldsData = function _fieldsData(data, datasetOption) {
    var fieldCaptions, fieldValues, xFieldIndex, yFieldIndex, fieldValueIndex, xData, yData, result;
    var sort = datasetOption.sort,
      yField = datasetOption.yField,
      xField = datasetOption.xField,
      isStastic = datasetOption.isStastic;
    fieldCaptions = data.fieldCaptions; // 所有x字段
    xFieldIndex = fieldCaptions.indexOf(xField); // x字段的下标
    yFieldIndex = fieldCaptions.indexOf(yField); // y字段的下标
    fieldValues = yFieldIndex < 0 ? [] : data.fieldValues[yFieldIndex]; // y字段的所有feature值
    // 该数据是否需要统计,统计的是数组下标
    if (isStastic) {
      fieldValueIndex = this._getUniqFieldDatas(data, xFieldIndex, sort);
      // 生成统计后的数据
      xData = this._stasticXData(fieldValueIndex, sort);
      yData = this._stasticYData(fieldValues, fieldValueIndex, sort);
    } else {
      // 如果不是统计图表
      xData = this._getFieldDatas(data, xFieldIndex);
      yData = [].concat(fieldValues).map(function (item) {
        return (0, _lodash.default)(item);
      });
    }
    result = {
      xData: xData,
      yData: yData
    };
    return result;
  }

  /**
   * @function EchartsDataService.prototype._stasticXData
   * @private
   * @description 统计X字段数据，生成xData。
   * @param {Object} fieldValueIndex - x字段的统计索引
   * @returns {Array}  统计后的Xdata、
   */;
  _proto._stasticXData = function _stasticXData(fieldValueIndex) {
    var xData = Object.keys(fieldValueIndex);
    return xData;
  }

  /**
   * @function EchartsDataService.prototype._stasticYData
   * @private
   * @description 统计数据，生成yData。
   * @param {Object} fieldValues - y字段的所有feature值
   * @param {Object} fieldValueIndex - x字段的统计索引
   * @returns {Array}  统计后的Ydata、
   */;
  _proto._stasticYData = function _stasticYData(fieldValues, fieldValueIndex) {
    var yData = [];
    // 统计Y字段
    var _loop = function _loop() {
      var total = 0;
      fieldValueIndex[key].forEach(function (index) {
        // 清除字符串型的数字的逗号
        var num = fieldValues[index] && (0, _util.clearNumberComma)(fieldValues[index]);
        total += (0, _lodash.default)(num);
      });
      yData.push(total);
    };
    for (var key in fieldValueIndex) {
      _loop();
    }
    return yData;
  }

  /**
   * @function EchartsDataService.prototype._getUniqFieldDatas
   * @private
   * @description 获取x轴字段要统计的属性值
   * @param {Object} data - 从superMap的iserver,iportal中请求返回的数据的fieldValue
   * @param {String} fieldIndexs - x字段索引值数组
   * @returns {Object}  返回x轴字段要统计的属性值，返回值为eg:[fieldIndex：1, statiscIndex:{浇水地：[5,2,5,4], 林地：[5,2,5,4]...}]。
   */;
  _proto._getUniqFieldDatas = function _getUniqFieldDatas(data, fieldIndex) {
    var fieldValues = this._getFieldDatas(data, fieldIndex);
    var uniqFieldValues = {};
    if (fieldValues) {
      fieldValues.forEach(function (value, index) {
        if (!uniqFieldValues[value]) {
          uniqFieldValues[value] = [index];
        } else {
          uniqFieldValues[value].push(index);
        }
      });
    }
    return uniqFieldValues;
  }

  /**
   * @function EchartsDataService.prototype._getFieldDatas
   * @private
   * @description 。
   * @param {Object} data - 从superMap的iserver,iportal中请求返回的数据的fieldValue
   * @param {String} fieldIndex - x字段索引值
   * @returns {Array}  返回的是一个数组[林地， 旱地， 林地，沼泽，旱地...]
   */;
  _proto._getFieldDatas = function _getFieldDatas(data, fieldIndex) {
    // 获取x字段所有值，
    return data.fieldValues[fieldIndex];
  };
  return EchartsDataService;
}();

/***/ }),

/***/ 901:
/***/ (function(module, exports) {

module.exports = require("lodash.tonumber");

/***/ }),

/***/ 902:
/***/ (function(module, exports) {

module.exports = require("lodash.orderby");

/***/ })

/******/ });