{"version":3,"sources":["webpack:///./node_modules/echarts/lib/stream/Scheduler.js","webpack:///./node_modules/echarts/lib/stream/task.js"],"names":["_util","each","map","isFunction","createHashMap","noop","_task","createTask","_component","getUID","GlobalModel","ExtensionAPI","_model","normalizeToArray","Scheduler","ecInstance","api","dataProcessorHandlers","visualHandlers","this","unfinished","_dataProcessorHandlers","slice","_visualHandlers","_allHandlers","concat","_stageTaskMap","proto","prototype","performStageTasks","scheduler","stageHandlers","ecModel","payload","opt","needSetDirty","task","setDirty","dirtyMap","get","__pipeline","id","stageHandler","idx","visualType","stageHandlerRecord","uid","seriesTaskMap","overallTask","overallNeedDirty","agentStubMap","stub","dirty","updatePayload","performArgs","getPerformArgs","block","perform","pipelineId","skip","performRawSeries","isSeriesFiltered","context","model","restoreData","taskRecord","isBlock","pipeline","_pipelineMap","pCtx","incremental","progressiveEnabled","progressiveRender","__idxInPipeline","blockIndex","step","modDataCount","modBy","Math","ceil","getPipeline","updateStreamModes","seriesModel","view","data","getData","dataLen","count","incrementalPrepareRender","threshold","large","pipelineContext","restorePipelines","pipelineMap","eachSeries","progressive","getProgressive","set","head","tail","getProgressiveThreshold","preventIncremental","round","pipe","dataTask","prepareStageTasks","stageTaskMap","getModel","handler","record","reset","createSeriesStageTask","overallReset","createOverallStageTask","prepareView","renderTask","__block","performDataProcessorTasks","performVisualTasks","performSeriesTasks","plan","getUpstream","seriesType","getTargetSeries","create","seriesTaskPlan","seriesTaskReset","seriesTaskCount","useClearVisual","isVisual","isLayout","createOnAllSeries","eachRawSeries","eachRawSeriesByType","dispose","removeKey","overallTaskReset","overallProgress","modifyOutputEnd","createStub","stubReset","onDirty","stubOnDirty","agent","getSeries","upstreamContext","stubProgress","getDownstream","clearAllVisual","resetDefines","length","v","makeSeriesTaskProgress","singleSeriesTaskProgress","resetDefineIdx","params","resetDefine","dataEach","i","start","end","progress","detectSeriseType","legacyFunc","ecModelMock","apiMock","e","wrapStageHandler","mockMethods","target","Clz","name","eachSeriesByType","type","eachComponent","cond","mainType","subType","_default","module","exports","isArray","assert","_config","__DEV__","define","Task","_reset","_plan","_count","_onDirty","_dirty","taskProto","planResult","upTask","_upstream","outputData","currentTask","forceFirstProgress","lastModBy","normalizeModBy","_modBy","lastModDataCount","_modDataCount","val","_dueEnd","_outputDueEnd","Infinity","_progress","_dueIndex","min","doProgress","outputDueEnd","_settedOutputEnd","iterator","current","winCount","it","s","sStep","sCount","next","modNext","sequentialNext","dataIndex","result","taskIns","_callingProgress","downstream","_downstream","downTask","_disposed","setOutputEnd"],"mappings":"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","file":"js/chunk-6642863e.3d1a98fa.js","sourcesContent":["\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar _util = require(\"zrender/lib/core/util\");\n\nvar each = _util.each;\nvar map = _util.map;\nvar isFunction = _util.isFunction;\nvar createHashMap = _util.createHashMap;\nvar noop = _util.noop;\n\nvar _task = require(\"./task\");\n\nvar createTask = _task.createTask;\n\nvar _component = require(\"../util/component\");\n\nvar getUID = _component.getUID;\n\nvar GlobalModel = require(\"../model/Global\");\n\nvar ExtensionAPI = require(\"../ExtensionAPI\");\n\nvar _model = require(\"../util/model\");\n\nvar normalizeToArray = _model.normalizeToArray;\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/**\n * @module echarts/stream/Scheduler\n */\n\n/**\n * @constructor\n */\nfunction Scheduler(ecInstance, api, dataProcessorHandlers, visualHandlers) {\n  this.ecInstance = ecInstance;\n  this.api = api;\n  this.unfinished; // Fix current processors in case that in some rear cases that\n  // processors might be registered after echarts instance created.\n  // Register processors incrementally for a echarts instance is\n  // not supported by this stream architecture.\n\n  var dataProcessorHandlers = this._dataProcessorHandlers = dataProcessorHandlers.slice();\n  var visualHandlers = this._visualHandlers = visualHandlers.slice();\n  this._allHandlers = dataProcessorHandlers.concat(visualHandlers);\n  /**\n   * @private\n   * @type {\n   *     [handlerUID: string]: {\n   *         seriesTaskMap?: {\n   *             [seriesUID: string]: Task\n   *         },\n   *         overallTask?: Task\n   *     }\n   * }\n   */\n\n  this._stageTaskMap = createHashMap();\n}\n\nvar proto = Scheduler.prototype;\n/**\n * @param {module:echarts/model/Global} ecModel\n * @param {Object} payload\n */\n\nproto.restoreData = function (ecModel, payload) {\n  // TODO: Only restroe needed series and components, but not all components.\n  // Currently `restoreData` of all of the series and component will be called.\n  // But some independent components like `title`, `legend`, `graphic`, `toolbox`,\n  // `tooltip`, `axisPointer`, etc, do not need series refresh when `setOption`,\n  // and some components like coordinate system, axes, dataZoom, visualMap only\n  // need their target series refresh.\n  // (1) If we are implementing this feature some day, we should consider these cases:\n  // if a data processor depends on a component (e.g., dataZoomProcessor depends\n  // on the settings of `dataZoom`), it should be re-performed if the component\n  // is modified by `setOption`.\n  // (2) If a processor depends on sevral series, speicified by its `getTargetSeries`,\n  // it should be re-performed when the result array of `getTargetSeries` changed.\n  // We use `dependencies` to cover these issues.\n  // (3) How to update target series when coordinate system related components modified.\n  // TODO: simply the dirty mechanism? Check whether only the case here can set tasks dirty,\n  // and this case all of the tasks will be set as dirty.\n  ecModel.restoreData(payload); // Theoretically an overall task not only depends on each of its target series, but also\n  // depends on all of the series.\n  // The overall task is not in pipeline, and `ecModel.restoreData` only set pipeline tasks\n  // dirty. If `getTargetSeries` of an overall task returns nothing, we should also ensure\n  // that the overall task is set as dirty and to be performed, otherwise it probably cause\n  // state chaos. So we have to set dirty of all of the overall tasks manually, otherwise it\n  // probably cause state chaos (consider `dataZoomProcessor`).\n\n  this._stageTaskMap.each(function (taskRecord) {\n    var overallTask = taskRecord.overallTask;\n    overallTask && overallTask.dirty();\n  });\n}; // If seriesModel provided, incremental threshold is check by series data.\n\n\nproto.getPerformArgs = function (task, isBlock) {\n  // For overall task\n  if (!task.__pipeline) {\n    return;\n  }\n\n  var pipeline = this._pipelineMap.get(task.__pipeline.id);\n\n  var pCtx = pipeline.context;\n  var incremental = !isBlock && pipeline.progressiveEnabled && (!pCtx || pCtx.progressiveRender) && task.__idxInPipeline > pipeline.blockIndex;\n  var step = incremental ? pipeline.step : null;\n  var modDataCount = pCtx && pCtx.modDataCount;\n  var modBy = modDataCount != null ? Math.ceil(modDataCount / step) : null;\n  return {\n    step: step,\n    modBy: modBy,\n    modDataCount: modDataCount\n  };\n};\n\nproto.getPipeline = function (pipelineId) {\n  return this._pipelineMap.get(pipelineId);\n};\n/**\n * Current, progressive rendering starts from visual and layout.\n * Always detect render mode in the same stage, avoiding that incorrect\n * detection caused by data filtering.\n * Caution:\n * `updateStreamModes` use `seriesModel.getData()`.\n */\n\n\nproto.updateStreamModes = function (seriesModel, view) {\n  var pipeline = this._pipelineMap.get(seriesModel.uid);\n\n  var data = seriesModel.getData();\n  var dataLen = data.count(); // `progressiveRender` means that can render progressively in each\n  // animation frame. Note that some types of series do not provide\n  // `view.incrementalPrepareRender` but support `chart.appendData`. We\n  // use the term `incremental` but not `progressive` to describe the\n  // case that `chart.appendData`.\n\n  var progressiveRender = pipeline.progressiveEnabled && view.incrementalPrepareRender && dataLen >= pipeline.threshold;\n  var large = seriesModel.get('large') && dataLen >= seriesModel.get('largeThreshold'); // TODO: modDataCount should not updated if `appendData`, otherwise cause whole repaint.\n  // see `test/candlestick-large3.html`\n\n  var modDataCount = seriesModel.get('progressiveChunkMode') === 'mod' ? dataLen : null;\n  seriesModel.pipelineContext = pipeline.context = {\n    progressiveRender: progressiveRender,\n    modDataCount: modDataCount,\n    large: large\n  };\n};\n\nproto.restorePipelines = function (ecModel) {\n  var scheduler = this;\n  var pipelineMap = scheduler._pipelineMap = createHashMap();\n  ecModel.eachSeries(function (seriesModel) {\n    var progressive = seriesModel.getProgressive();\n    var pipelineId = seriesModel.uid;\n    pipelineMap.set(pipelineId, {\n      id: pipelineId,\n      head: null,\n      tail: null,\n      threshold: seriesModel.getProgressiveThreshold(),\n      progressiveEnabled: progressive && !(seriesModel.preventIncremental && seriesModel.preventIncremental()),\n      blockIndex: -1,\n      step: Math.round(progressive || 700),\n      count: 0\n    });\n    pipe(scheduler, seriesModel, seriesModel.dataTask);\n  });\n};\n\nproto.prepareStageTasks = function () {\n  var stageTaskMap = this._stageTaskMap;\n  var ecModel = this.ecInstance.getModel();\n  var api = this.api;\n  each(this._allHandlers, function (handler) {\n    var record = stageTaskMap.get(handler.uid) || stageTaskMap.set(handler.uid, []);\n    handler.reset && createSeriesStageTask(this, handler, record, ecModel, api);\n    handler.overallReset && createOverallStageTask(this, handler, record, ecModel, api);\n  }, this);\n};\n\nproto.prepareView = function (view, model, ecModel, api) {\n  var renderTask = view.renderTask;\n  var context = renderTask.context;\n  context.model = model;\n  context.ecModel = ecModel;\n  context.api = api;\n  renderTask.__block = !view.incrementalPrepareRender;\n  pipe(this, model, renderTask);\n};\n\nproto.performDataProcessorTasks = function (ecModel, payload) {\n  // If we do not use `block` here, it should be considered when to update modes.\n  performStageTasks(this, this._dataProcessorHandlers, ecModel, payload, {\n    block: true\n  });\n}; // opt\n// opt.visualType: 'visual' or 'layout'\n// opt.setDirty\n\n\nproto.performVisualTasks = function (ecModel, payload, opt) {\n  performStageTasks(this, this._visualHandlers, ecModel, payload, opt);\n};\n\nfunction performStageTasks(scheduler, stageHandlers, ecModel, payload, opt) {\n  opt = opt || {};\n  var unfinished;\n  each(stageHandlers, function (stageHandler, idx) {\n    if (opt.visualType && opt.visualType !== stageHandler.visualType) {\n      return;\n    }\n\n    var stageHandlerRecord = scheduler._stageTaskMap.get(stageHandler.uid);\n\n    var seriesTaskMap = stageHandlerRecord.seriesTaskMap;\n    var overallTask = stageHandlerRecord.overallTask;\n\n    if (overallTask) {\n      var overallNeedDirty;\n      var agentStubMap = overallTask.agentStubMap;\n      agentStubMap.each(function (stub) {\n        if (needSetDirty(opt, stub)) {\n          stub.dirty();\n          overallNeedDirty = true;\n        }\n      });\n      overallNeedDirty && overallTask.dirty();\n      updatePayload(overallTask, payload);\n      var performArgs = scheduler.getPerformArgs(overallTask, opt.block); // Execute stubs firstly, which may set the overall task dirty,\n      // then execute the overall task. And stub will call seriesModel.setData,\n      // which ensures that in the overallTask seriesModel.getData() will not\n      // return incorrect data.\n\n      agentStubMap.each(function (stub) {\n        stub.perform(performArgs);\n      });\n      unfinished |= overallTask.perform(performArgs);\n    } else if (seriesTaskMap) {\n      seriesTaskMap.each(function (task, pipelineId) {\n        if (needSetDirty(opt, task)) {\n          task.dirty();\n        }\n\n        var performArgs = scheduler.getPerformArgs(task, opt.block); // FIXME\n        // if intending to decalare `performRawSeries` in handlers, only\n        // stream-independent (specifically, data item independent) operations can be\n        // performed. Because is a series is filtered, most of the tasks will not\n        // be performed. A stream-dependent operation probably cause wrong biz logic.\n        // Perhaps we should not provide a separate callback for this case instead\n        // of providing the config `performRawSeries`. The stream-dependent operaions\n        // and stream-independent operations should better not be mixed.\n\n        performArgs.skip = !stageHandler.performRawSeries && ecModel.isSeriesFiltered(task.context.model);\n        updatePayload(task, payload);\n        unfinished |= task.perform(performArgs);\n      });\n    }\n  });\n\n  function needSetDirty(opt, task) {\n    return opt.setDirty && (!opt.dirtyMap || opt.dirtyMap.get(task.__pipeline.id));\n  }\n\n  scheduler.unfinished |= unfinished;\n}\n\nproto.performSeriesTasks = function (ecModel) {\n  var unfinished;\n  ecModel.eachSeries(function (seriesModel) {\n    // Progress to the end for dataInit and dataRestore.\n    unfinished |= seriesModel.dataTask.perform();\n  });\n  this.unfinished |= unfinished;\n};\n\nproto.plan = function () {\n  // Travel pipelines, check block.\n  this._pipelineMap.each(function (pipeline) {\n    var task = pipeline.tail;\n\n    do {\n      if (task.__block) {\n        pipeline.blockIndex = task.__idxInPipeline;\n        break;\n      }\n\n      task = task.getUpstream();\n    } while (task);\n  });\n};\n\nvar updatePayload = proto.updatePayload = function (task, payload) {\n  payload !== 'remain' && (task.context.payload = payload);\n};\n\nfunction createSeriesStageTask(scheduler, stageHandler, stageHandlerRecord, ecModel, api) {\n  var seriesTaskMap = stageHandlerRecord.seriesTaskMap || (stageHandlerRecord.seriesTaskMap = createHashMap());\n  var seriesType = stageHandler.seriesType;\n  var getTargetSeries = stageHandler.getTargetSeries; // If a stageHandler should cover all series, `createOnAllSeries` should be declared mandatorily,\n  // to avoid some typo or abuse. Otherwise if an extension do not specify a `seriesType`,\n  // it works but it may cause other irrelevant charts blocked.\n\n  if (stageHandler.createOnAllSeries) {\n    ecModel.eachRawSeries(create);\n  } else if (seriesType) {\n    ecModel.eachRawSeriesByType(seriesType, create);\n  } else if (getTargetSeries) {\n    getTargetSeries(ecModel, api).each(create);\n  }\n\n  function create(seriesModel) {\n    var pipelineId = seriesModel.uid; // Init tasks for each seriesModel only once.\n    // Reuse original task instance.\n\n    var task = seriesTaskMap.get(pipelineId) || seriesTaskMap.set(pipelineId, createTask({\n      plan: seriesTaskPlan,\n      reset: seriesTaskReset,\n      count: seriesTaskCount\n    }));\n    task.context = {\n      model: seriesModel,\n      ecModel: ecModel,\n      api: api,\n      useClearVisual: stageHandler.isVisual && !stageHandler.isLayout,\n      plan: stageHandler.plan,\n      reset: stageHandler.reset,\n      scheduler: scheduler\n    };\n    pipe(scheduler, seriesModel, task);\n  } // Clear unused series tasks.\n\n\n  var pipelineMap = scheduler._pipelineMap;\n  seriesTaskMap.each(function (task, pipelineId) {\n    if (!pipelineMap.get(pipelineId)) {\n      task.dispose();\n      seriesTaskMap.removeKey(pipelineId);\n    }\n  });\n}\n\nfunction createOverallStageTask(scheduler, stageHandler, stageHandlerRecord, ecModel, api) {\n  var overallTask = stageHandlerRecord.overallTask = stageHandlerRecord.overallTask // For overall task, the function only be called on reset stage.\n  || createTask({\n    reset: overallTaskReset\n  });\n  overallTask.context = {\n    ecModel: ecModel,\n    api: api,\n    overallReset: stageHandler.overallReset,\n    scheduler: scheduler\n  }; // Reuse orignal stubs.\n\n  var agentStubMap = overallTask.agentStubMap = overallTask.agentStubMap || createHashMap();\n  var seriesType = stageHandler.seriesType;\n  var getTargetSeries = stageHandler.getTargetSeries;\n  var overallProgress = true;\n  var modifyOutputEnd = stageHandler.modifyOutputEnd; // An overall task with seriesType detected or has `getTargetSeries`, we add\n  // stub in each pipelines, it will set the overall task dirty when the pipeline\n  // progress. Moreover, to avoid call the overall task each frame (too frequent),\n  // we set the pipeline block.\n\n  if (seriesType) {\n    ecModel.eachRawSeriesByType(seriesType, createStub);\n  } else if (getTargetSeries) {\n    getTargetSeries(ecModel, api).each(createStub);\n  } // Otherwise, (usually it is legancy case), the overall task will only be\n  // executed when upstream dirty. Otherwise the progressive rendering of all\n  // pipelines will be disabled unexpectedly. But it still needs stubs to receive\n  // dirty info from upsteam.\n  else {\n      overallProgress = false;\n      each(ecModel.getSeries(), createStub);\n    }\n\n  function createStub(seriesModel) {\n    var pipelineId = seriesModel.uid;\n    var stub = agentStubMap.get(pipelineId);\n\n    if (!stub) {\n      stub = agentStubMap.set(pipelineId, createTask({\n        reset: stubReset,\n        onDirty: stubOnDirty\n      })); // When the result of `getTargetSeries` changed, the overallTask\n      // should be set as dirty and re-performed.\n\n      overallTask.dirty();\n    }\n\n    stub.context = {\n      model: seriesModel,\n      overallProgress: overallProgress,\n      modifyOutputEnd: modifyOutputEnd\n    };\n    stub.agent = overallTask;\n    stub.__block = overallProgress;\n    pipe(scheduler, seriesModel, stub);\n  } // Clear unused stubs.\n\n\n  var pipelineMap = scheduler._pipelineMap;\n  agentStubMap.each(function (stub, pipelineId) {\n    if (!pipelineMap.get(pipelineId)) {\n      stub.dispose(); // When the result of `getTargetSeries` changed, the overallTask\n      // should be set as dirty and re-performed.\n\n      overallTask.dirty();\n      agentStubMap.removeKey(pipelineId);\n    }\n  });\n}\n\nfunction overallTaskReset(context) {\n  context.overallReset(context.ecModel, context.api, context.payload);\n}\n\nfunction stubReset(context, upstreamContext) {\n  return context.overallProgress && stubProgress;\n}\n\nfunction stubProgress() {\n  this.agent.dirty();\n  this.getDownstream().dirty();\n}\n\nfunction stubOnDirty() {\n  this.agent && this.agent.dirty();\n}\n\nfunction seriesTaskPlan(context) {\n  return context.plan && context.plan(context.model, context.ecModel, context.api, context.payload);\n}\n\nfunction seriesTaskReset(context) {\n  if (context.useClearVisual) {\n    context.data.clearAllVisual();\n  }\n\n  var resetDefines = context.resetDefines = normalizeToArray(context.reset(context.model, context.ecModel, context.api, context.payload));\n  return resetDefines.length > 1 ? map(resetDefines, function (v, idx) {\n    return makeSeriesTaskProgress(idx);\n  }) : singleSeriesTaskProgress;\n}\n\nvar singleSeriesTaskProgress = makeSeriesTaskProgress(0);\n\nfunction makeSeriesTaskProgress(resetDefineIdx) {\n  return function (params, context) {\n    var data = context.data;\n    var resetDefine = context.resetDefines[resetDefineIdx];\n\n    if (resetDefine && resetDefine.dataEach) {\n      for (var i = params.start; i < params.end; i++) {\n        resetDefine.dataEach(data, i);\n      }\n    } else if (resetDefine && resetDefine.progress) {\n      resetDefine.progress(params, data);\n    }\n  };\n}\n\nfunction seriesTaskCount(context) {\n  return context.data.count();\n}\n\nfunction pipe(scheduler, seriesModel, task) {\n  var pipelineId = seriesModel.uid;\n\n  var pipeline = scheduler._pipelineMap.get(pipelineId);\n\n  !pipeline.head && (pipeline.head = task);\n  pipeline.tail && pipeline.tail.pipe(task);\n  pipeline.tail = task;\n  task.__idxInPipeline = pipeline.count++;\n  task.__pipeline = pipeline;\n}\n\nScheduler.wrapStageHandler = function (stageHandler, visualType) {\n  if (isFunction(stageHandler)) {\n    stageHandler = {\n      overallReset: stageHandler,\n      seriesType: detectSeriseType(stageHandler)\n    };\n  }\n\n  stageHandler.uid = getUID('stageHandler');\n  visualType && (stageHandler.visualType = visualType);\n  return stageHandler;\n};\n/**\n * Only some legacy stage handlers (usually in echarts extensions) are pure function.\n * To ensure that they can work normally, they should work in block mode, that is,\n * they should not be started util the previous tasks finished. So they cause the\n * progressive rendering disabled. We try to detect the series type, to narrow down\n * the block range to only the series type they concern, but not all series.\n */\n\n\nfunction detectSeriseType(legacyFunc) {\n  seriesType = null;\n\n  try {\n    // Assume there is no async when calling `eachSeriesByType`.\n    legacyFunc(ecModelMock, apiMock);\n  } catch (e) {}\n\n  return seriesType;\n}\n\nvar ecModelMock = {};\nvar apiMock = {};\nvar seriesType;\nmockMethods(ecModelMock, GlobalModel);\nmockMethods(apiMock, ExtensionAPI);\n\necModelMock.eachSeriesByType = ecModelMock.eachRawSeriesByType = function (type) {\n  seriesType = type;\n};\n\necModelMock.eachComponent = function (cond) {\n  if (cond.mainType === 'series' && cond.subType) {\n    seriesType = cond.subType;\n  }\n};\n\nfunction mockMethods(target, Clz) {\n  /* eslint-disable */\n  for (var name in Clz.prototype) {\n    // Do not use hasOwnProperty\n    target[name] = noop;\n  }\n  /* eslint-enable */\n\n}\n\nvar _default = Scheduler;\nmodule.exports = _default;","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar _util = require(\"zrender/lib/core/util\");\n\nvar assert = _util.assert;\nvar isArray = _util.isArray;\n\nvar _config = require(\"../config\");\n\nvar __DEV__ = _config.__DEV__;\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/**\n * @param {Object} define\n * @return See the return of `createTask`.\n */\nfunction createTask(define) {\n  return new Task(define);\n}\n/**\n * @constructor\n * @param {Object} define\n * @param {Function} define.reset Custom reset\n * @param {Function} [define.plan] Returns 'reset' indicate reset immediately.\n * @param {Function} [define.count] count is used to determin data task.\n * @param {Function} [define.onDirty] count is used to determin data task.\n */\n\n\nfunction Task(define) {\n  define = define || {};\n  this._reset = define.reset;\n  this._plan = define.plan;\n  this._count = define.count;\n  this._onDirty = define.onDirty;\n  this._dirty = true; // Context must be specified implicitly, to\n  // avoid miss update context when model changed.\n\n  this.context;\n}\n\nvar taskProto = Task.prototype;\n/**\n * @param {Object} performArgs\n * @param {number} [performArgs.step] Specified step.\n * @param {number} [performArgs.skip] Skip customer perform call.\n * @param {number} [performArgs.modBy] Sampling window size.\n * @param {number} [performArgs.modDataCount] Sampling count.\n */\n\ntaskProto.perform = function (performArgs) {\n  var upTask = this._upstream;\n  var skip = performArgs && performArgs.skip; // TODO some refactor.\n  // Pull data. Must pull data each time, because context.data\n  // may be updated by Series.setData.\n\n  if (this._dirty && upTask) {\n    var context = this.context;\n    context.data = context.outputData = upTask.context.outputData;\n  }\n\n  if (this.__pipeline) {\n    this.__pipeline.currentTask = this;\n  }\n\n  var planResult;\n\n  if (this._plan && !skip) {\n    planResult = this._plan(this.context);\n  } // Support sharding by mod, which changes the render sequence and makes the rendered graphic\n  // elements uniformed distributed when progress, especially when moving or zooming.\n\n\n  var lastModBy = normalizeModBy(this._modBy);\n  var lastModDataCount = this._modDataCount || 0;\n  var modBy = normalizeModBy(performArgs && performArgs.modBy);\n  var modDataCount = performArgs && performArgs.modDataCount || 0;\n\n  if (lastModBy !== modBy || lastModDataCount !== modDataCount) {\n    planResult = 'reset';\n  }\n\n  function normalizeModBy(val) {\n    !(val >= 1) && (val = 1); // jshint ignore:line\n\n    return val;\n  }\n\n  var forceFirstProgress;\n\n  if (this._dirty || planResult === 'reset') {\n    this._dirty = false;\n    forceFirstProgress = reset(this, skip);\n  }\n\n  this._modBy = modBy;\n  this._modDataCount = modDataCount;\n  var step = performArgs && performArgs.step;\n\n  if (upTask) {\n    this._dueEnd = upTask._outputDueEnd;\n  } // DataTask or overallTask\n  else {\n      this._dueEnd = this._count ? this._count(this.context) : Infinity;\n    } // Note: Stubs, that its host overall task let it has progress, has progress.\n  // If no progress, pass index from upstream to downstream each time plan called.\n\n\n  if (this._progress) {\n    var start = this._dueIndex;\n    var end = Math.min(step != null ? this._dueIndex + step : Infinity, this._dueEnd);\n\n    if (!skip && (forceFirstProgress || start < end)) {\n      var progress = this._progress;\n\n      if (isArray(progress)) {\n        for (var i = 0; i < progress.length; i++) {\n          doProgress(this, progress[i], start, end, modBy, modDataCount);\n        }\n      } else {\n        doProgress(this, progress, start, end, modBy, modDataCount);\n      }\n    }\n\n    this._dueIndex = end; // If no `outputDueEnd`, assume that output data and\n    // input data is the same, so use `dueIndex` as `outputDueEnd`.\n\n    var outputDueEnd = this._settedOutputEnd != null ? this._settedOutputEnd : end;\n    this._outputDueEnd = outputDueEnd;\n  } else {\n    // (1) Some overall task has no progress.\n    // (2) Stubs, that its host overall task do not let it has progress, has no progress.\n    // This should always be performed so it can be passed to downstream.\n    this._dueIndex = this._outputDueEnd = this._settedOutputEnd != null ? this._settedOutputEnd : this._dueEnd;\n  }\n\n  return this.unfinished();\n};\n\nvar iterator = function () {\n  var end;\n  var current;\n  var modBy;\n  var modDataCount;\n  var winCount;\n  var it = {\n    reset: function (s, e, sStep, sCount) {\n      current = s;\n      end = e;\n      modBy = sStep;\n      modDataCount = sCount;\n      winCount = Math.ceil(modDataCount / modBy);\n      it.next = modBy > 1 && modDataCount > 0 ? modNext : sequentialNext;\n    }\n  };\n  return it;\n\n  function sequentialNext() {\n    return current < end ? current++ : null;\n  }\n\n  function modNext() {\n    var dataIndex = current % winCount * modBy + Math.ceil(current / winCount);\n    var result = current >= end ? null : dataIndex < modDataCount ? dataIndex // If modDataCount is smaller than data.count() (consider `appendData` case),\n    // Use normal linear rendering mode.\n    : current;\n    current++;\n    return result;\n  }\n}();\n\ntaskProto.dirty = function () {\n  this._dirty = true;\n  this._onDirty && this._onDirty(this.context);\n};\n\nfunction doProgress(taskIns, progress, start, end, modBy, modDataCount) {\n  iterator.reset(start, end, modBy, modDataCount);\n  taskIns._callingProgress = progress;\n\n  taskIns._callingProgress({\n    start: start,\n    end: end,\n    count: end - start,\n    next: iterator.next\n  }, taskIns.context);\n}\n\nfunction reset(taskIns, skip) {\n  taskIns._dueIndex = taskIns._outputDueEnd = taskIns._dueEnd = 0;\n  taskIns._settedOutputEnd = null;\n  var progress;\n  var forceFirstProgress;\n\n  if (!skip && taskIns._reset) {\n    progress = taskIns._reset(taskIns.context);\n\n    if (progress && progress.progress) {\n      forceFirstProgress = progress.forceFirstProgress;\n      progress = progress.progress;\n    } // To simplify no progress checking, array must has item.\n\n\n    if (isArray(progress) && !progress.length) {\n      progress = null;\n    }\n  }\n\n  taskIns._progress = progress;\n  taskIns._modBy = taskIns._modDataCount = null;\n  var downstream = taskIns._downstream;\n  downstream && downstream.dirty();\n  return forceFirstProgress;\n}\n/**\n * @return {boolean}\n */\n\n\ntaskProto.unfinished = function () {\n  return this._progress && this._dueIndex < this._dueEnd;\n};\n/**\n * @param {Object} downTask The downstream task.\n * @return {Object} The downstream task.\n */\n\n\ntaskProto.pipe = function (downTask) {\n  // If already downstream, do not dirty downTask.\n  if (this._downstream !== downTask || this._dirty) {\n    this._downstream = downTask;\n    downTask._upstream = this;\n    downTask.dirty();\n  }\n};\n\ntaskProto.dispose = function () {\n  if (this._disposed) {\n    return;\n  }\n\n  this._upstream && (this._upstream._downstream = null);\n  this._downstream && (this._downstream._upstream = null);\n  this._dirty = false;\n  this._disposed = true;\n};\n\ntaskProto.getUpstream = function () {\n  return this._upstream;\n};\n\ntaskProto.getDownstream = function () {\n  return this._downstream;\n};\n\ntaskProto.setOutputEnd = function (end) {\n  // This only happend in dataTask, dataZoom, map, currently.\n  // where dataZoom do not set end each time, but only set\n  // when reset. So we should record the setted end, in case\n  // that the stub of dataZoom perform again and earse the\n  // setted end by upstream.\n  this._outputDueEnd = this._settedOutputEnd = end;\n}; ///////////////////////////////////////////////////////////\n// For stream debug (Should be commented out after used!)\n// Usage: printTask(this, 'begin');\n// Usage: printTask(this, null, {someExtraProp});\n// function printTask(task, prefix, extra) {\n//     window.ecTaskUID == null && (window.ecTaskUID = 0);\n//     task.uidDebug == null && (task.uidDebug = `task_${window.ecTaskUID++}`);\n//     task.agent && task.agent.uidDebug == null && (task.agent.uidDebug = `task_${window.ecTaskUID++}`);\n//     var props = [];\n//     if (task.__pipeline) {\n//         var val = `${task.__idxInPipeline}/${task.__pipeline.tail.__idxInPipeline} ${task.agent ? '(stub)' : ''}`;\n//         props.push({text: 'idx', value: val});\n//     } else {\n//         var stubCount = 0;\n//         task.agentStubMap.each(() => stubCount++);\n//         props.push({text: 'idx', value: `overall (stubs: ${stubCount})`});\n//     }\n//     props.push({text: 'uid', value: task.uidDebug});\n//     if (task.__pipeline) {\n//         props.push({text: 'pid', value: task.__pipeline.id});\n//         task.agent && props.push(\n//             {text: 'stubFor', value: task.agent.uidDebug}\n//         );\n//     }\n//     props.push(\n//         {text: 'dirty', value: task._dirty},\n//         {text: 'dueIndex', value: task._dueIndex},\n//         {text: 'dueEnd', value: task._dueEnd},\n//         {text: 'outputDueEnd', value: task._outputDueEnd}\n//     );\n//     if (extra) {\n//         Object.keys(extra).forEach(key => {\n//             props.push({text: key, value: extra[key]});\n//         });\n//     }\n//     var args = ['color: blue'];\n//     var msg = `%c[${prefix || 'T'}] %c` + props.map(item => (\n//         args.push('color: black', 'color: red'),\n//         `${item.text}: %c${item.value}`\n//     )).join('%c, ');\n//     console.log.apply(console, [msg].concat(args));\n//     // console.log(this);\n// }\n\n\nexports.createTask = createTask;"],"sourceRoot":""}