|
/*
|
* 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 { each, map, isFunction, createHashMap, noop, assert } from 'zrender/lib/core/util.js';
|
import { createTask } from './task.js';
|
import { getUID } from '../util/component.js';
|
import GlobalModel from '../model/Global.js';
|
import ExtensionAPI from './ExtensionAPI.js';
|
import { normalizeToArray } from '../util/model.js';
|
;
|
var Scheduler = /** @class */function () {
|
function Scheduler(ecInstance, api, dataProcessorHandlers, visualHandlers) {
|
// key: handlerUID
|
this._stageTaskMap = createHashMap();
|
this.ecInstance = ecInstance;
|
this.api = api;
|
// Fix current processors in case that in some rear cases that
|
// processors might be registered after echarts instance created.
|
// Register processors incrementally for a echarts instance is
|
// not supported by this stream architecture.
|
dataProcessorHandlers = this._dataProcessorHandlers = dataProcessorHandlers.slice();
|
visualHandlers = this._visualHandlers = visualHandlers.slice();
|
this._allHandlers = dataProcessorHandlers.concat(visualHandlers);
|
}
|
Scheduler.prototype.restoreData = function (ecModel, payload) {
|
// TODO: Only restore needed series and components, but not all components.
|
// Currently `restoreData` of all of the series and component will be called.
|
// But some independent components like `title`, `legend`, `graphic`, `toolbox`,
|
// `tooltip`, `axisPointer`, etc, do not need series refresh when `setOption`,
|
// and some components like coordinate system, axes, dataZoom, visualMap only
|
// need their target series refresh.
|
// (1) If we are implementing this feature some day, we should consider these cases:
|
// if a data processor depends on a component (e.g., dataZoomProcessor depends
|
// on the settings of `dataZoom`), it should be re-performed if the component
|
// is modified by `setOption`.
|
// (2) If a processor depends on sevral series, speicified by its `getTargetSeries`,
|
// it should be re-performed when the result array of `getTargetSeries` changed.
|
// We use `dependencies` to cover these issues.
|
// (3) How to update target series when coordinate system related components modified.
|
// TODO: simply the dirty mechanism? Check whether only the case here can set tasks dirty,
|
// and this case all of the tasks will be set as dirty.
|
ecModel.restoreData(payload);
|
// Theoretically an overall task not only depends on each of its target series, but also
|
// depends on all of the series.
|
// The overall task is not in pipeline, and `ecModel.restoreData` only set pipeline tasks
|
// dirty. If `getTargetSeries` of an overall task returns nothing, we should also ensure
|
// that the overall task is set as dirty and to be performed, otherwise it probably cause
|
// state chaos. So we have to set dirty of all of the overall tasks manually, otherwise it
|
// probably cause state chaos (consider `dataZoomProcessor`).
|
this._stageTaskMap.each(function (taskRecord) {
|
var overallTask = taskRecord.overallTask;
|
overallTask && overallTask.dirty();
|
});
|
};
|
// If seriesModel provided, incremental threshold is check by series data.
|
Scheduler.prototype.getPerformArgs = function (task, isBlock) {
|
// For overall task
|
if (!task.__pipeline) {
|
return;
|
}
|
var pipeline = this._pipelineMap.get(task.__pipeline.id);
|
var pCtx = pipeline.context;
|
var incremental = !isBlock && pipeline.progressiveEnabled && (!pCtx || pCtx.progressiveRender) && task.__idxInPipeline > pipeline.blockIndex;
|
var step = incremental ? pipeline.step : null;
|
var modDataCount = pCtx && pCtx.modDataCount;
|
var modBy = modDataCount != null ? Math.ceil(modDataCount / step) : null;
|
return {
|
step: step,
|
modBy: modBy,
|
modDataCount: modDataCount
|
};
|
};
|
Scheduler.prototype.getPipeline = function (pipelineId) {
|
return this._pipelineMap.get(pipelineId);
|
};
|
/**
|
* Current, progressive rendering starts from visual and layout.
|
* Always detect render mode in the same stage, avoiding that incorrect
|
* detection caused by data filtering.
|
* Caution:
|
* `updateStreamModes` use `seriesModel.getData()`.
|
*/
|
Scheduler.prototype.updateStreamModes = function (seriesModel, view) {
|
var pipeline = this._pipelineMap.get(seriesModel.uid);
|
var data = seriesModel.getData();
|
var dataLen = data.count();
|
// `progressiveRender` means that can render progressively in each
|
// animation frame. Note that some types of series do not provide
|
// `view.incrementalPrepareRender` but support `chart.appendData`. We
|
// use the term `incremental` but not `progressive` to describe the
|
// case that `chart.appendData`.
|
var progressiveRender = pipeline.progressiveEnabled && view.incrementalPrepareRender && dataLen >= pipeline.threshold;
|
var large = seriesModel.get('large') && dataLen >= seriesModel.get('largeThreshold');
|
// TODO: modDataCount should not updated if `appendData`, otherwise cause whole repaint.
|
// see `test/candlestick-large3.html`
|
var modDataCount = seriesModel.get('progressiveChunkMode') === 'mod' ? dataLen : null;
|
seriesModel.pipelineContext = pipeline.context = {
|
progressiveRender: progressiveRender,
|
modDataCount: modDataCount,
|
large: large
|
};
|
};
|
Scheduler.prototype.restorePipelines = function (ecModel) {
|
var scheduler = this;
|
var pipelineMap = scheduler._pipelineMap = createHashMap();
|
ecModel.eachSeries(function (seriesModel) {
|
var progressive = seriesModel.getProgressive();
|
var pipelineId = seriesModel.uid;
|
pipelineMap.set(pipelineId, {
|
id: pipelineId,
|
head: null,
|
tail: null,
|
threshold: seriesModel.getProgressiveThreshold(),
|
progressiveEnabled: progressive && !(seriesModel.preventIncremental && seriesModel.preventIncremental()),
|
blockIndex: -1,
|
step: Math.round(progressive || 700),
|
count: 0
|
});
|
scheduler._pipe(seriesModel, seriesModel.dataTask);
|
});
|
};
|
Scheduler.prototype.prepareStageTasks = function () {
|
var stageTaskMap = this._stageTaskMap;
|
var ecModel = this.api.getModel();
|
var api = this.api;
|
each(this._allHandlers, function (handler) {
|
var record = stageTaskMap.get(handler.uid) || stageTaskMap.set(handler.uid, {});
|
var errMsg = '';
|
if (process.env.NODE_ENV !== 'production') {
|
// Currently do not need to support to sepecify them both.
|
errMsg = '"reset" and "overallReset" must not be both specified.';
|
}
|
assert(!(handler.reset && handler.overallReset), errMsg);
|
handler.reset && this._createSeriesStageTask(handler, record, ecModel, api);
|
handler.overallReset && this._createOverallStageTask(handler, record, ecModel, api);
|
}, this);
|
};
|
Scheduler.prototype.prepareView = function (view, model, ecModel, api) {
|
var renderTask = view.renderTask;
|
var context = renderTask.context;
|
context.model = model;
|
context.ecModel = ecModel;
|
context.api = api;
|
renderTask.__block = !view.incrementalPrepareRender;
|
this._pipe(model, renderTask);
|
};
|
Scheduler.prototype.performDataProcessorTasks = function (ecModel, payload) {
|
// If we do not use `block` here, it should be considered when to update modes.
|
this._performStageTasks(this._dataProcessorHandlers, ecModel, payload, {
|
block: true
|
});
|
};
|
Scheduler.prototype.performVisualTasks = function (ecModel, payload, opt) {
|
this._performStageTasks(this._visualHandlers, ecModel, payload, opt);
|
};
|
Scheduler.prototype._performStageTasks = function (stageHandlers, ecModel, payload, opt) {
|
opt = opt || {};
|
var unfinished = false;
|
var scheduler = this;
|
each(stageHandlers, function (stageHandler, idx) {
|
if (opt.visualType && opt.visualType !== stageHandler.visualType) {
|
return;
|
}
|
var stageHandlerRecord = scheduler._stageTaskMap.get(stageHandler.uid);
|
var seriesTaskMap = stageHandlerRecord.seriesTaskMap;
|
var overallTask = stageHandlerRecord.overallTask;
|
if (overallTask) {
|
var overallNeedDirty_1;
|
var agentStubMap = overallTask.agentStubMap;
|
agentStubMap.each(function (stub) {
|
if (needSetDirty(opt, stub)) {
|
stub.dirty();
|
overallNeedDirty_1 = true;
|
}
|
});
|
overallNeedDirty_1 && overallTask.dirty();
|
scheduler.updatePayload(overallTask, payload);
|
var performArgs_1 = scheduler.getPerformArgs(overallTask, opt.block);
|
// Execute stubs firstly, which may set the overall task dirty,
|
// then execute the overall task. And stub will call seriesModel.setData,
|
// which ensures that in the overallTask seriesModel.getData() will not
|
// return incorrect data.
|
agentStubMap.each(function (stub) {
|
stub.perform(performArgs_1);
|
});
|
if (overallTask.perform(performArgs_1)) {
|
unfinished = true;
|
}
|
} else if (seriesTaskMap) {
|
seriesTaskMap.each(function (task, pipelineId) {
|
if (needSetDirty(opt, task)) {
|
task.dirty();
|
}
|
var performArgs = scheduler.getPerformArgs(task, opt.block);
|
// FIXME
|
// if intending to declare `performRawSeries` in handlers, only
|
// stream-independent (specifically, data item independent) operations can be
|
// performed. Because if a series is filtered, most of the tasks will not
|
// be performed. A stream-dependent operation probably cause wrong biz logic.
|
// Perhaps we should not provide a separate callback for this case instead
|
// of providing the config `performRawSeries`. The stream-dependent operations
|
// and stream-independent operations should better not be mixed.
|
performArgs.skip = !stageHandler.performRawSeries && ecModel.isSeriesFiltered(task.context.model);
|
scheduler.updatePayload(task, payload);
|
if (task.perform(performArgs)) {
|
unfinished = true;
|
}
|
});
|
}
|
});
|
function needSetDirty(opt, task) {
|
return opt.setDirty && (!opt.dirtyMap || opt.dirtyMap.get(task.__pipeline.id));
|
}
|
this.unfinished = unfinished || this.unfinished;
|
};
|
Scheduler.prototype.performSeriesTasks = function (ecModel) {
|
var unfinished;
|
ecModel.eachSeries(function (seriesModel) {
|
// Progress to the end for dataInit and dataRestore.
|
unfinished = seriesModel.dataTask.perform() || unfinished;
|
});
|
this.unfinished = unfinished || this.unfinished;
|
};
|
Scheduler.prototype.plan = function () {
|
// Travel pipelines, check block.
|
this._pipelineMap.each(function (pipeline) {
|
var task = pipeline.tail;
|
do {
|
if (task.__block) {
|
pipeline.blockIndex = task.__idxInPipeline;
|
break;
|
}
|
task = task.getUpstream();
|
} while (task);
|
});
|
};
|
Scheduler.prototype.updatePayload = function (task, payload) {
|
payload !== 'remain' && (task.context.payload = payload);
|
};
|
Scheduler.prototype._createSeriesStageTask = function (stageHandler, stageHandlerRecord, ecModel, api) {
|
var scheduler = this;
|
var oldSeriesTaskMap = stageHandlerRecord.seriesTaskMap;
|
// The count of stages are totally about only several dozen, so
|
// do not need to reuse the map.
|
var newSeriesTaskMap = stageHandlerRecord.seriesTaskMap = createHashMap();
|
var seriesType = stageHandler.seriesType;
|
var getTargetSeries = stageHandler.getTargetSeries;
|
// If a stageHandler should cover all series, `createOnAllSeries` should be declared mandatorily,
|
// to avoid some typo or abuse. Otherwise if an extension do not specify a `seriesType`,
|
// it works but it may cause other irrelevant charts blocked.
|
if (stageHandler.createOnAllSeries) {
|
ecModel.eachRawSeries(create);
|
} else if (seriesType) {
|
ecModel.eachRawSeriesByType(seriesType, create);
|
} else if (getTargetSeries) {
|
getTargetSeries(ecModel, api).each(create);
|
}
|
function create(seriesModel) {
|
var pipelineId = seriesModel.uid;
|
// Init tasks for each seriesModel only once.
|
// Reuse original task instance.
|
var task = newSeriesTaskMap.set(pipelineId, oldSeriesTaskMap && oldSeriesTaskMap.get(pipelineId) || createTask({
|
plan: seriesTaskPlan,
|
reset: seriesTaskReset,
|
count: seriesTaskCount
|
}));
|
task.context = {
|
model: seriesModel,
|
ecModel: ecModel,
|
api: api,
|
// PENDING: `useClearVisual` not used?
|
useClearVisual: stageHandler.isVisual && !stageHandler.isLayout,
|
plan: stageHandler.plan,
|
reset: stageHandler.reset,
|
scheduler: scheduler
|
};
|
scheduler._pipe(seriesModel, task);
|
}
|
};
|
Scheduler.prototype._createOverallStageTask = function (stageHandler, stageHandlerRecord, ecModel, api) {
|
var scheduler = this;
|
var overallTask = stageHandlerRecord.overallTask = stageHandlerRecord.overallTask
|
// For overall task, the function only be called on reset stage.
|
|| createTask({
|
reset: overallTaskReset
|
});
|
overallTask.context = {
|
ecModel: ecModel,
|
api: api,
|
overallReset: stageHandler.overallReset,
|
scheduler: scheduler
|
};
|
var oldAgentStubMap = overallTask.agentStubMap;
|
// The count of stages are totally about only several dozen, so
|
// do not need to reuse the map.
|
var newAgentStubMap = overallTask.agentStubMap = createHashMap();
|
var seriesType = stageHandler.seriesType;
|
var getTargetSeries = stageHandler.getTargetSeries;
|
var overallProgress = true;
|
var shouldOverallTaskDirty = false;
|
// FIXME:TS never used, so comment it
|
// let modifyOutputEnd = stageHandler.modifyOutputEnd;
|
// An overall task with seriesType detected or has `getTargetSeries`, we add
|
// stub in each pipelines, it will set the overall task dirty when the pipeline
|
// progress. Moreover, to avoid call the overall task each frame (too frequent),
|
// we set the pipeline block.
|
var errMsg = '';
|
if (process.env.NODE_ENV !== 'production') {
|
errMsg = '"createOnAllSeries" is not supported for "overallReset", ' + 'because it will block all streams.';
|
}
|
assert(!stageHandler.createOnAllSeries, errMsg);
|
if (seriesType) {
|
ecModel.eachRawSeriesByType(seriesType, createStub);
|
} else if (getTargetSeries) {
|
getTargetSeries(ecModel, api).each(createStub);
|
}
|
// Otherwise, (usually it is legacy case), the overall task will only be
|
// executed when upstream is dirty. Otherwise the progressive rendering of all
|
// pipelines will be disabled unexpectedly. But it still needs stubs to receive
|
// dirty info from upstream.
|
else {
|
overallProgress = false;
|
each(ecModel.getSeries(), createStub);
|
}
|
function createStub(seriesModel) {
|
var pipelineId = seriesModel.uid;
|
var stub = newAgentStubMap.set(pipelineId, oldAgentStubMap && oldAgentStubMap.get(pipelineId) || (
|
// When the result of `getTargetSeries` changed, the overallTask
|
// should be set as dirty and re-performed.
|
shouldOverallTaskDirty = true, createTask({
|
reset: stubReset,
|
onDirty: stubOnDirty
|
})));
|
stub.context = {
|
model: seriesModel,
|
overallProgress: overallProgress
|
// FIXME:TS never used, so comment it
|
// modifyOutputEnd: modifyOutputEnd
|
};
|
stub.agent = overallTask;
|
stub.__block = overallProgress;
|
scheduler._pipe(seriesModel, stub);
|
}
|
if (shouldOverallTaskDirty) {
|
overallTask.dirty();
|
}
|
};
|
Scheduler.prototype._pipe = function (seriesModel, task) {
|
var pipelineId = seriesModel.uid;
|
var pipeline = this._pipelineMap.get(pipelineId);
|
!pipeline.head && (pipeline.head = task);
|
pipeline.tail && pipeline.tail.pipe(task);
|
pipeline.tail = task;
|
task.__idxInPipeline = pipeline.count++;
|
task.__pipeline = pipeline;
|
};
|
Scheduler.wrapStageHandler = function (stageHandler, visualType) {
|
if (isFunction(stageHandler)) {
|
stageHandler = {
|
overallReset: stageHandler,
|
seriesType: detectSeriseType(stageHandler)
|
};
|
}
|
stageHandler.uid = getUID('stageHandler');
|
visualType && (stageHandler.visualType = visualType);
|
return stageHandler;
|
};
|
;
|
return Scheduler;
|
}();
|
function overallTaskReset(context) {
|
context.overallReset(context.ecModel, context.api, context.payload);
|
}
|
function stubReset(context) {
|
return context.overallProgress && stubProgress;
|
}
|
function stubProgress() {
|
this.agent.dirty();
|
this.getDownstream().dirty();
|
}
|
function stubOnDirty() {
|
this.agent && this.agent.dirty();
|
}
|
function seriesTaskPlan(context) {
|
return context.plan ? context.plan(context.model, context.ecModel, context.api, context.payload) : null;
|
}
|
function seriesTaskReset(context) {
|
if (context.useClearVisual) {
|
context.data.clearAllVisual();
|
}
|
var resetDefines = context.resetDefines = normalizeToArray(context.reset(context.model, context.ecModel, context.api, context.payload));
|
return resetDefines.length > 1 ? map(resetDefines, function (v, idx) {
|
return makeSeriesTaskProgress(idx);
|
}) : singleSeriesTaskProgress;
|
}
|
var singleSeriesTaskProgress = makeSeriesTaskProgress(0);
|
function makeSeriesTaskProgress(resetDefineIdx) {
|
return function (params, context) {
|
var data = context.data;
|
var resetDefine = context.resetDefines[resetDefineIdx];
|
if (resetDefine && resetDefine.dataEach) {
|
for (var i = params.start; i < params.end; i++) {
|
resetDefine.dataEach(data, i);
|
}
|
} else if (resetDefine && resetDefine.progress) {
|
resetDefine.progress(params, data);
|
}
|
};
|
}
|
function seriesTaskCount(context) {
|
return context.data.count();
|
}
|
/**
|
* Only some legacy stage handlers (usually in echarts extensions) are pure function.
|
* To ensure that they can work normally, they should work in block mode, that is,
|
* they should not be started util the previous tasks finished. So they cause the
|
* progressive rendering disabled. We try to detect the series type, to narrow down
|
* the block range to only the series type they concern, but not all series.
|
*/
|
function detectSeriseType(legacyFunc) {
|
seriesType = null;
|
try {
|
// Assume there is no async when calling `eachSeriesByType`.
|
legacyFunc(ecModelMock, apiMock);
|
} catch (e) {}
|
return seriesType;
|
}
|
var ecModelMock = {};
|
var apiMock = {};
|
var seriesType;
|
mockMethods(ecModelMock, GlobalModel);
|
mockMethods(apiMock, ExtensionAPI);
|
ecModelMock.eachSeriesByType = ecModelMock.eachRawSeriesByType = function (type) {
|
seriesType = type;
|
};
|
ecModelMock.eachComponent = function (cond) {
|
if (cond.mainType === 'series' && cond.subType) {
|
seriesType = cond.subType;
|
}
|
};
|
function mockMethods(target, Clz) {
|
/* eslint-disable */
|
for (var name_1 in Clz.prototype) {
|
// Do not use hasOwnProperty
|
target[name_1] = noop;
|
}
|
/* eslint-enable */
|
}
|
export default Scheduler;
|
