908 lines
30 KiB
JavaScript
908 lines
30 KiB
JavaScript
|
import {
|
||
|
|
BE_ORDINAL,
|
||
|
|
CoordinateSystem_default,
|
||
|
|
CtorInt32Array,
|
||
|
|
DISPLAY_STATES,
|
||
|
|
Polyline_default,
|
||
|
|
SINGLE_REFERRING,
|
||
|
|
SOURCE_FORMAT_ORIGINAL,
|
||
|
|
SPECIAL_STATES,
|
||
|
|
SeriesDataSchema,
|
||
|
|
SeriesData_default,
|
||
|
|
SeriesDimensionDefine_default,
|
||
|
|
VISUAL_DIMENSIONS,
|
||
|
|
createDimNameMap,
|
||
|
|
createSourceFromSeriesDataOption,
|
||
|
|
enableDataStack,
|
||
|
|
ensureSourceDimNameMap,
|
||
|
|
getDataItemValue,
|
||
|
|
getDimensionTypeByAxis,
|
||
|
|
guessOrdinal,
|
||
|
|
isSourceInstance,
|
||
|
|
makeSeriesEncodeForAxisCoordSys,
|
||
|
|
normalizeToArray,
|
||
|
|
shouldOmitUnusedDimensions
|
||
|
|
} from "./chunk-P3HASGYV.js";
|
||
|
|
import {
|
||
|
|
PathProxy_default,
|
||
|
|
Path_default,
|
||
|
|
Point_default,
|
||
|
|
createHashMap,
|
||
|
|
cubicProjectPoint,
|
||
|
|
curry,
|
||
|
|
defaults,
|
||
|
|
dist,
|
||
|
|
each,
|
||
|
|
extend,
|
||
|
|
invert,
|
||
|
|
isArray,
|
||
|
|
isFunction,
|
||
|
|
isObject,
|
||
|
|
isString,
|
||
|
|
lerp,
|
||
|
|
map,
|
||
|
|
normalizeRadian,
|
||
|
|
quadraticProjectPoint,
|
||
|
|
retrieve,
|
||
|
|
retrieve2
|
||
|
|
} from "./chunk-57VLBA47.js";
|
||
|
|
|
||
|
|
// node_modules/echarts/lib/data/helper/createDimensions.js
|
||
|
|
function createDimensions(source, opt) {
|
||
|
|
return prepareSeriesDataSchema(source, opt).dimensions;
|
||
|
|
}
|
||
|
|
function prepareSeriesDataSchema(source, opt) {
|
||
|
|
if (!isSourceInstance(source)) {
|
||
|
|
source = createSourceFromSeriesDataOption(source);
|
||
|
|
}
|
||
|
|
opt = opt || {};
|
||
|
|
var sysDims = opt.coordDimensions || [];
|
||
|
|
var dimsDef = opt.dimensionsDefine || source.dimensionsDefine || [];
|
||
|
|
var coordDimNameMap = createHashMap();
|
||
|
|
var resultList = [];
|
||
|
|
var dimCount = getDimCount(source, sysDims, dimsDef, opt.dimensionsCount);
|
||
|
|
var omitUnusedDimensions = opt.canOmitUnusedDimensions && shouldOmitUnusedDimensions(dimCount);
|
||
|
|
var isUsingSourceDimensionsDef = dimsDef === source.dimensionsDefine;
|
||
|
|
var dataDimNameMap = isUsingSourceDimensionsDef ? ensureSourceDimNameMap(source) : createDimNameMap(dimsDef);
|
||
|
|
var encodeDef = opt.encodeDefine;
|
||
|
|
if (!encodeDef && opt.encodeDefaulter) {
|
||
|
|
encodeDef = opt.encodeDefaulter(source, dimCount);
|
||
|
|
}
|
||
|
|
var encodeDefMap = createHashMap(encodeDef);
|
||
|
|
var indicesMap = new CtorInt32Array(dimCount);
|
||
|
|
for (var i = 0; i < indicesMap.length; i++) {
|
||
|
|
indicesMap[i] = -1;
|
||
|
|
}
|
||
|
|
function getResultItem(dimIdx) {
|
||
|
|
var idx = indicesMap[dimIdx];
|
||
|
|
if (idx < 0) {
|
||
|
|
var dimDefItemRaw = dimsDef[dimIdx];
|
||
|
|
var dimDefItem = isObject(dimDefItemRaw) ? dimDefItemRaw : {
|
||
|
|
name: dimDefItemRaw
|
||
|
|
};
|
||
|
|
var resultItem2 = new SeriesDimensionDefine_default();
|
||
|
|
var userDimName = dimDefItem.name;
|
||
|
|
if (userDimName != null && dataDimNameMap.get(userDimName) != null) {
|
||
|
|
resultItem2.name = resultItem2.displayName = userDimName;
|
||
|
|
}
|
||
|
|
dimDefItem.type != null && (resultItem2.type = dimDefItem.type);
|
||
|
|
dimDefItem.displayName != null && (resultItem2.displayName = dimDefItem.displayName);
|
||
|
|
var newIdx = resultList.length;
|
||
|
|
indicesMap[dimIdx] = newIdx;
|
||
|
|
resultItem2.storeDimIndex = dimIdx;
|
||
|
|
resultList.push(resultItem2);
|
||
|
|
return resultItem2;
|
||
|
|
}
|
||
|
|
return resultList[idx];
|
||
|
|
}
|
||
|
|
if (!omitUnusedDimensions) {
|
||
|
|
for (var i = 0; i < dimCount; i++) {
|
||
|
|
getResultItem(i);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
encodeDefMap.each(function(dataDimsRaw, coordDim2) {
|
||
|
|
var dataDims = normalizeToArray(dataDimsRaw).slice();
|
||
|
|
if (dataDims.length === 1 && !isString(dataDims[0]) && dataDims[0] < 0) {
|
||
|
|
encodeDefMap.set(coordDim2, false);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
var validDataDims = encodeDefMap.set(coordDim2, []);
|
||
|
|
each(dataDims, function(resultDimIdxOrName, idx) {
|
||
|
|
var resultDimIdx2 = isString(resultDimIdxOrName) ? dataDimNameMap.get(resultDimIdxOrName) : resultDimIdxOrName;
|
||
|
|
if (resultDimIdx2 != null && resultDimIdx2 < dimCount) {
|
||
|
|
validDataDims[idx] = resultDimIdx2;
|
||
|
|
applyDim(getResultItem(resultDimIdx2), coordDim2, idx);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
});
|
||
|
|
var availDimIdx = 0;
|
||
|
|
each(sysDims, function(sysDimItemRaw) {
|
||
|
|
var coordDim2;
|
||
|
|
var sysDimItemDimsDef;
|
||
|
|
var sysDimItemOtherDims;
|
||
|
|
var sysDimItem;
|
||
|
|
if (isString(sysDimItemRaw)) {
|
||
|
|
coordDim2 = sysDimItemRaw;
|
||
|
|
sysDimItem = {};
|
||
|
|
} else {
|
||
|
|
sysDimItem = sysDimItemRaw;
|
||
|
|
coordDim2 = sysDimItem.name;
|
||
|
|
var ordinalMeta = sysDimItem.ordinalMeta;
|
||
|
|
sysDimItem.ordinalMeta = null;
|
||
|
|
sysDimItem = extend({}, sysDimItem);
|
||
|
|
sysDimItem.ordinalMeta = ordinalMeta;
|
||
|
|
sysDimItemDimsDef = sysDimItem.dimsDef;
|
||
|
|
sysDimItemOtherDims = sysDimItem.otherDims;
|
||
|
|
sysDimItem.name = sysDimItem.coordDim = sysDimItem.coordDimIndex = sysDimItem.dimsDef = sysDimItem.otherDims = null;
|
||
|
|
}
|
||
|
|
var dataDims = encodeDefMap.get(coordDim2);
|
||
|
|
if (dataDims === false) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
dataDims = normalizeToArray(dataDims);
|
||
|
|
if (!dataDims.length) {
|
||
|
|
for (var i2 = 0; i2 < (sysDimItemDimsDef && sysDimItemDimsDef.length || 1); i2++) {
|
||
|
|
while (availDimIdx < dimCount && getResultItem(availDimIdx).coordDim != null) {
|
||
|
|
availDimIdx++;
|
||
|
|
}
|
||
|
|
availDimIdx < dimCount && dataDims.push(availDimIdx++);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
each(dataDims, function(resultDimIdx2, coordDimIndex) {
|
||
|
|
var resultItem2 = getResultItem(resultDimIdx2);
|
||
|
|
if (isUsingSourceDimensionsDef && sysDimItem.type != null) {
|
||
|
|
resultItem2.type = sysDimItem.type;
|
||
|
|
}
|
||
|
|
applyDim(defaults(resultItem2, sysDimItem), coordDim2, coordDimIndex);
|
||
|
|
if (resultItem2.name == null && sysDimItemDimsDef) {
|
||
|
|
var sysDimItemDimsDefItem = sysDimItemDimsDef[coordDimIndex];
|
||
|
|
!isObject(sysDimItemDimsDefItem) && (sysDimItemDimsDefItem = {
|
||
|
|
name: sysDimItemDimsDefItem
|
||
|
|
});
|
||
|
|
resultItem2.name = resultItem2.displayName = sysDimItemDimsDefItem.name;
|
||
|
|
resultItem2.defaultTooltip = sysDimItemDimsDefItem.defaultTooltip;
|
||
|
|
}
|
||
|
|
sysDimItemOtherDims && defaults(resultItem2.otherDims, sysDimItemOtherDims);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
function applyDim(resultItem2, coordDim2, coordDimIndex) {
|
||
|
|
if (VISUAL_DIMENSIONS.get(coordDim2) != null) {
|
||
|
|
resultItem2.otherDims[coordDim2] = coordDimIndex;
|
||
|
|
} else {
|
||
|
|
resultItem2.coordDim = coordDim2;
|
||
|
|
resultItem2.coordDimIndex = coordDimIndex;
|
||
|
|
coordDimNameMap.set(coordDim2, true);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var generateCoord = opt.generateCoord;
|
||
|
|
var generateCoordCount = opt.generateCoordCount;
|
||
|
|
var fromZero = generateCoordCount != null;
|
||
|
|
generateCoordCount = generateCoord ? generateCoordCount || 1 : 0;
|
||
|
|
var extra = generateCoord || "value";
|
||
|
|
function ifNoNameFillWithCoordName(resultItem2) {
|
||
|
|
if (resultItem2.name == null) {
|
||
|
|
resultItem2.name = resultItem2.coordDim;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!omitUnusedDimensions) {
|
||
|
|
for (var resultDimIdx = 0; resultDimIdx < dimCount; resultDimIdx++) {
|
||
|
|
var resultItem = getResultItem(resultDimIdx);
|
||
|
|
var coordDim = resultItem.coordDim;
|
||
|
|
if (coordDim == null) {
|
||
|
|
resultItem.coordDim = genCoordDimName(extra, coordDimNameMap, fromZero);
|
||
|
|
resultItem.coordDimIndex = 0;
|
||
|
|
if (!generateCoord || generateCoordCount <= 0) {
|
||
|
|
resultItem.isExtraCoord = true;
|
||
|
|
}
|
||
|
|
generateCoordCount--;
|
||
|
|
}
|
||
|
|
ifNoNameFillWithCoordName(resultItem);
|
||
|
|
if (resultItem.type == null && (guessOrdinal(source, resultDimIdx) === BE_ORDINAL.Must || resultItem.isExtraCoord && (resultItem.otherDims.itemName != null || resultItem.otherDims.seriesName != null))) {
|
||
|
|
resultItem.type = "ordinal";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
each(resultList, function(resultItem2) {
|
||
|
|
ifNoNameFillWithCoordName(resultItem2);
|
||
|
|
});
|
||
|
|
resultList.sort(function(item0, item1) {
|
||
|
|
return item0.storeDimIndex - item1.storeDimIndex;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
removeDuplication(resultList);
|
||
|
|
return new SeriesDataSchema({
|
||
|
|
source,
|
||
|
|
dimensions: resultList,
|
||
|
|
fullDimensionCount: dimCount,
|
||
|
|
dimensionOmitted: omitUnusedDimensions
|
||
|
|
});
|
||
|
|
}
|
||
|
|
function removeDuplication(result) {
|
||
|
|
var duplicationMap = createHashMap();
|
||
|
|
for (var i = 0; i < result.length; i++) {
|
||
|
|
var dim = result[i];
|
||
|
|
var dimOriginalName = dim.name;
|
||
|
|
var count = duplicationMap.get(dimOriginalName) || 0;
|
||
|
|
if (count > 0) {
|
||
|
|
dim.name = dimOriginalName + (count - 1);
|
||
|
|
}
|
||
|
|
count++;
|
||
|
|
duplicationMap.set(dimOriginalName, count);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function getDimCount(source, sysDims, dimsDef, optDimCount) {
|
||
|
|
var dimCount = Math.max(source.dimensionsDetectedCount || 1, sysDims.length, dimsDef.length, optDimCount || 0);
|
||
|
|
each(sysDims, function(sysDimItem) {
|
||
|
|
var sysDimItemDimsDef;
|
||
|
|
if (isObject(sysDimItem) && (sysDimItemDimsDef = sysDimItem.dimsDef)) {
|
||
|
|
dimCount = Math.max(dimCount, sysDimItemDimsDef.length);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
return dimCount;
|
||
|
|
}
|
||
|
|
function genCoordDimName(name, map2, fromZero) {
|
||
|
|
if (fromZero || map2.hasKey(name)) {
|
||
|
|
var i = 0;
|
||
|
|
while (map2.hasKey(name + i)) {
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
name += i;
|
||
|
|
}
|
||
|
|
map2.set(name, true);
|
||
|
|
return name;
|
||
|
|
}
|
||
|
|
|
||
|
|
// node_modules/echarts/lib/model/referHelper.js
|
||
|
|
var CoordSysInfo = (
|
||
|
|
/** @class */
|
||
|
|
/* @__PURE__ */ function() {
|
||
|
|
function CoordSysInfo2(coordSysName) {
|
||
|
|
this.coordSysDims = [];
|
||
|
|
this.axisMap = createHashMap();
|
||
|
|
this.categoryAxisMap = createHashMap();
|
||
|
|
this.coordSysName = coordSysName;
|
||
|
|
}
|
||
|
|
return CoordSysInfo2;
|
||
|
|
}()
|
||
|
|
);
|
||
|
|
function getCoordSysInfoBySeries(seriesModel) {
|
||
|
|
var coordSysName = seriesModel.get("coordinateSystem");
|
||
|
|
var result = new CoordSysInfo(coordSysName);
|
||
|
|
var fetch = fetchers[coordSysName];
|
||
|
|
if (fetch) {
|
||
|
|
fetch(seriesModel, result, result.axisMap, result.categoryAxisMap);
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var fetchers = {
|
||
|
|
cartesian2d: function(seriesModel, result, axisMap, categoryAxisMap) {
|
||
|
|
var xAxisModel = seriesModel.getReferringComponents("xAxis", SINGLE_REFERRING).models[0];
|
||
|
|
var yAxisModel = seriesModel.getReferringComponents("yAxis", SINGLE_REFERRING).models[0];
|
||
|
|
if (true) {
|
||
|
|
if (!xAxisModel) {
|
||
|
|
throw new Error('xAxis "' + retrieve(seriesModel.get("xAxisIndex"), seriesModel.get("xAxisId"), 0) + '" not found');
|
||
|
|
}
|
||
|
|
if (!yAxisModel) {
|
||
|
|
throw new Error('yAxis "' + retrieve(seriesModel.get("xAxisIndex"), seriesModel.get("yAxisId"), 0) + '" not found');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
result.coordSysDims = ["x", "y"];
|
||
|
|
axisMap.set("x", xAxisModel);
|
||
|
|
axisMap.set("y", yAxisModel);
|
||
|
|
if (isCategory(xAxisModel)) {
|
||
|
|
categoryAxisMap.set("x", xAxisModel);
|
||
|
|
result.firstCategoryDimIndex = 0;
|
||
|
|
}
|
||
|
|
if (isCategory(yAxisModel)) {
|
||
|
|
categoryAxisMap.set("y", yAxisModel);
|
||
|
|
result.firstCategoryDimIndex == null && (result.firstCategoryDimIndex = 1);
|
||
|
|
}
|
||
|
|
},
|
||
|
|
singleAxis: function(seriesModel, result, axisMap, categoryAxisMap) {
|
||
|
|
var singleAxisModel = seriesModel.getReferringComponents("singleAxis", SINGLE_REFERRING).models[0];
|
||
|
|
if (true) {
|
||
|
|
if (!singleAxisModel) {
|
||
|
|
throw new Error("singleAxis should be specified.");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
result.coordSysDims = ["single"];
|
||
|
|
axisMap.set("single", singleAxisModel);
|
||
|
|
if (isCategory(singleAxisModel)) {
|
||
|
|
categoryAxisMap.set("single", singleAxisModel);
|
||
|
|
result.firstCategoryDimIndex = 0;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
polar: function(seriesModel, result, axisMap, categoryAxisMap) {
|
||
|
|
var polarModel = seriesModel.getReferringComponents("polar", SINGLE_REFERRING).models[0];
|
||
|
|
var radiusAxisModel = polarModel.findAxisModel("radiusAxis");
|
||
|
|
var angleAxisModel = polarModel.findAxisModel("angleAxis");
|
||
|
|
if (true) {
|
||
|
|
if (!angleAxisModel) {
|
||
|
|
throw new Error("angleAxis option not found");
|
||
|
|
}
|
||
|
|
if (!radiusAxisModel) {
|
||
|
|
throw new Error("radiusAxis option not found");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
result.coordSysDims = ["radius", "angle"];
|
||
|
|
axisMap.set("radius", radiusAxisModel);
|
||
|
|
axisMap.set("angle", angleAxisModel);
|
||
|
|
if (isCategory(radiusAxisModel)) {
|
||
|
|
categoryAxisMap.set("radius", radiusAxisModel);
|
||
|
|
result.firstCategoryDimIndex = 0;
|
||
|
|
}
|
||
|
|
if (isCategory(angleAxisModel)) {
|
||
|
|
categoryAxisMap.set("angle", angleAxisModel);
|
||
|
|
result.firstCategoryDimIndex == null && (result.firstCategoryDimIndex = 1);
|
||
|
|
}
|
||
|
|
},
|
||
|
|
geo: function(seriesModel, result, axisMap, categoryAxisMap) {
|
||
|
|
result.coordSysDims = ["lng", "lat"];
|
||
|
|
},
|
||
|
|
parallel: function(seriesModel, result, axisMap, categoryAxisMap) {
|
||
|
|
var ecModel = seriesModel.ecModel;
|
||
|
|
var parallelModel = ecModel.getComponent("parallel", seriesModel.get("parallelIndex"));
|
||
|
|
var coordSysDims = result.coordSysDims = parallelModel.dimensions.slice();
|
||
|
|
each(parallelModel.parallelAxisIndex, function(axisIndex, index) {
|
||
|
|
var axisModel = ecModel.getComponent("parallelAxis", axisIndex);
|
||
|
|
var axisDim = coordSysDims[index];
|
||
|
|
axisMap.set(axisDim, axisModel);
|
||
|
|
if (isCategory(axisModel)) {
|
||
|
|
categoryAxisMap.set(axisDim, axisModel);
|
||
|
|
if (result.firstCategoryDimIndex == null) {
|
||
|
|
result.firstCategoryDimIndex = index;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
};
|
||
|
|
function isCategory(axisModel) {
|
||
|
|
return axisModel.get("type") === "category";
|
||
|
|
}
|
||
|
|
|
||
|
|
// node_modules/echarts/lib/chart/helper/createSeriesData.js
|
||
|
|
function getCoordSysDimDefs(seriesModel, coordSysInfo) {
|
||
|
|
var coordSysName = seriesModel.get("coordinateSystem");
|
||
|
|
var registeredCoordSys = CoordinateSystem_default.get(coordSysName);
|
||
|
|
var coordSysDimDefs;
|
||
|
|
if (coordSysInfo && coordSysInfo.coordSysDims) {
|
||
|
|
coordSysDimDefs = map(coordSysInfo.coordSysDims, function(dim) {
|
||
|
|
var dimInfo = {
|
||
|
|
name: dim
|
||
|
|
};
|
||
|
|
var axisModel = coordSysInfo.axisMap.get(dim);
|
||
|
|
if (axisModel) {
|
||
|
|
var axisType = axisModel.get("type");
|
||
|
|
dimInfo.type = getDimensionTypeByAxis(axisType);
|
||
|
|
}
|
||
|
|
return dimInfo;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
if (!coordSysDimDefs) {
|
||
|
|
coordSysDimDefs = registeredCoordSys && (registeredCoordSys.getDimensionsInfo ? registeredCoordSys.getDimensionsInfo() : registeredCoordSys.dimensions.slice()) || ["x", "y"];
|
||
|
|
}
|
||
|
|
return coordSysDimDefs;
|
||
|
|
}
|
||
|
|
function injectOrdinalMeta(dimInfoList, createInvertedIndices, coordSysInfo) {
|
||
|
|
var firstCategoryDimIndex;
|
||
|
|
var hasNameEncode;
|
||
|
|
coordSysInfo && each(dimInfoList, function(dimInfo, dimIndex) {
|
||
|
|
var coordDim = dimInfo.coordDim;
|
||
|
|
var categoryAxisModel = coordSysInfo.categoryAxisMap.get(coordDim);
|
||
|
|
if (categoryAxisModel) {
|
||
|
|
if (firstCategoryDimIndex == null) {
|
||
|
|
firstCategoryDimIndex = dimIndex;
|
||
|
|
}
|
||
|
|
dimInfo.ordinalMeta = categoryAxisModel.getOrdinalMeta();
|
||
|
|
if (createInvertedIndices) {
|
||
|
|
dimInfo.createInvertedIndices = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (dimInfo.otherDims.itemName != null) {
|
||
|
|
hasNameEncode = true;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
if (!hasNameEncode && firstCategoryDimIndex != null) {
|
||
|
|
dimInfoList[firstCategoryDimIndex].otherDims.itemName = 0;
|
||
|
|
}
|
||
|
|
return firstCategoryDimIndex;
|
||
|
|
}
|
||
|
|
function createSeriesData(sourceRaw, seriesModel, opt) {
|
||
|
|
opt = opt || {};
|
||
|
|
var sourceManager = seriesModel.getSourceManager();
|
||
|
|
var source;
|
||
|
|
var isOriginalSource = false;
|
||
|
|
if (sourceRaw) {
|
||
|
|
isOriginalSource = true;
|
||
|
|
source = createSourceFromSeriesDataOption(sourceRaw);
|
||
|
|
} else {
|
||
|
|
source = sourceManager.getSource();
|
||
|
|
isOriginalSource = source.sourceFormat === SOURCE_FORMAT_ORIGINAL;
|
||
|
|
}
|
||
|
|
var coordSysInfo = getCoordSysInfoBySeries(seriesModel);
|
||
|
|
var coordSysDimDefs = getCoordSysDimDefs(seriesModel, coordSysInfo);
|
||
|
|
var useEncodeDefaulter = opt.useEncodeDefaulter;
|
||
|
|
var encodeDefaulter = isFunction(useEncodeDefaulter) ? useEncodeDefaulter : useEncodeDefaulter ? curry(makeSeriesEncodeForAxisCoordSys, coordSysDimDefs, seriesModel) : null;
|
||
|
|
var createDimensionOptions = {
|
||
|
|
coordDimensions: coordSysDimDefs,
|
||
|
|
generateCoord: opt.generateCoord,
|
||
|
|
encodeDefine: seriesModel.getEncode(),
|
||
|
|
encodeDefaulter,
|
||
|
|
canOmitUnusedDimensions: !isOriginalSource
|
||
|
|
};
|
||
|
|
var schema = prepareSeriesDataSchema(source, createDimensionOptions);
|
||
|
|
var firstCategoryDimIndex = injectOrdinalMeta(schema.dimensions, opt.createInvertedIndices, coordSysInfo);
|
||
|
|
var store = !isOriginalSource ? sourceManager.getSharedDataStore(schema) : null;
|
||
|
|
var stackCalculationInfo = enableDataStack(seriesModel, {
|
||
|
|
schema,
|
||
|
|
store
|
||
|
|
});
|
||
|
|
var data = new SeriesData_default(schema, seriesModel);
|
||
|
|
data.setCalculationInfo(stackCalculationInfo);
|
||
|
|
var dimValueGetter = firstCategoryDimIndex != null && isNeedCompleteOrdinalData(source) ? function(itemOpt, dimName, dataIndex, dimIndex) {
|
||
|
|
return dimIndex === firstCategoryDimIndex ? dataIndex : this.defaultDimValueGetter(itemOpt, dimName, dataIndex, dimIndex);
|
||
|
|
} : null;
|
||
|
|
data.hasItemOption = false;
|
||
|
|
data.initData(
|
||
|
|
// Try to reuse the data store in sourceManager if using dataset.
|
||
|
|
isOriginalSource ? source : store,
|
||
|
|
null,
|
||
|
|
dimValueGetter
|
||
|
|
);
|
||
|
|
return data;
|
||
|
|
}
|
||
|
|
function isNeedCompleteOrdinalData(source) {
|
||
|
|
if (source.sourceFormat === SOURCE_FORMAT_ORIGINAL) {
|
||
|
|
var sampleItem = firstDataNotNull(source.data || []);
|
||
|
|
return !isArray(getDataItemValue(sampleItem));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function firstDataNotNull(arr) {
|
||
|
|
var i = 0;
|
||
|
|
while (i < arr.length && arr[i] == null) {
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
return arr[i];
|
||
|
|
}
|
||
|
|
var createSeriesData_default = createSeriesData;
|
||
|
|
|
||
|
|
// node_modules/echarts/lib/label/labelGuideHelper.js
|
||
|
|
var PI2 = Math.PI * 2;
|
||
|
|
var CMD = PathProxy_default.CMD;
|
||
|
|
var DEFAULT_SEARCH_SPACE = ["top", "right", "bottom", "left"];
|
||
|
|
function getCandidateAnchor(pos, distance, rect, outPt, outDir) {
|
||
|
|
var width = rect.width;
|
||
|
|
var height = rect.height;
|
||
|
|
switch (pos) {
|
||
|
|
case "top":
|
||
|
|
outPt.set(rect.x + width / 2, rect.y - distance);
|
||
|
|
outDir.set(0, -1);
|
||
|
|
break;
|
||
|
|
case "bottom":
|
||
|
|
outPt.set(rect.x + width / 2, rect.y + height + distance);
|
||
|
|
outDir.set(0, 1);
|
||
|
|
break;
|
||
|
|
case "left":
|
||
|
|
outPt.set(rect.x - distance, rect.y + height / 2);
|
||
|
|
outDir.set(-1, 0);
|
||
|
|
break;
|
||
|
|
case "right":
|
||
|
|
outPt.set(rect.x + width + distance, rect.y + height / 2);
|
||
|
|
outDir.set(1, 0);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function projectPointToArc(cx, cy, r, startAngle, endAngle, anticlockwise, x, y, out) {
|
||
|
|
x -= cx;
|
||
|
|
y -= cy;
|
||
|
|
var d = Math.sqrt(x * x + y * y);
|
||
|
|
x /= d;
|
||
|
|
y /= d;
|
||
|
|
var ox = x * r + cx;
|
||
|
|
var oy = y * r + cy;
|
||
|
|
if (Math.abs(startAngle - endAngle) % PI2 < 1e-4) {
|
||
|
|
out[0] = ox;
|
||
|
|
out[1] = oy;
|
||
|
|
return d - r;
|
||
|
|
}
|
||
|
|
if (anticlockwise) {
|
||
|
|
var tmp = startAngle;
|
||
|
|
startAngle = normalizeRadian(endAngle);
|
||
|
|
endAngle = normalizeRadian(tmp);
|
||
|
|
} else {
|
||
|
|
startAngle = normalizeRadian(startAngle);
|
||
|
|
endAngle = normalizeRadian(endAngle);
|
||
|
|
}
|
||
|
|
if (startAngle > endAngle) {
|
||
|
|
endAngle += PI2;
|
||
|
|
}
|
||
|
|
var angle = Math.atan2(y, x);
|
||
|
|
if (angle < 0) {
|
||
|
|
angle += PI2;
|
||
|
|
}
|
||
|
|
if (angle >= startAngle && angle <= endAngle || angle + PI2 >= startAngle && angle + PI2 <= endAngle) {
|
||
|
|
out[0] = ox;
|
||
|
|
out[1] = oy;
|
||
|
|
return d - r;
|
||
|
|
}
|
||
|
|
var x1 = r * Math.cos(startAngle) + cx;
|
||
|
|
var y1 = r * Math.sin(startAngle) + cy;
|
||
|
|
var x2 = r * Math.cos(endAngle) + cx;
|
||
|
|
var y2 = r * Math.sin(endAngle) + cy;
|
||
|
|
var d1 = (x1 - x) * (x1 - x) + (y1 - y) * (y1 - y);
|
||
|
|
var d2 = (x2 - x) * (x2 - x) + (y2 - y) * (y2 - y);
|
||
|
|
if (d1 < d2) {
|
||
|
|
out[0] = x1;
|
||
|
|
out[1] = y1;
|
||
|
|
return Math.sqrt(d1);
|
||
|
|
} else {
|
||
|
|
out[0] = x2;
|
||
|
|
out[1] = y2;
|
||
|
|
return Math.sqrt(d2);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function projectPointToLine(x1, y1, x2, y2, x, y, out, limitToEnds) {
|
||
|
|
var dx = x - x1;
|
||
|
|
var dy = y - y1;
|
||
|
|
var dx1 = x2 - x1;
|
||
|
|
var dy1 = y2 - y1;
|
||
|
|
var lineLen = Math.sqrt(dx1 * dx1 + dy1 * dy1);
|
||
|
|
dx1 /= lineLen;
|
||
|
|
dy1 /= lineLen;
|
||
|
|
var projectedLen = dx * dx1 + dy * dy1;
|
||
|
|
var t = projectedLen / lineLen;
|
||
|
|
if (limitToEnds) {
|
||
|
|
t = Math.min(Math.max(t, 0), 1);
|
||
|
|
}
|
||
|
|
t *= lineLen;
|
||
|
|
var ox = out[0] = x1 + t * dx1;
|
||
|
|
var oy = out[1] = y1 + t * dy1;
|
||
|
|
return Math.sqrt((ox - x) * (ox - x) + (oy - y) * (oy - y));
|
||
|
|
}
|
||
|
|
function projectPointToRect(x1, y1, width, height, x, y, out) {
|
||
|
|
if (width < 0) {
|
||
|
|
x1 = x1 + width;
|
||
|
|
width = -width;
|
||
|
|
}
|
||
|
|
if (height < 0) {
|
||
|
|
y1 = y1 + height;
|
||
|
|
height = -height;
|
||
|
|
}
|
||
|
|
var x2 = x1 + width;
|
||
|
|
var y2 = y1 + height;
|
||
|
|
var ox = out[0] = Math.min(Math.max(x, x1), x2);
|
||
|
|
var oy = out[1] = Math.min(Math.max(y, y1), y2);
|
||
|
|
return Math.sqrt((ox - x) * (ox - x) + (oy - y) * (oy - y));
|
||
|
|
}
|
||
|
|
var tmpPt = [];
|
||
|
|
function nearestPointOnRect(pt, rect, out) {
|
||
|
|
var dist2 = projectPointToRect(rect.x, rect.y, rect.width, rect.height, pt.x, pt.y, tmpPt);
|
||
|
|
out.set(tmpPt[0], tmpPt[1]);
|
||
|
|
return dist2;
|
||
|
|
}
|
||
|
|
function nearestPointOnPath(pt, path, out) {
|
||
|
|
var xi = 0;
|
||
|
|
var yi = 0;
|
||
|
|
var x0 = 0;
|
||
|
|
var y0 = 0;
|
||
|
|
var x1;
|
||
|
|
var y1;
|
||
|
|
var minDist = Infinity;
|
||
|
|
var data = path.data;
|
||
|
|
var x = pt.x;
|
||
|
|
var y = pt.y;
|
||
|
|
for (var i = 0; i < data.length; ) {
|
||
|
|
var cmd = data[i++];
|
||
|
|
if (i === 1) {
|
||
|
|
xi = data[i];
|
||
|
|
yi = data[i + 1];
|
||
|
|
x0 = xi;
|
||
|
|
y0 = yi;
|
||
|
|
}
|
||
|
|
var d = minDist;
|
||
|
|
switch (cmd) {
|
||
|
|
case CMD.M:
|
||
|
|
x0 = data[i++];
|
||
|
|
y0 = data[i++];
|
||
|
|
xi = x0;
|
||
|
|
yi = y0;
|
||
|
|
break;
|
||
|
|
case CMD.L:
|
||
|
|
d = projectPointToLine(xi, yi, data[i], data[i + 1], x, y, tmpPt, true);
|
||
|
|
xi = data[i++];
|
||
|
|
yi = data[i++];
|
||
|
|
break;
|
||
|
|
case CMD.C:
|
||
|
|
d = cubicProjectPoint(xi, yi, data[i++], data[i++], data[i++], data[i++], data[i], data[i + 1], x, y, tmpPt);
|
||
|
|
xi = data[i++];
|
||
|
|
yi = data[i++];
|
||
|
|
break;
|
||
|
|
case CMD.Q:
|
||
|
|
d = quadraticProjectPoint(xi, yi, data[i++], data[i++], data[i], data[i + 1], x, y, tmpPt);
|
||
|
|
xi = data[i++];
|
||
|
|
yi = data[i++];
|
||
|
|
break;
|
||
|
|
case CMD.A:
|
||
|
|
var cx = data[i++];
|
||
|
|
var cy = data[i++];
|
||
|
|
var rx = data[i++];
|
||
|
|
var ry = data[i++];
|
||
|
|
var theta = data[i++];
|
||
|
|
var dTheta = data[i++];
|
||
|
|
i += 1;
|
||
|
|
var anticlockwise = !!(1 - data[i++]);
|
||
|
|
x1 = Math.cos(theta) * rx + cx;
|
||
|
|
y1 = Math.sin(theta) * ry + cy;
|
||
|
|
if (i <= 1) {
|
||
|
|
x0 = x1;
|
||
|
|
y0 = y1;
|
||
|
|
}
|
||
|
|
var _x = (x - cx) * ry / rx + cx;
|
||
|
|
d = projectPointToArc(cx, cy, ry, theta, theta + dTheta, anticlockwise, _x, y, tmpPt);
|
||
|
|
xi = Math.cos(theta + dTheta) * rx + cx;
|
||
|
|
yi = Math.sin(theta + dTheta) * ry + cy;
|
||
|
|
break;
|
||
|
|
case CMD.R:
|
||
|
|
x0 = xi = data[i++];
|
||
|
|
y0 = yi = data[i++];
|
||
|
|
var width = data[i++];
|
||
|
|
var height = data[i++];
|
||
|
|
d = projectPointToRect(x0, y0, width, height, x, y, tmpPt);
|
||
|
|
break;
|
||
|
|
case CMD.Z:
|
||
|
|
d = projectPointToLine(xi, yi, x0, y0, x, y, tmpPt, true);
|
||
|
|
xi = x0;
|
||
|
|
yi = y0;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (d < minDist) {
|
||
|
|
minDist = d;
|
||
|
|
out.set(tmpPt[0], tmpPt[1]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return minDist;
|
||
|
|
}
|
||
|
|
var pt0 = new Point_default();
|
||
|
|
var pt1 = new Point_default();
|
||
|
|
var pt2 = new Point_default();
|
||
|
|
var dir = new Point_default();
|
||
|
|
var dir2 = new Point_default();
|
||
|
|
function updateLabelLinePoints(target, labelLineModel) {
|
||
|
|
if (!target) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
var labelLine = target.getTextGuideLine();
|
||
|
|
var label = target.getTextContent();
|
||
|
|
if (!(label && labelLine)) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
var labelGuideConfig = target.textGuideLineConfig || {};
|
||
|
|
var points = [[0, 0], [0, 0], [0, 0]];
|
||
|
|
var searchSpace = labelGuideConfig.candidates || DEFAULT_SEARCH_SPACE;
|
||
|
|
var labelRect = label.getBoundingRect().clone();
|
||
|
|
labelRect.applyTransform(label.getComputedTransform());
|
||
|
|
var minDist = Infinity;
|
||
|
|
var anchorPoint = labelGuideConfig.anchor;
|
||
|
|
var targetTransform = target.getComputedTransform();
|
||
|
|
var targetInversedTransform = targetTransform && invert([], targetTransform);
|
||
|
|
var len = labelLineModel.get("length2") || 0;
|
||
|
|
if (anchorPoint) {
|
||
|
|
pt2.copy(anchorPoint);
|
||
|
|
}
|
||
|
|
for (var i = 0; i < searchSpace.length; i++) {
|
||
|
|
var candidate = searchSpace[i];
|
||
|
|
getCandidateAnchor(candidate, 0, labelRect, pt0, dir);
|
||
|
|
Point_default.scaleAndAdd(pt1, pt0, dir, len);
|
||
|
|
pt1.transform(targetInversedTransform);
|
||
|
|
var boundingRect = target.getBoundingRect();
|
||
|
|
var dist2 = anchorPoint ? anchorPoint.distance(pt1) : target instanceof Path_default ? nearestPointOnPath(pt1, target.path, pt2) : nearestPointOnRect(pt1, boundingRect, pt2);
|
||
|
|
if (dist2 < minDist) {
|
||
|
|
minDist = dist2;
|
||
|
|
pt1.transform(targetTransform);
|
||
|
|
pt2.transform(targetTransform);
|
||
|
|
pt2.toArray(points[0]);
|
||
|
|
pt1.toArray(points[1]);
|
||
|
|
pt0.toArray(points[2]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
limitTurnAngle(points, labelLineModel.get("minTurnAngle"));
|
||
|
|
labelLine.setShape({
|
||
|
|
points
|
||
|
|
});
|
||
|
|
}
|
||
|
|
var tmpArr = [];
|
||
|
|
var tmpProjPoint = new Point_default();
|
||
|
|
function limitTurnAngle(linePoints, minTurnAngle) {
|
||
|
|
if (!(minTurnAngle <= 180 && minTurnAngle > 0)) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
minTurnAngle = minTurnAngle / 180 * Math.PI;
|
||
|
|
pt0.fromArray(linePoints[0]);
|
||
|
|
pt1.fromArray(linePoints[1]);
|
||
|
|
pt2.fromArray(linePoints[2]);
|
||
|
|
Point_default.sub(dir, pt0, pt1);
|
||
|
|
Point_default.sub(dir2, pt2, pt1);
|
||
|
|
var len1 = dir.len();
|
||
|
|
var len2 = dir2.len();
|
||
|
|
if (len1 < 1e-3 || len2 < 1e-3) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
dir.scale(1 / len1);
|
||
|
|
dir2.scale(1 / len2);
|
||
|
|
var angleCos = dir.dot(dir2);
|
||
|
|
var minTurnAngleCos = Math.cos(minTurnAngle);
|
||
|
|
if (minTurnAngleCos < angleCos) {
|
||
|
|
var d = projectPointToLine(pt1.x, pt1.y, pt2.x, pt2.y, pt0.x, pt0.y, tmpArr, false);
|
||
|
|
tmpProjPoint.fromArray(tmpArr);
|
||
|
|
tmpProjPoint.scaleAndAdd(dir2, d / Math.tan(Math.PI - minTurnAngle));
|
||
|
|
var t = pt2.x !== pt1.x ? (tmpProjPoint.x - pt1.x) / (pt2.x - pt1.x) : (tmpProjPoint.y - pt1.y) / (pt2.y - pt1.y);
|
||
|
|
if (isNaN(t)) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (t < 0) {
|
||
|
|
Point_default.copy(tmpProjPoint, pt1);
|
||
|
|
} else if (t > 1) {
|
||
|
|
Point_default.copy(tmpProjPoint, pt2);
|
||
|
|
}
|
||
|
|
tmpProjPoint.toArray(linePoints[1]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function limitSurfaceAngle(linePoints, surfaceNormal, maxSurfaceAngle) {
|
||
|
|
if (!(maxSurfaceAngle <= 180 && maxSurfaceAngle > 0)) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
maxSurfaceAngle = maxSurfaceAngle / 180 * Math.PI;
|
||
|
|
pt0.fromArray(linePoints[0]);
|
||
|
|
pt1.fromArray(linePoints[1]);
|
||
|
|
pt2.fromArray(linePoints[2]);
|
||
|
|
Point_default.sub(dir, pt1, pt0);
|
||
|
|
Point_default.sub(dir2, pt2, pt1);
|
||
|
|
var len1 = dir.len();
|
||
|
|
var len2 = dir2.len();
|
||
|
|
if (len1 < 1e-3 || len2 < 1e-3) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
dir.scale(1 / len1);
|
||
|
|
dir2.scale(1 / len2);
|
||
|
|
var angleCos = dir.dot(surfaceNormal);
|
||
|
|
var maxSurfaceAngleCos = Math.cos(maxSurfaceAngle);
|
||
|
|
if (angleCos < maxSurfaceAngleCos) {
|
||
|
|
var d = projectPointToLine(pt1.x, pt1.y, pt2.x, pt2.y, pt0.x, pt0.y, tmpArr, false);
|
||
|
|
tmpProjPoint.fromArray(tmpArr);
|
||
|
|
var HALF_PI = Math.PI / 2;
|
||
|
|
var angle2 = Math.acos(dir2.dot(surfaceNormal));
|
||
|
|
var newAngle = HALF_PI + angle2 - maxSurfaceAngle;
|
||
|
|
if (newAngle >= HALF_PI) {
|
||
|
|
Point_default.copy(tmpProjPoint, pt2);
|
||
|
|
} else {
|
||
|
|
tmpProjPoint.scaleAndAdd(dir2, d / Math.tan(Math.PI / 2 - newAngle));
|
||
|
|
var t = pt2.x !== pt1.x ? (tmpProjPoint.x - pt1.x) / (pt2.x - pt1.x) : (tmpProjPoint.y - pt1.y) / (pt2.y - pt1.y);
|
||
|
|
if (isNaN(t)) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (t < 0) {
|
||
|
|
Point_default.copy(tmpProjPoint, pt1);
|
||
|
|
} else if (t > 1) {
|
||
|
|
Point_default.copy(tmpProjPoint, pt2);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
tmpProjPoint.toArray(linePoints[1]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function setLabelLineState(labelLine, ignore, stateName, stateModel) {
|
||
|
|
var isNormal = stateName === "normal";
|
||
|
|
var stateObj = isNormal ? labelLine : labelLine.ensureState(stateName);
|
||
|
|
stateObj.ignore = ignore;
|
||
|
|
var smooth = stateModel.get("smooth");
|
||
|
|
if (smooth && smooth === true) {
|
||
|
|
smooth = 0.3;
|
||
|
|
}
|
||
|
|
stateObj.shape = stateObj.shape || {};
|
||
|
|
if (smooth > 0) {
|
||
|
|
stateObj.shape.smooth = smooth;
|
||
|
|
}
|
||
|
|
var styleObj = stateModel.getModel("lineStyle").getLineStyle();
|
||
|
|
isNormal ? labelLine.useStyle(styleObj) : stateObj.style = styleObj;
|
||
|
|
}
|
||
|
|
function buildLabelLinePath(path, shape) {
|
||
|
|
var smooth = shape.smooth;
|
||
|
|
var points = shape.points;
|
||
|
|
if (!points) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
path.moveTo(points[0][0], points[0][1]);
|
||
|
|
if (smooth > 0 && points.length >= 3) {
|
||
|
|
var len1 = dist(points[0], points[1]);
|
||
|
|
var len2 = dist(points[1], points[2]);
|
||
|
|
if (!len1 || !len2) {
|
||
|
|
path.lineTo(points[1][0], points[1][1]);
|
||
|
|
path.lineTo(points[2][0], points[2][1]);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
var moveLen = Math.min(len1, len2) * smooth;
|
||
|
|
var midPoint0 = lerp([], points[1], points[0], moveLen / len1);
|
||
|
|
var midPoint2 = lerp([], points[1], points[2], moveLen / len2);
|
||
|
|
var midPoint1 = lerp([], midPoint0, midPoint2, 0.5);
|
||
|
|
path.bezierCurveTo(midPoint0[0], midPoint0[1], midPoint0[0], midPoint0[1], midPoint1[0], midPoint1[1]);
|
||
|
|
path.bezierCurveTo(midPoint2[0], midPoint2[1], midPoint2[0], midPoint2[1], points[2][0], points[2][1]);
|
||
|
|
} else {
|
||
|
|
for (var i = 1; i < points.length; i++) {
|
||
|
|
path.lineTo(points[i][0], points[i][1]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function setLabelLineStyle(targetEl, statesModels, defaultStyle) {
|
||
|
|
var labelLine = targetEl.getTextGuideLine();
|
||
|
|
var label = targetEl.getTextContent();
|
||
|
|
if (!label) {
|
||
|
|
if (labelLine) {
|
||
|
|
targetEl.removeTextGuideLine();
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
var normalModel = statesModels.normal;
|
||
|
|
var showNormal = normalModel.get("show");
|
||
|
|
var labelIgnoreNormal = label.ignore;
|
||
|
|
for (var i = 0; i < DISPLAY_STATES.length; i++) {
|
||
|
|
var stateName = DISPLAY_STATES[i];
|
||
|
|
var stateModel = statesModels[stateName];
|
||
|
|
var isNormal = stateName === "normal";
|
||
|
|
if (stateModel) {
|
||
|
|
var stateShow = stateModel.get("show");
|
||
|
|
var isLabelIgnored = isNormal ? labelIgnoreNormal : retrieve2(label.states[stateName] && label.states[stateName].ignore, labelIgnoreNormal);
|
||
|
|
if (isLabelIgnored || !retrieve2(stateShow, showNormal)) {
|
||
|
|
var stateObj = isNormal ? labelLine : labelLine && labelLine.states[stateName];
|
||
|
|
if (stateObj) {
|
||
|
|
stateObj.ignore = true;
|
||
|
|
}
|
||
|
|
if (!!labelLine) {
|
||
|
|
setLabelLineState(labelLine, true, stateName, stateModel);
|
||
|
|
}
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if (!labelLine) {
|
||
|
|
labelLine = new Polyline_default();
|
||
|
|
targetEl.setTextGuideLine(labelLine);
|
||
|
|
if (!isNormal && (labelIgnoreNormal || !showNormal)) {
|
||
|
|
setLabelLineState(labelLine, true, "normal", statesModels.normal);
|
||
|
|
}
|
||
|
|
if (targetEl.stateProxy) {
|
||
|
|
labelLine.stateProxy = targetEl.stateProxy;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
setLabelLineState(labelLine, false, stateName, stateModel);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (labelLine) {
|
||
|
|
defaults(labelLine.style, defaultStyle);
|
||
|
|
labelLine.style.fill = null;
|
||
|
|
var showAbove = normalModel.get("showAbove");
|
||
|
|
var labelLineConfig = targetEl.textGuideLineConfig = targetEl.textGuideLineConfig || {};
|
||
|
|
labelLineConfig.showAbove = showAbove || false;
|
||
|
|
labelLine.buildPath = buildLabelLinePath;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function getLabelLineStatesModels(itemModel, labelLineName) {
|
||
|
|
labelLineName = labelLineName || "labelLine";
|
||
|
|
var statesModels = {
|
||
|
|
normal: itemModel.getModel(labelLineName)
|
||
|
|
};
|
||
|
|
for (var i = 0; i < SPECIAL_STATES.length; i++) {
|
||
|
|
var stateName = SPECIAL_STATES[i];
|
||
|
|
statesModels[stateName] = itemModel.getModel([stateName, labelLineName]);
|
||
|
|
}
|
||
|
|
return statesModels;
|
||
|
|
}
|
||
|
|
|
||
|
|
export {
|
||
|
|
createDimensions,
|
||
|
|
prepareSeriesDataSchema,
|
||
|
|
createSeriesData_default,
|
||
|
|
updateLabelLinePoints,
|
||
|
|
limitTurnAngle,
|
||
|
|
limitSurfaceAngle,
|
||
|
|
setLabelLineStyle,
|
||
|
|
getLabelLineStatesModels
|
||
|
|
};
|
||
|
|
//# sourceMappingURL=chunk-ZV5VKGRJ.js.map
|