cione-comp-lib/es/node_modules/echarts/lib/chart/themeRiver/ThemeRiverSeries.mjs

`$ yarn add cione-comp-lib` 或者 `$ npm i cione-comp-lib -S`

import { __extends } from "../../../../tslib/tslib.es6.mjs";
import SeriesModel from "../../model/Series.mjs";
import prepareSeriesDataSchema from "../../data/helper/createDimensions.mjs";
import { getDimensionTypeByAxis } from "../../data/helper/dimensionHelper.mjs";
import SeriesData from "../../data/SeriesData.mjs";
import { bind, filter, createHashMap, isArray } from "../../../../zrender/lib/core/util.mjs";
import { groupData, SINGLE_REFERRING } from "../../util/model.mjs";
import LegendVisualProvider from "../../visual/LegendVisualProvider.mjs";
import { createTooltipMarkup } from "../../component/tooltip/tooltipMarkup.mjs";
var DATA_NAME_INDEX = 2;
var ThemeRiverSeriesModel = function(_super) {
  __extends(ThemeRiverSeriesModel2, _super);
  function ThemeRiverSeriesModel2() {
    var _this = _super !== null && _super.apply(this, arguments) || this;
    _this.type = ThemeRiverSeriesModel2.type;
    return _this;
  }
  ThemeRiverSeriesModel2.prototype.init = function(option) {
    _super.prototype.init.apply(this, arguments);
    this.legendVisualProvider = new LegendVisualProvider(bind(this.getData, this), bind(this.getRawData, this));
  };
  ThemeRiverSeriesModel2.prototype.fixData = function(data) {
    var rawDataLength = data.length;
    var timeValueKeys = {};
    var groupResult = groupData(data, function(item) {
      if (!timeValueKeys.hasOwnProperty(item[0] + "")) {
        timeValueKeys[item[0] + ""] = -1;
      }
      return item[2];
    });
    var layerData = [];
    groupResult.buckets.each(function(items, key) {
      layerData.push({
        name: key,
        dataList: items
      });
    });
    var layerNum = layerData.length;
    for (var k = 0; k < layerNum; ++k) {
      var name_1 = layerData[k].name;
      for (var j = 0; j < layerData[k].dataList.length; ++j) {
        var timeValue = layerData[k].dataList[j][0] + "";
        timeValueKeys[timeValue] = k;
      }
      for (var timeValue in timeValueKeys) {
        if (timeValueKeys.hasOwnProperty(timeValue) && timeValueKeys[timeValue] !== k) {
          timeValueKeys[timeValue] = k;
          data[rawDataLength] = [timeValue, 0, name_1];
          rawDataLength++;
        }
      }
    }
    return data;
  };
  ThemeRiverSeriesModel2.prototype.getInitialData = function(option, ecModel) {
    var singleAxisModel = this.getReferringComponents("singleAxis", SINGLE_REFERRING).models[0];
    var axisType = singleAxisModel.get("type");
    var filterData = filter(option.data, function(dataItem) {
      return dataItem[2] !== void 0;
    });
    var data = this.fixData(filterData || []);
    var nameList = [];
    var nameMap = this.nameMap = createHashMap();
    var count = 0;
    for (var i = 0; i < data.length; ++i) {
      nameList.push(data[i][DATA_NAME_INDEX]);
      if (!nameMap.get(data[i][DATA_NAME_INDEX])) {
        nameMap.set(data[i][DATA_NAME_INDEX], count);
        count++;
      }
    }
    var dimensions = prepareSeriesDataSchema(data, {
      coordDimensions: ["single"],
      dimensionsDefine: [{
        name: "time",
        type: getDimensionTypeByAxis(axisType)
      }, {
        name: "value",
        type: "float"
      }, {
        name: "name",
        type: "ordinal"
      }],
      encodeDefine: {
        single: 0,
        value: 1,
        itemName: 2
      }
    }).dimensions;
    var list = new SeriesData(dimensions, this);
    list.initData(data);
    return list;
  };
  ThemeRiverSeriesModel2.prototype.getLayerSeries = function() {
    var data = this.getData();
    var lenCount = data.count();
    var indexArr = [];
    for (var i = 0; i < lenCount; ++i) {
      indexArr[i] = i;
    }
    var timeDim = data.mapDimension("single");
    var groupResult = groupData(indexArr, function(index) {
      return data.get("name", index);
    });
    var layerSeries = [];
    groupResult.buckets.each(function(items, key) {
      items.sort(function(index1, index2) {
        return data.get(timeDim, index1) - data.get(timeDim, index2);
      });
      layerSeries.push({
        name: key,
        indices: items
      });
    });
    return layerSeries;
  };
  ThemeRiverSeriesModel2.prototype.getAxisTooltipData = function(dim, value, baseAxis) {
    if (!isArray(dim)) {
      dim = dim ? [dim] : [];
    }
    var data = this.getData();
    var layerSeries = this.getLayerSeries();
    var indices = [];
    var layerNum = layerSeries.length;
    var nestestValue;
    for (var i = 0; i < layerNum; ++i) {
      var minDist = Number.MAX_VALUE;
      var nearestIdx = -1;
      var pointNum = layerSeries[i].indices.length;
      for (var j = 0; j < pointNum; ++j) {
        var theValue = data.get(dim[0], layerSeries[i].indices[j]);
        var dist = Math.abs(theValue - value);
        if (dist <= minDist) {
          nestestValue = theValue;
          minDist = dist;
          nearestIdx = layerSeries[i].indices[j];
        }
      }
      indices.push(nearestIdx);
    }
    return {
      dataIndices: indices,
      nestestValue
    };
  };
  ThemeRiverSeriesModel2.prototype.formatTooltip = function(dataIndex, multipleSeries, dataType) {
    var data = this.getData();
    var name = data.getName(dataIndex);
    var value = data.get(data.mapDimension("value"), dataIndex);
    return createTooltipMarkup("nameValue", {
      name,
      value
    });
  };
  ThemeRiverSeriesModel2.type = "series.themeRiver";
  ThemeRiverSeriesModel2.dependencies = ["singleAxis"];
  ThemeRiverSeriesModel2.defaultOption = {
    z: 2,
    colorBy: "data",
    coordinateSystem: "singleAxis",
    boundaryGap: ["10%", "10%"],
    singleAxisIndex: 0,
    animationEasing: "linear",
    label: {
      margin: 4,
      show: true,
      position: "left",
      fontSize: 11
    },
    emphasis: {
      label: {
        show: true
      }
    }
  };
  return ThemeRiverSeriesModel2;
}(SeriesModel);
var ThemeRiverSeriesModel$1 = ThemeRiverSeriesModel;
export { ThemeRiverSeriesModel$1 as default };