office-viewer 0.3.12 → 0.3.14

package/esm/node_modules/echarts/lib/core/Scheduler.js

@@ -1,447 +0,0 @@
-import { noop, createHashMap, each, assert, isFunction, map } 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 { Scheduler as default };