|
/*
|
* Licensed to the Apache Software Foundation (ASF) under one
|
* or more contributor license agreements. See the NOTICE file
|
* distributed with this work for additional information
|
* regarding copyright ownership. The ASF licenses this file
|
* to you under the Apache License, Version 2.0 (the
|
* "License"); you may not use this file except in compliance
|
* with the License. You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing,
|
* software distributed under the License is distributed on an
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
* KIND, either express or implied. See the License for the
|
* specific language governing permissions and limitations
|
* under the License.
|
*/
|
|
|
/**
|
* AUTO-GENERATED FILE. DO NOT MODIFY.
|
*/
|
|
/*
|
* Licensed to the Apache Software Foundation (ASF) under one
|
* or more contributor license agreements. See the NOTICE file
|
* distributed with this work for additional information
|
* regarding copyright ownership. The ASF licenses this file
|
* to you under the Apache License, Version 2.0 (the
|
* "License"); you may not use this file except in compliance
|
* with the License. You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing,
|
* software distributed under the License is distributed on an
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
* KIND, either express or implied. See the License for the
|
* specific language governing permissions and limitations
|
* under the License.
|
*/
|
import { __extends } from "tslib";
|
import * as zrUtil from 'zrender/lib/core/util.js';
|
import env from 'zrender/lib/core/env.js';
|
import * as modelUtil from '../util/model.js';
|
import ComponentModel from './Component.js';
|
import { PaletteMixin } from './mixin/palette.js';
|
import { DataFormatMixin } from '../model/mixin/dataFormat.js';
|
import { getLayoutParams, mergeLayoutParam, fetchLayoutMode } from '../util/layout.js';
|
import { createTask } from '../core/task.js';
|
import { mountExtend } from '../util/clazz.js';
|
import { SourceManager } from '../data/helper/sourceManager.js';
|
import { defaultSeriesFormatTooltip } from '../component/tooltip/seriesFormatTooltip.js';
|
var inner = modelUtil.makeInner();
|
function getSelectionKey(data, dataIndex) {
|
return data.getName(dataIndex) || data.getId(dataIndex);
|
}
|
export var SERIES_UNIVERSAL_TRANSITION_PROP = '__universalTransitionEnabled';
|
var SeriesModel = /** @class */function (_super) {
|
__extends(SeriesModel, _super);
|
function SeriesModel() {
|
// [Caution]: Because this class or desecendants can be used as `XXX.extend(subProto)`,
|
// the class members must not be initialized in constructor or declaration place.
|
// Otherwise there is bad case:
|
// class A {xxx = 1;}
|
// enableClassExtend(A);
|
// class B extends A {}
|
// var C = B.extend({xxx: 5});
|
// var c = new C();
|
// console.log(c.xxx); // expect 5 but always 1.
|
var _this = _super !== null && _super.apply(this, arguments) || this;
|
// ---------------------------------------
|
// Props about data selection
|
// ---------------------------------------
|
_this._selectedDataIndicesMap = {};
|
return _this;
|
}
|
SeriesModel.prototype.init = function (option, parentModel, ecModel) {
|
this.seriesIndex = this.componentIndex;
|
this.dataTask = createTask({
|
count: dataTaskCount,
|
reset: dataTaskReset
|
});
|
this.dataTask.context = {
|
model: this
|
};
|
this.mergeDefaultAndTheme(option, ecModel);
|
var sourceManager = inner(this).sourceManager = new SourceManager(this);
|
sourceManager.prepareSource();
|
var data = this.getInitialData(option, ecModel);
|
wrapData(data, this);
|
this.dataTask.context.data = data;
|
if (process.env.NODE_ENV !== 'production') {
|
zrUtil.assert(data, 'getInitialData returned invalid data.');
|
}
|
inner(this).dataBeforeProcessed = data;
|
// If we reverse the order (make data firstly, and then make
|
// dataBeforeProcessed by cloneShallow), cloneShallow will
|
// cause data.graph.data !== data when using
|
// module:echarts/data/Graph or module:echarts/data/Tree.
|
// See module:echarts/data/helper/linkSeriesData
|
// Theoretically, it is unreasonable to call `seriesModel.getData()` in the model
|
// init or merge stage, because the data can be restored. So we do not `restoreData`
|
// and `setData` here, which forbids calling `seriesModel.getData()` in this stage.
|
// Call `seriesModel.getRawData()` instead.
|
// this.restoreData();
|
autoSeriesName(this);
|
this._initSelectedMapFromData(data);
|
};
|
/**
|
* Util for merge default and theme to option
|
*/
|
SeriesModel.prototype.mergeDefaultAndTheme = function (option, ecModel) {
|
var layoutMode = fetchLayoutMode(this);
|
var inputPositionParams = layoutMode ? getLayoutParams(option) : {};
|
// Backward compat: using subType on theme.
|
// But if name duplicate between series subType
|
// (for example: parallel) add component mainType,
|
// add suffix 'Series'.
|
var themeSubType = this.subType;
|
if (ComponentModel.hasClass(themeSubType)) {
|
themeSubType += 'Series';
|
}
|
zrUtil.merge(option, ecModel.getTheme().get(this.subType));
|
zrUtil.merge(option, this.getDefaultOption());
|
// Default label emphasis `show`
|
modelUtil.defaultEmphasis(option, 'label', ['show']);
|
this.fillDataTextStyle(option.data);
|
if (layoutMode) {
|
mergeLayoutParam(option, inputPositionParams, layoutMode);
|
}
|
};
|
SeriesModel.prototype.mergeOption = function (newSeriesOption, ecModel) {
|
// this.settingTask.dirty();
|
newSeriesOption = zrUtil.merge(this.option, newSeriesOption, true);
|
this.fillDataTextStyle(newSeriesOption.data);
|
var layoutMode = fetchLayoutMode(this);
|
if (layoutMode) {
|
mergeLayoutParam(this.option, newSeriesOption, layoutMode);
|
}
|
var sourceManager = inner(this).sourceManager;
|
sourceManager.dirty();
|
sourceManager.prepareSource();
|
var data = this.getInitialData(newSeriesOption, ecModel);
|
wrapData(data, this);
|
this.dataTask.dirty();
|
this.dataTask.context.data = data;
|
inner(this).dataBeforeProcessed = data;
|
autoSeriesName(this);
|
this._initSelectedMapFromData(data);
|
};
|
SeriesModel.prototype.fillDataTextStyle = function (data) {
|
// Default data label emphasis `show`
|
// FIXME Tree structure data ?
|
// FIXME Performance ?
|
if (data && !zrUtil.isTypedArray(data)) {
|
var props = ['show'];
|
for (var i = 0; i < data.length; i++) {
|
if (data[i] && data[i].label) {
|
modelUtil.defaultEmphasis(data[i], 'label', props);
|
}
|
}
|
}
|
};
|
/**
|
* Init a data structure from data related option in series
|
* Must be overridden.
|
*/
|
SeriesModel.prototype.getInitialData = function (option, ecModel) {
|
return;
|
};
|
/**
|
* Append data to list
|
*/
|
SeriesModel.prototype.appendData = function (params) {
|
// FIXME ???
|
// (1) If data from dataset, forbidden append.
|
// (2) support append data of dataset.
|
var data = this.getRawData();
|
data.appendData(params.data);
|
};
|
/**
|
* Consider some method like `filter`, `map` need make new data,
|
* We should make sure that `seriesModel.getData()` get correct
|
* data in the stream procedure. So we fetch data from upstream
|
* each time `task.perform` called.
|
*/
|
SeriesModel.prototype.getData = function (dataType) {
|
var task = getCurrentTask(this);
|
if (task) {
|
var data = task.context.data;
|
return dataType == null || !data.getLinkedData ? data : data.getLinkedData(dataType);
|
} else {
|
// When series is not alive (that may happen when click toolbox
|
// restore or setOption with not merge mode), series data may
|
// be still need to judge animation or something when graphic
|
// elements want to know whether fade out.
|
return inner(this).data;
|
}
|
};
|
SeriesModel.prototype.getAllData = function () {
|
var mainData = this.getData();
|
return mainData && mainData.getLinkedDataAll ? mainData.getLinkedDataAll() : [{
|
data: mainData
|
}];
|
};
|
SeriesModel.prototype.setData = function (data) {
|
var task = getCurrentTask(this);
|
if (task) {
|
var context = task.context;
|
// Consider case: filter, data sample.
|
// FIXME:TS never used, so comment it
|
// if (context.data !== data && task.modifyOutputEnd) {
|
// task.setOutputEnd(data.count());
|
// }
|
context.outputData = data;
|
// Caution: setData should update context.data,
|
// Because getData may be called multiply in a
|
// single stage and expect to get the data just
|
// set. (For example, AxisProxy, x y both call
|
// getData and setDate sequentially).
|
// So the context.data should be fetched from
|
// upstream each time when a stage starts to be
|
// performed.
|
if (task !== this.dataTask) {
|
context.data = data;
|
}
|
}
|
inner(this).data = data;
|
};
|
SeriesModel.prototype.getEncode = function () {
|
var encode = this.get('encode', true);
|
if (encode) {
|
return zrUtil.createHashMap(encode);
|
}
|
};
|
SeriesModel.prototype.getSourceManager = function () {
|
return inner(this).sourceManager;
|
};
|
SeriesModel.prototype.getSource = function () {
|
return this.getSourceManager().getSource();
|
};
|
/**
|
* Get data before processed
|
*/
|
SeriesModel.prototype.getRawData = function () {
|
return inner(this).dataBeforeProcessed;
|
};
|
SeriesModel.prototype.getColorBy = function () {
|
var colorBy = this.get('colorBy');
|
return colorBy || 'series';
|
};
|
SeriesModel.prototype.isColorBySeries = function () {
|
return this.getColorBy() === 'series';
|
};
|
/**
|
* Get base axis if has coordinate system and has axis.
|
* By default use coordSys.getBaseAxis();
|
* Can be overridden for some chart.
|
* @return {type} description
|
*/
|
SeriesModel.prototype.getBaseAxis = function () {
|
var coordSys = this.coordinateSystem;
|
// @ts-ignore
|
return coordSys && coordSys.getBaseAxis && coordSys.getBaseAxis();
|
};
|
/**
|
* Default tooltip formatter
|
*
|
* @param dataIndex
|
* @param multipleSeries
|
* @param dataType
|
* @param renderMode valid values: 'html'(by default) and 'richText'.
|
* 'html' is used for rendering tooltip in extra DOM form, and the result
|
* string is used as DOM HTML content.
|
* 'richText' is used for rendering tooltip in rich text form, for those where
|
* DOM operation is not supported.
|
* @return formatted tooltip with `html` and `markers`
|
* Notice: The override method can also return string
|
*/
|
SeriesModel.prototype.formatTooltip = function (dataIndex, multipleSeries, dataType) {
|
return defaultSeriesFormatTooltip({
|
series: this,
|
dataIndex: dataIndex,
|
multipleSeries: multipleSeries
|
});
|
};
|
SeriesModel.prototype.isAnimationEnabled = function () {
|
var ecModel = this.ecModel;
|
// Disable animation if using echarts in node but not give ssr flag.
|
// In ssr mode, renderToString will generate svg with css animation.
|
if (env.node && !(ecModel && ecModel.ssr)) {
|
return false;
|
}
|
var animationEnabled = this.getShallow('animation');
|
if (animationEnabled) {
|
if (this.getData().count() > this.getShallow('animationThreshold')) {
|
animationEnabled = false;
|
}
|
}
|
return !!animationEnabled;
|
};
|
SeriesModel.prototype.restoreData = function () {
|
this.dataTask.dirty();
|
};
|
SeriesModel.prototype.getColorFromPalette = function (name, scope, requestColorNum) {
|
var ecModel = this.ecModel;
|
// PENDING
|
var color = PaletteMixin.prototype.getColorFromPalette.call(this, name, scope, requestColorNum);
|
if (!color) {
|
color = ecModel.getColorFromPalette(name, scope, requestColorNum);
|
}
|
return color;
|
};
|
/**
|
* Use `data.mapDimensionsAll(coordDim)` instead.
|
* @deprecated
|
*/
|
SeriesModel.prototype.coordDimToDataDim = function (coordDim) {
|
return this.getRawData().mapDimensionsAll(coordDim);
|
};
|
/**
|
* Get progressive rendering count each step
|
*/
|
SeriesModel.prototype.getProgressive = function () {
|
return this.get('progressive');
|
};
|
/**
|
* Get progressive rendering count each step
|
*/
|
SeriesModel.prototype.getProgressiveThreshold = function () {
|
return this.get('progressiveThreshold');
|
};
|
// PENGING If selectedMode is null ?
|
SeriesModel.prototype.select = function (innerDataIndices, dataType) {
|
this._innerSelect(this.getData(dataType), innerDataIndices);
|
};
|
SeriesModel.prototype.unselect = function (innerDataIndices, dataType) {
|
var selectedMap = this.option.selectedMap;
|
if (!selectedMap) {
|
return;
|
}
|
var selectedMode = this.option.selectedMode;
|
var data = this.getData(dataType);
|
if (selectedMode === 'series' || selectedMap === 'all') {
|
this.option.selectedMap = {};
|
this._selectedDataIndicesMap = {};
|
return;
|
}
|
for (var i = 0; i < innerDataIndices.length; i++) {
|
var dataIndex = innerDataIndices[i];
|
var nameOrId = getSelectionKey(data, dataIndex);
|
selectedMap[nameOrId] = false;
|
this._selectedDataIndicesMap[nameOrId] = -1;
|
}
|
};
|
SeriesModel.prototype.toggleSelect = function (innerDataIndices, dataType) {
|
var tmpArr = [];
|
for (var i = 0; i < innerDataIndices.length; i++) {
|
tmpArr[0] = innerDataIndices[i];
|
this.isSelected(innerDataIndices[i], dataType) ? this.unselect(tmpArr, dataType) : this.select(tmpArr, dataType);
|
}
|
};
|
SeriesModel.prototype.getSelectedDataIndices = function () {
|
if (this.option.selectedMap === 'all') {
|
return [].slice.call(this.getData().getIndices());
|
}
|
var selectedDataIndicesMap = this._selectedDataIndicesMap;
|
var nameOrIds = zrUtil.keys(selectedDataIndicesMap);
|
var dataIndices = [];
|
for (var i = 0; i < nameOrIds.length; i++) {
|
var dataIndex = selectedDataIndicesMap[nameOrIds[i]];
|
if (dataIndex >= 0) {
|
dataIndices.push(dataIndex);
|
}
|
}
|
return dataIndices;
|
};
|
SeriesModel.prototype.isSelected = function (dataIndex, dataType) {
|
var selectedMap = this.option.selectedMap;
|
if (!selectedMap) {
|
return false;
|
}
|
var data = this.getData(dataType);
|
return (selectedMap === 'all' || selectedMap[getSelectionKey(data, dataIndex)]) && !data.getItemModel(dataIndex).get(['select', 'disabled']);
|
};
|
SeriesModel.prototype.isUniversalTransitionEnabled = function () {
|
if (this[SERIES_UNIVERSAL_TRANSITION_PROP]) {
|
return true;
|
}
|
var universalTransitionOpt = this.option.universalTransition;
|
// Quick reject
|
if (!universalTransitionOpt) {
|
return false;
|
}
|
if (universalTransitionOpt === true) {
|
return true;
|
}
|
// Can be simply 'universalTransition: true'
|
return universalTransitionOpt && universalTransitionOpt.enabled;
|
};
|
SeriesModel.prototype._innerSelect = function (data, innerDataIndices) {
|
var _a, _b;
|
var option = this.option;
|
var selectedMode = option.selectedMode;
|
var len = innerDataIndices.length;
|
if (!selectedMode || !len) {
|
return;
|
}
|
if (selectedMode === 'series') {
|
option.selectedMap = 'all';
|
} else if (selectedMode === 'multiple') {
|
if (!zrUtil.isObject(option.selectedMap)) {
|
option.selectedMap = {};
|
}
|
var selectedMap = option.selectedMap;
|
for (var i = 0; i < len; i++) {
|
var dataIndex = innerDataIndices[i];
|
// TODO different types of data share same object.
|
var nameOrId = getSelectionKey(data, dataIndex);
|
selectedMap[nameOrId] = true;
|
this._selectedDataIndicesMap[nameOrId] = data.getRawIndex(dataIndex);
|
}
|
} else if (selectedMode === 'single' || selectedMode === true) {
|
var lastDataIndex = innerDataIndices[len - 1];
|
var nameOrId = getSelectionKey(data, lastDataIndex);
|
option.selectedMap = (_a = {}, _a[nameOrId] = true, _a);
|
this._selectedDataIndicesMap = (_b = {}, _b[nameOrId] = data.getRawIndex(lastDataIndex), _b);
|
}
|
};
|
SeriesModel.prototype._initSelectedMapFromData = function (data) {
|
// Ignore select info in data if selectedMap exists.
|
// NOTE It's only for legacy usage. edge data is not supported.
|
if (this.option.selectedMap) {
|
return;
|
}
|
var dataIndices = [];
|
if (data.hasItemOption) {
|
data.each(function (idx) {
|
var rawItem = data.getRawDataItem(idx);
|
if (rawItem && rawItem.selected) {
|
dataIndices.push(idx);
|
}
|
});
|
}
|
if (dataIndices.length > 0) {
|
this._innerSelect(data, dataIndices);
|
}
|
};
|
// /**
|
// * @see {module:echarts/stream/Scheduler}
|
// */
|
// abstract pipeTask: null
|
SeriesModel.registerClass = function (clz) {
|
return ComponentModel.registerClass(clz);
|
};
|
SeriesModel.protoInitialize = function () {
|
var proto = SeriesModel.prototype;
|
proto.type = 'series.__base__';
|
proto.seriesIndex = 0;
|
proto.ignoreStyleOnData = false;
|
proto.hasSymbolVisual = false;
|
proto.defaultSymbol = 'circle';
|
// Make sure the values can be accessed!
|
proto.visualStyleAccessPath = 'itemStyle';
|
proto.visualDrawType = 'fill';
|
}();
|
return SeriesModel;
|
}(ComponentModel);
|
zrUtil.mixin(SeriesModel, DataFormatMixin);
|
zrUtil.mixin(SeriesModel, PaletteMixin);
|
mountExtend(SeriesModel, ComponentModel);
|
/**
|
* MUST be called after `prepareSource` called
|
* Here we need to make auto series, especially for auto legend. But we
|
* do not modify series.name in option to avoid side effects.
|
*/
|
function autoSeriesName(seriesModel) {
|
// User specified name has higher priority, otherwise it may cause
|
// series can not be queried unexpectedly.
|
var name = seriesModel.name;
|
if (!modelUtil.isNameSpecified(seriesModel)) {
|
seriesModel.name = getSeriesAutoName(seriesModel) || name;
|
}
|
}
|
function getSeriesAutoName(seriesModel) {
|
var data = seriesModel.getRawData();
|
var dataDims = data.mapDimensionsAll('seriesName');
|
var nameArr = [];
|
zrUtil.each(dataDims, function (dataDim) {
|
var dimInfo = data.getDimensionInfo(dataDim);
|
dimInfo.displayName && nameArr.push(dimInfo.displayName);
|
});
|
return nameArr.join(' ');
|
}
|
function dataTaskCount(context) {
|
return context.model.getRawData().count();
|
}
|
function dataTaskReset(context) {
|
var seriesModel = context.model;
|
seriesModel.setData(seriesModel.getRawData().cloneShallow());
|
return dataTaskProgress;
|
}
|
function dataTaskProgress(param, context) {
|
// Avoid repeat cloneShallow when data just created in reset.
|
if (context.outputData && param.end > context.outputData.count()) {
|
context.model.getRawData().cloneShallow(context.outputData);
|
}
|
}
|
// TODO refactor
|
function wrapData(data, seriesModel) {
|
zrUtil.each(zrUtil.concatArray(data.CHANGABLE_METHODS, data.DOWNSAMPLE_METHODS), function (methodName) {
|
data.wrapMethod(methodName, zrUtil.curry(onDataChange, seriesModel));
|
});
|
}
|
function onDataChange(seriesModel, newList) {
|
var task = getCurrentTask(seriesModel);
|
if (task) {
|
// Consider case: filter, selectRange
|
task.setOutputEnd((newList || this).count());
|
}
|
return newList;
|
}
|
function getCurrentTask(seriesModel) {
|
var scheduler = (seriesModel.ecModel || {}).scheduler;
|
var pipeline = scheduler && scheduler.getPipeline(seriesModel.uid);
|
if (pipeline) {
|
// When pipline finished, the currrentTask keep the last
|
// task (renderTask).
|
var task = pipeline.currentTask;
|
if (task) {
|
var agentStubMap = task.agentStubMap;
|
if (agentStubMap) {
|
task = agentStubMap.get(seriesModel.uid);
|
}
|
}
|
return task;
|
}
|
}
|
export default SeriesModel;
|
