@fmdevui/fm-dev 1.0.113 → 1.0.114

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/data/helper/sourceHelper.js

@@ -0,0 +1,321 @@
+'use strict';
+
+var model = require('../../util/model.js');
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var types = require('../../util/types.js');
+
+// The result of `guessOrdinal`.
+var BE_ORDINAL = {
+  Must: 1,
+  Might: 2,
+  Not: 3 // Other cases
+};
+var innerGlobalModel = model.makeInner();
+/**
+ * MUST be called before mergeOption of all series.
+ */
+function resetSourceDefaulter(ecModel) {
+  // `datasetMap` is used to make default encode.
+  innerGlobalModel(ecModel).datasetMap = util.createHashMap();
+}
+/**
+ * [The strategy of the arrengment of data dimensions for dataset]:
+ * "value way": all axes are non-category axes. So series one by one take
+ *     several (the number is coordSysDims.length) dimensions from dataset.
+ *     The result of data arrengment of data dimensions like:
+ *     | ser0_x | ser0_y | ser1_x | ser1_y | ser2_x | ser2_y |
+ * "category way": at least one axis is category axis. So the the first data
+ *     dimension is always mapped to the first category axis and shared by
+ *     all of the series. The other data dimensions are taken by series like
+ *     "value way" does.
+ *     The result of data arrengment of data dimensions like:
+ *     | ser_shared_x | ser0_y | ser1_y | ser2_y |
+ *
+ * @return encode Never be `null/undefined`.
+ */
+function makeSeriesEncodeForAxisCoordSys(coordDimensions, seriesModel, source) {
+  var encode = {};
+  var datasetModel = querySeriesUpstreamDatasetModel(seriesModel);
+  // Currently only make default when using dataset, util more reqirements occur.
+  if (!datasetModel || !coordDimensions) {
+    return encode;
+  }
+  var encodeItemName = [];
+  var encodeSeriesName = [];
+  var ecModel = seriesModel.ecModel;
+  var datasetMap = innerGlobalModel(ecModel).datasetMap;
+  var key = datasetModel.uid + '_' + source.seriesLayoutBy;
+  var baseCategoryDimIndex;
+  var categoryWayValueDimStart;
+  coordDimensions = coordDimensions.slice();
+  util.each(coordDimensions, function (coordDimInfoLoose, coordDimIdx) {
+    var coordDimInfo = util.isObject(coordDimInfoLoose) ? coordDimInfoLoose : coordDimensions[coordDimIdx] = {
+      name: coordDimInfoLoose
+    };
+    if (coordDimInfo.type === 'ordinal' && baseCategoryDimIndex == null) {
+      baseCategoryDimIndex = coordDimIdx;
+      categoryWayValueDimStart = getDataDimCountOnCoordDim(coordDimInfo);
+    }
+    encode[coordDimInfo.name] = [];
+  });
+  var datasetRecord = datasetMap.get(key) || datasetMap.set(key, {
+    categoryWayDim: categoryWayValueDimStart,
+    valueWayDim: 0
+  });
+  // TODO
+  // Auto detect first time axis and do arrangement.
+  util.each(coordDimensions, function (coordDimInfo, coordDimIdx) {
+    var coordDimName = coordDimInfo.name;
+    var count = getDataDimCountOnCoordDim(coordDimInfo);
+    // In value way.
+    if (baseCategoryDimIndex == null) {
+      var start = datasetRecord.valueWayDim;
+      pushDim(encode[coordDimName], start, count);
+      pushDim(encodeSeriesName, start, count);
+      datasetRecord.valueWayDim += count;
+      // ??? TODO give a better default series name rule?
+      // especially when encode x y specified.
+      // consider: when multiple series share one dimension
+      // category axis, series name should better use
+      // the other dimension name. On the other hand, use
+      // both dimensions name.
+    }
+    // In category way, the first category axis.
+    else if (baseCategoryDimIndex === coordDimIdx) {
+      pushDim(encode[coordDimName], 0, count);
+      pushDim(encodeItemName, 0, count);
+    }
+    // In category way, the other axis.
+    else {
+      var start = datasetRecord.categoryWayDim;
+      pushDim(encode[coordDimName], start, count);
+      pushDim(encodeSeriesName, start, count);
+      datasetRecord.categoryWayDim += count;
+    }
+  });
+  function pushDim(dimIdxArr, idxFrom, idxCount) {
+    for (var i = 0; i < idxCount; i++) {
+      dimIdxArr.push(idxFrom + i);
+    }
+  }
+  function getDataDimCountOnCoordDim(coordDimInfo) {
+    var dimsDef = coordDimInfo.dimsDef;
+    return dimsDef ? dimsDef.length : 1;
+  }
+  encodeItemName.length && (encode.itemName = encodeItemName);
+  encodeSeriesName.length && (encode.seriesName = encodeSeriesName);
+  return encode;
+}
+/**
+ * Work for data like [{name: ..., value: ...}, ...].
+ *
+ * @return encode Never be `null/undefined`.
+ */
+function makeSeriesEncodeForNameBased(seriesModel, source, dimCount) {
+  var encode = {};
+  var datasetModel = querySeriesUpstreamDatasetModel(seriesModel);
+  // Currently only make default when using dataset, util more reqirements occur.
+  if (!datasetModel) {
+    return encode;
+  }
+  var sourceFormat = source.sourceFormat;
+  var dimensionsDefine = source.dimensionsDefine;
+  var potentialNameDimIndex;
+  if (sourceFormat === types.SOURCE_FORMAT_OBJECT_ROWS || sourceFormat === types.SOURCE_FORMAT_KEYED_COLUMNS) {
+    util.each(dimensionsDefine, function (dim, idx) {
+      if ((util.isObject(dim) ? dim.name : dim) === 'name') {
+        potentialNameDimIndex = idx;
+      }
+    });
+  }
+  var idxResult = function () {
+    var idxRes0 = {};
+    var idxRes1 = {};
+    var guessRecords = [];
+    // 5 is an experience value.
+    for (var i = 0, len = Math.min(5, dimCount); i < len; i++) {
+      var guessResult = doGuessOrdinal(source.data, sourceFormat, source.seriesLayoutBy, dimensionsDefine, source.startIndex, i);
+      guessRecords.push(guessResult);
+      var isPureNumber = guessResult === BE_ORDINAL.Not;
+      // [Strategy of idxRes0]: find the first BE_ORDINAL.Not as the value dim,
+      // and then find a name dim with the priority:
+      // "BE_ORDINAL.Might|BE_ORDINAL.Must" > "other dim" > "the value dim itself".
+      if (isPureNumber && idxRes0.v == null && i !== potentialNameDimIndex) {
+        idxRes0.v = i;
+      }
+      if (idxRes0.n == null || idxRes0.n === idxRes0.v || !isPureNumber && guessRecords[idxRes0.n] === BE_ORDINAL.Not) {
+        idxRes0.n = i;
+      }
+      if (fulfilled(idxRes0) && guessRecords[idxRes0.n] !== BE_ORDINAL.Not) {
+        return idxRes0;
+      }
+      // [Strategy of idxRes1]: if idxRes0 not satisfied (that is, no BE_ORDINAL.Not),
+      // find the first BE_ORDINAL.Might as the value dim,
+      // and then find a name dim with the priority:
+      // "other dim" > "the value dim itself".
+      // That is for backward compat: number-like (e.g., `'3'`, `'55'`) can be
+      // treated as number.
+      if (!isPureNumber) {
+        if (guessResult === BE_ORDINAL.Might && idxRes1.v == null && i !== potentialNameDimIndex) {
+          idxRes1.v = i;
+        }
+        if (idxRes1.n == null || idxRes1.n === idxRes1.v) {
+          idxRes1.n = i;
+        }
+      }
+    }
+    function fulfilled(idxResult) {
+      return idxResult.v != null && idxResult.n != null;
+    }
+    return fulfilled(idxRes0) ? idxRes0 : fulfilled(idxRes1) ? idxRes1 : null;
+  }();
+  if (idxResult) {
+    encode.value = [idxResult.v];
+    // `potentialNameDimIndex` has highest priority.
+    var nameDimIndex = potentialNameDimIndex != null ? potentialNameDimIndex : idxResult.n;
+    // By default, label uses itemName in charts.
+    // So we don't set encodeLabel here.
+    encode.itemName = [nameDimIndex];
+    encode.seriesName = [nameDimIndex];
+  }
+  return encode;
+}
+/**
+ * @return If return null/undefined, indicate that should not use datasetModel.
+ */
+function querySeriesUpstreamDatasetModel(seriesModel) {
+  // Caution: consider the scenario:
+  // A dataset is declared and a series is not expected to use the dataset,
+  // and at the beginning `setOption({series: { noData })` (just prepare other
+  // option but no data), then `setOption({series: {data: [...]}); In this case,
+  // the user should set an empty array to avoid that dataset is used by default.
+  var thisData = seriesModel.get('data', true);
+  if (!thisData) {
+    return model.queryReferringComponents(seriesModel.ecModel, 'dataset', {
+      index: seriesModel.get('datasetIndex', true),
+      id: seriesModel.get('datasetId', true)
+    }, model.SINGLE_REFERRING).models[0];
+  }
+}
+/**
+ * @return Always return an array event empty.
+ */
+function queryDatasetUpstreamDatasetModels(datasetModel) {
+  // Only these attributes declared, we by default reference to `datasetIndex: 0`.
+  // Otherwise, no reference.
+  if (!datasetModel.get('transform', true) && !datasetModel.get('fromTransformResult', true)) {
+    return [];
+  }
+  return model.queryReferringComponents(datasetModel.ecModel, 'dataset', {
+    index: datasetModel.get('fromDatasetIndex', true),
+    id: datasetModel.get('fromDatasetId', true)
+  }, model.SINGLE_REFERRING).models;
+}
+/**
+ * The rule should not be complex, otherwise user might not
+ * be able to known where the data is wrong.
+ * The code is ugly, but how to make it neat?
+ */
+function guessOrdinal(source, dimIndex) {
+  return doGuessOrdinal(source.data, source.sourceFormat, source.seriesLayoutBy, source.dimensionsDefine, source.startIndex, dimIndex);
+}
+// dimIndex may be overflow source data.
+// return {BE_ORDINAL}
+function doGuessOrdinal(data, sourceFormat, seriesLayoutBy, dimensionsDefine, startIndex, dimIndex) {
+  var result;
+  // Experience value.
+  var maxLoop = 5;
+  if (util.isTypedArray(data)) {
+    return BE_ORDINAL.Not;
+  }
+  // When sourceType is 'objectRows' or 'keyedColumns', dimensionsDefine
+  // always exists in source.
+  var dimName;
+  var dimType;
+  if (dimensionsDefine) {
+    var dimDefItem = dimensionsDefine[dimIndex];
+    if (util.isObject(dimDefItem)) {
+      dimName = dimDefItem.name;
+      dimType = dimDefItem.type;
+    } else if (util.isString(dimDefItem)) {
+      dimName = dimDefItem;
+    }
+  }
+  if (dimType != null) {
+    return dimType === 'ordinal' ? BE_ORDINAL.Must : BE_ORDINAL.Not;
+  }
+  if (sourceFormat === types.SOURCE_FORMAT_ARRAY_ROWS) {
+    var dataArrayRows = data;
+    if (seriesLayoutBy === types.SERIES_LAYOUT_BY_ROW) {
+      var sample = dataArrayRows[dimIndex];
+      for (var i = 0; i < (sample || []).length && i < maxLoop; i++) {
+        if ((result = detectValue(sample[startIndex + i])) != null) {
+          return result;
+        }
+      }
+    } else {
+      for (var i = 0; i < dataArrayRows.length && i < maxLoop; i++) {
+        var row = dataArrayRows[startIndex + i];
+        if (row && (result = detectValue(row[dimIndex])) != null) {
+          return result;
+        }
+      }
+    }
+  } else if (sourceFormat === types.SOURCE_FORMAT_OBJECT_ROWS) {
+    var dataObjectRows = data;
+    if (!dimName) {
+      return BE_ORDINAL.Not;
+    }
+    for (var i = 0; i < dataObjectRows.length && i < maxLoop; i++) {
+      var item = dataObjectRows[i];
+      if (item && (result = detectValue(item[dimName])) != null) {
+        return result;
+      }
+    }
+  } else if (sourceFormat === types.SOURCE_FORMAT_KEYED_COLUMNS) {
+    var dataKeyedColumns = data;
+    if (!dimName) {
+      return BE_ORDINAL.Not;
+    }
+    var sample = dataKeyedColumns[dimName];
+    if (!sample || util.isTypedArray(sample)) {
+      return BE_ORDINAL.Not;
+    }
+    for (var i = 0; i < sample.length && i < maxLoop; i++) {
+      if ((result = detectValue(sample[i])) != null) {
+        return result;
+      }
+    }
+  } else if (sourceFormat === types.SOURCE_FORMAT_ORIGINAL) {
+    var dataOriginal = data;
+    for (var i = 0; i < dataOriginal.length && i < maxLoop; i++) {
+      var item = dataOriginal[i];
+      var val = model.getDataItemValue(item);
+      if (!util.isArray(val)) {
+        return BE_ORDINAL.Not;
+      }
+      if ((result = detectValue(val[dimIndex])) != null) {
+        return result;
+      }
+    }
+  }
+  function detectValue(val) {
+    var beStr = util.isString(val);
+    // Consider usage convenience, '1', '2' will be treated as "number".
+    // `Number('')` (or any whitespace) is `0`.
+    if (val != null && Number.isFinite(Number(val)) && val !== '') {
+      return beStr ? BE_ORDINAL.Might : BE_ORDINAL.Not;
+    } else if (beStr && val !== '-') {
+      return BE_ORDINAL.Must;
+    }
+  }
+  return BE_ORDINAL.Not;
+}
+
+exports.BE_ORDINAL = BE_ORDINAL;
+exports.guessOrdinal = guessOrdinal;
+exports.makeSeriesEncodeForAxisCoordSys = makeSeriesEncodeForAxisCoordSys;
+exports.makeSeriesEncodeForNameBased = makeSeriesEncodeForNameBased;
+exports.queryDatasetUpstreamDatasetModels = queryDatasetUpstreamDatasetModels;
+exports.querySeriesUpstreamDatasetModel = querySeriesUpstreamDatasetModel;
+exports.resetSourceDefaulter = resetSourceDefaulter;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/data/helper/sourceManager.js

@@ -0,0 +1,379 @@
+'use strict';
+
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var Source = require('../Source.js');
+var types = require('../../util/types.js');
+var sourceHelper = require('./sourceHelper.js');
+var transform = require('./transform.js');
+var DataStore = require('../DataStore.js');
+var dataProvider = require('./dataProvider.js');
+
+/**
+ * [REQUIREMENT_MEMO]:
+ * (0) `metaRawOption` means `dimensions`/`sourceHeader`/`seriesLayoutBy` in raw option.
+ * (1) Keep support the feature: `metaRawOption` can be specified both on `series` and
+ * `root-dataset`. Them on `series` has higher priority.
+ * (2) Do not support to set `metaRawOption` on a `non-root-dataset`, because it might
+ * confuse users: whether those props indicate how to visit the upstream source or visit
+ * the transform result source, and some transforms has nothing to do with these props,
+ * and some transforms might have multiple upstream.
+ * (3) Transforms should specify `metaRawOption` in each output, just like they can be
+ * declared in `root-dataset`.
+ * (4) At present only support visit source in `SERIES_LAYOUT_BY_COLUMN` in transforms.
+ * That is for reducing complexity in transforms.
+ * PENDING: Whether to provide transposition transform?
+ *
+ * [IMPLEMENTAION_MEMO]:
+ * "sourceVisitConfig" are calculated from `metaRawOption` and `data`.
+ * They will not be calculated until `source` is about to be visited (to prevent from
+ * duplicate calcuation). `source` is visited only in series and input to transforms.
+ *
+ * [DIMENSION_INHERIT_RULE]:
+ * By default the dimensions are inherited from ancestors, unless a transform return
+ * a new dimensions definition.
+ * Consider the case:
+ * ```js
+ * dataset: [{
+ *     source: [ ['Product', 'Sales', 'Prise'], ['Cookies', 321, 44.21], ...]
+ * }, {
+ *     transform: { type: 'filter', ... }
+ * }]
+ * dataset: [{
+ *     dimension: ['Product', 'Sales', 'Prise'],
+ *     source: [ ['Cookies', 321, 44.21], ...]
+ * }, {
+ *     transform: { type: 'filter', ... }
+ * }]
+ * ```
+ * The two types of option should have the same behavior after transform.
+ *
+ *
+ * [SCENARIO]:
+ * (1) Provide source data directly:
+ * ```js
+ * series: {
+ *     encode: {...},
+ *     dimensions: [...]
+ *     seriesLayoutBy: 'row',
+ *     data: [[...]]
+ * }
+ * ```
+ * (2) Series refer to dataset.
+ * ```js
+ * series: [{
+ *     encode: {...}
+ *     // Ignore datasetIndex means `datasetIndex: 0`
+ *     // and the dimensions defination in dataset is used
+ * }, {
+ *     encode: {...},
+ *     seriesLayoutBy: 'column',
+ *     datasetIndex: 1
+ * }]
+ * ```
+ * (3) dataset transform
+ * ```js
+ * dataset: [{
+ *     source: [...]
+ * }, {
+ *     source: [...]
+ * }, {
+ *     // By default from 0.
+ *     transform: { type: 'filter', config: {...} }
+ * }, {
+ *     // Piped.
+ *     transform: [
+ *         { type: 'filter', config: {...} },
+ *         { type: 'sort', config: {...} }
+ *     ]
+ * }, {
+ *     id: 'regressionData',
+ *     fromDatasetIndex: 1,
+ *     // Third-party transform
+ *     transform: { type: 'ecStat:regression', config: {...} }
+ * }, {
+ *     // retrieve the extra result.
+ *     id: 'regressionFormula',
+ *     fromDatasetId: 'regressionData',
+ *     fromTransformResult: 1
+ * }]
+ * ```
+ */
+var SourceManager = /** @class */function () {
+  function SourceManager(sourceHost) {
+    // Cached source. Do not repeat calculating if not dirty.
+    this._sourceList = [];
+    this._storeList = [];
+    // version sign of each upstream source manager.
+    this._upstreamSignList = [];
+    this._versionSignBase = 0;
+    this._dirty = true;
+    this._sourceHost = sourceHost;
+  }
+  /**
+   * Mark dirty.
+   */
+  SourceManager.prototype.dirty = function () {
+    this._setLocalSource([], []);
+    this._storeList = [];
+    this._dirty = true;
+  };
+  SourceManager.prototype._setLocalSource = function (sourceList, upstreamSignList) {
+    this._sourceList = sourceList;
+    this._upstreamSignList = upstreamSignList;
+    this._versionSignBase++;
+    if (this._versionSignBase > 9e10) {
+      this._versionSignBase = 0;
+    }
+  };
+  /**
+   * For detecting whether the upstream source is dirty, so that
+   * the local cached source (in `_sourceList`) should be discarded.
+   */
+  SourceManager.prototype._getVersionSign = function () {
+    return this._sourceHost.uid + '_' + this._versionSignBase;
+  };
+  /**
+   * Always return a source instance. Otherwise throw error.
+   */
+  SourceManager.prototype.prepareSource = function () {
+    // For the case that call `setOption` multiple time but no data changed,
+    // cache the result source to prevent from repeating transform.
+    if (this._isDirty()) {
+      this._createSource();
+      this._dirty = false;
+    }
+  };
+  SourceManager.prototype._createSource = function () {
+    this._setLocalSource([], []);
+    var sourceHost = this._sourceHost;
+    var upSourceMgrList = this._getUpstreamSourceManagers();
+    var hasUpstream = !!upSourceMgrList.length;
+    var resultSourceList;
+    var upstreamSignList;
+    if (isSeries(sourceHost)) {
+      var seriesModel = sourceHost;
+      var data = void 0;
+      var sourceFormat = void 0;
+      var upSource = void 0;
+      // Has upstream dataset
+      if (hasUpstream) {
+        var upSourceMgr = upSourceMgrList[0];
+        upSourceMgr.prepareSource();
+        upSource = upSourceMgr.getSource();
+        data = upSource.data;
+        sourceFormat = upSource.sourceFormat;
+        upstreamSignList = [upSourceMgr._getVersionSign()];
+      }
+      // Series data is from own.
+      else {
+        data = seriesModel.get('data', true);
+        sourceFormat = util.isTypedArray(data) ? types.SOURCE_FORMAT_TYPED_ARRAY : types.SOURCE_FORMAT_ORIGINAL;
+        upstreamSignList = [];
+      }
+      // See [REQUIREMENT_MEMO], merge settings on series and parent dataset if it is root.
+      var newMetaRawOption = this._getSourceMetaRawOption() || {};
+      var upMetaRawOption = upSource && upSource.metaRawOption || {};
+      var seriesLayoutBy = util.retrieve2(newMetaRawOption.seriesLayoutBy, upMetaRawOption.seriesLayoutBy) || null;
+      var sourceHeader = util.retrieve2(newMetaRawOption.sourceHeader, upMetaRawOption.sourceHeader);
+      // Note here we should not use `upSource.dimensionsDefine`. Consider the case:
+      // `upSource.dimensionsDefine` is detected by `seriesLayoutBy: 'column'`,
+      // but series need `seriesLayoutBy: 'row'`.
+      var dimensions = util.retrieve2(newMetaRawOption.dimensions, upMetaRawOption.dimensions);
+      // We share source with dataset as much as possible
+      // to avoid extra memory cost of high dimensional data.
+      var needsCreateSource = seriesLayoutBy !== upMetaRawOption.seriesLayoutBy || !!sourceHeader !== !!upMetaRawOption.sourceHeader || dimensions;
+      resultSourceList = needsCreateSource ? [Source.createSource(data, {
+        seriesLayoutBy: seriesLayoutBy,
+        sourceHeader: sourceHeader,
+        dimensions: dimensions
+      }, sourceFormat)] : [];
+    } else {
+      var datasetModel = sourceHost;
+      // Has upstream dataset.
+      if (hasUpstream) {
+        var result = this._applyTransform(upSourceMgrList);
+        resultSourceList = result.sourceList;
+        upstreamSignList = result.upstreamSignList;
+      }
+      // Is root dataset.
+      else {
+        var sourceData = datasetModel.get('source', true);
+        resultSourceList = [Source.createSource(sourceData, this._getSourceMetaRawOption(), null)];
+        upstreamSignList = [];
+      }
+    }
+    if (process.env.NODE_ENV !== 'production') {
+      util.assert(resultSourceList && upstreamSignList);
+    }
+    this._setLocalSource(resultSourceList, upstreamSignList);
+  };
+  SourceManager.prototype._applyTransform = function (upMgrList) {
+    var datasetModel = this._sourceHost;
+    var transformOption = datasetModel.get('transform', true);
+    var fromTransformResult = datasetModel.get('fromTransformResult', true);
+    if (process.env.NODE_ENV !== 'production') {
+      util.assert(fromTransformResult != null || transformOption != null);
+    }
+    if (fromTransformResult != null) {
+      var errMsg = '';
+      if (upMgrList.length !== 1) {
+        if (process.env.NODE_ENV !== 'production') {
+          errMsg = 'When using `fromTransformResult`, there should be only one upstream dataset';
+        }
+        doThrow(errMsg);
+      }
+    }
+    var sourceList;
+    var upSourceList = [];
+    var upstreamSignList = [];
+    util.each(upMgrList, function (upMgr) {
+      upMgr.prepareSource();
+      var upSource = upMgr.getSource(fromTransformResult || 0);
+      var errMsg = '';
+      if (fromTransformResult != null && !upSource) {
+        if (process.env.NODE_ENV !== 'production') {
+          errMsg = 'Can not retrieve result by `fromTransformResult`: ' + fromTransformResult;
+        }
+        doThrow(errMsg);
+      }
+      upSourceList.push(upSource);
+      upstreamSignList.push(upMgr._getVersionSign());
+    });
+    if (transformOption) {
+      sourceList = transform.applyDataTransform(transformOption, upSourceList, {
+        datasetIndex: datasetModel.componentIndex
+      });
+    } else if (fromTransformResult != null) {
+      sourceList = [Source.cloneSourceShallow(upSourceList[0])];
+    }
+    return {
+      sourceList: sourceList,
+      upstreamSignList: upstreamSignList
+    };
+  };
+  SourceManager.prototype._isDirty = function () {
+    if (this._dirty) {
+      return true;
+    }
+    // All sourceList is from the some upstream.
+    var upSourceMgrList = this._getUpstreamSourceManagers();
+    for (var i = 0; i < upSourceMgrList.length; i++) {
+      var upSrcMgr = upSourceMgrList[i];
+      if (
+      // Consider the case that there is ancestor diry, call it recursively.
+      // The performance is probably not an issue because usually the chain is not long.
+      upSrcMgr._isDirty() || this._upstreamSignList[i] !== upSrcMgr._getVersionSign()) {
+        return true;
+      }
+    }
+  };
+  /**
+   * @param sourceIndex By default 0, means "main source".
+   *                    In most cases there is only one source.
+   */
+  SourceManager.prototype.getSource = function (sourceIndex) {
+    sourceIndex = sourceIndex || 0;
+    var source = this._sourceList[sourceIndex];
+    if (!source) {
+      // Series may share source instance with dataset.
+      var upSourceMgrList = this._getUpstreamSourceManagers();
+      return upSourceMgrList[0] && upSourceMgrList[0].getSource(sourceIndex);
+    }
+    return source;
+  };
+  /**
+   *
+   * Get a data store which can be shared across series.
+   * Only available for series.
+   *
+   * @param seriesDimRequest Dimensions that are generated in series.
+   *        Should have been sorted by `storeDimIndex` asc.
+   */
+  SourceManager.prototype.getSharedDataStore = function (seriesDimRequest) {
+    if (process.env.NODE_ENV !== 'production') {
+      util.assert(isSeries(this._sourceHost), 'Can only call getDataStore on series source manager.');
+    }
+    var schema = seriesDimRequest.makeStoreSchema();
+    return this._innerGetDataStore(schema.dimensions, seriesDimRequest.source, schema.hash);
+  };
+  SourceManager.prototype._innerGetDataStore = function (storeDims, seriesSource, sourceReadKey) {
+    // TODO Can use other sourceIndex?
+    var sourceIndex = 0;
+    var storeList = this._storeList;
+    var cachedStoreMap = storeList[sourceIndex];
+    if (!cachedStoreMap) {
+      cachedStoreMap = storeList[sourceIndex] = {};
+    }
+    var cachedStore = cachedStoreMap[sourceReadKey];
+    if (!cachedStore) {
+      var upSourceMgr = this._getUpstreamSourceManagers()[0];
+      if (isSeries(this._sourceHost) && upSourceMgr) {
+        cachedStore = upSourceMgr._innerGetDataStore(storeDims, seriesSource, sourceReadKey);
+      } else {
+        cachedStore = new DataStore.default();
+        // Always create store from source of series.
+        cachedStore.initData(new dataProvider.DefaultDataProvider(seriesSource, storeDims.length), storeDims);
+      }
+      cachedStoreMap[sourceReadKey] = cachedStore;
+    }
+    return cachedStore;
+  };
+  /**
+   * PENDING: Is it fast enough?
+   * If no upstream, return empty array.
+   */
+  SourceManager.prototype._getUpstreamSourceManagers = function () {
+    // Always get the relationship from the raw option.
+    // Do not cache the link of the dependency graph, so that
+    // there is no need to update them when change happens.
+    var sourceHost = this._sourceHost;
+    if (isSeries(sourceHost)) {
+      var datasetModel = sourceHelper.querySeriesUpstreamDatasetModel(sourceHost);
+      return !datasetModel ? [] : [datasetModel.getSourceManager()];
+    } else {
+      return util.map(sourceHelper.queryDatasetUpstreamDatasetModels(sourceHost), function (datasetModel) {
+        return datasetModel.getSourceManager();
+      });
+    }
+  };
+  SourceManager.prototype._getSourceMetaRawOption = function () {
+    var sourceHost = this._sourceHost;
+    var seriesLayoutBy;
+    var sourceHeader;
+    var dimensions;
+    if (isSeries(sourceHost)) {
+      seriesLayoutBy = sourceHost.get('seriesLayoutBy', true);
+      sourceHeader = sourceHost.get('sourceHeader', true);
+      dimensions = sourceHost.get('dimensions', true);
+    }
+    // See [REQUIREMENT_MEMO], `non-root-dataset` do not support them.
+    else if (!this._getUpstreamSourceManagers().length) {
+      var model = sourceHost;
+      seriesLayoutBy = model.get('seriesLayoutBy', true);
+      sourceHeader = model.get('sourceHeader', true);
+      dimensions = model.get('dimensions', true);
+    }
+    return {
+      seriesLayoutBy: seriesLayoutBy,
+      sourceHeader: sourceHeader,
+      dimensions: dimensions
+    };
+  };
+  return SourceManager;
+}();
+// Call this method after `super.init` and `super.mergeOption` to
+// disable the transform merge, but do not disable transform clone from rawOption.
+function disableTransformOptionMerge(datasetModel) {
+  var transformOption = datasetModel.option.transform;
+  transformOption && util.setAsPrimitive(datasetModel.option.transform);
+}
+function isSeries(sourceHost) {
+  // Avoid circular dependency with Series.ts
+  return sourceHost.mainType === 'series';
+}
+function doThrow(errMsg) {
+  throw new Error(errMsg);
+}
+
+exports.SourceManager = SourceManager;
+exports.disableTransformOptionMerge = disableTransformOptionMerge;