@fecp/mobile 1.0.78 → 1.1.0

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

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const model = require("../../util/model.js");
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const types = require("../../util/types.js");
+var BE_ORDINAL = {
+  Must: 1,
+  Might: 2,
+  Not: 3
+  // Other cases
+};
+var innerGlobalModel = model.makeInner();
+function resetSourceDefaulter(ecModel) {
+  innerGlobalModel(ecModel).datasetMap = util.createHashMap();
+}
+function makeSeriesEncodeForAxisCoordSys(coordDimensions, seriesModel, source) {
+  var encode = {};
+  var datasetModel = querySeriesUpstreamDatasetModel(seriesModel);
+  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
+  });
+  util.each(coordDimensions, function(coordDimInfo, coordDimIdx) {
+    var coordDimName = coordDimInfo.name;
+    var count = getDataDimCountOnCoordDim(coordDimInfo);
+    if (baseCategoryDimIndex == null) {
+      var start = datasetRecord.valueWayDim;
+      pushDim(encode[coordDimName], start, count);
+      pushDim(encodeSeriesName, start, count);
+      datasetRecord.valueWayDim += count;
+    } else if (baseCategoryDimIndex === coordDimIdx) {
+      pushDim(encode[coordDimName], 0, count);
+      pushDim(encodeItemName, 0, count);
+    } 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;
+}
+function makeSeriesEncodeForNameBased(seriesModel, source, dimCount) {
+  var encode = {};
+  var datasetModel = querySeriesUpstreamDatasetModel(seriesModel);
+  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 = [];
+    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;
+      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;
+      }
+      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(idxResult2) {
+      return idxResult2.v != null && idxResult2.n != null;
+    }
+    return fulfilled(idxRes0) ? idxRes0 : fulfilled(idxRes1) ? idxRes1 : null;
+  }();
+  if (idxResult) {
+    encode.value = [idxResult.v];
+    var nameDimIndex = potentialNameDimIndex != null ? potentialNameDimIndex : idxResult.n;
+    encode.itemName = [nameDimIndex];
+    encode.seriesName = [nameDimIndex];
+  }
+  return encode;
+}
+function querySeriesUpstreamDatasetModel(seriesModel) {
+  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];
+  }
+}
+function queryDatasetUpstreamDatasetModels(datasetModel) {
+  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;
+}
+function guessOrdinal(source, dimIndex) {
+  return doGuessOrdinal(source.data, source.sourceFormat, source.seriesLayoutBy, source.dimensionsDefine, source.startIndex, dimIndex);
+}
+function doGuessOrdinal(data, sourceFormat, seriesLayoutBy, dimensionsDefine, startIndex, dimIndex) {
+  var result;
+  var maxLoop = 5;
+  if (util.isTypedArray(data)) {
+    return BE_ORDINAL.Not;
+  }
+  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(val2) {
+    var beStr = util.isString(val2);
+    if (val2 != null && Number.isFinite(Number(val2)) && val2 !== "") {
+      return beStr ? BE_ORDINAL.Might : BE_ORDINAL.Not;
+    } else if (beStr && val2 !== "-") {
+      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@5.6.0/node_modules/echarts/lib/data/helper/sourceManager.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const Source = require("../Source.js");
+const types = require("../../util/types.js");
+const sourceHelper = require("./sourceHelper.js");
+const transform = require("./transform.js");
+const DataStore = require("../DataStore.js");
+const dataProvider = require("./dataProvider.js");
+var SourceManager = (
+  /** @class */
+  function() {
+    function SourceManager2(sourceHost) {
+      this._sourceList = [];
+      this._storeList = [];
+      this._upstreamSignList = [];
+      this._versionSignBase = 0;
+      this._dirty = true;
+      this._sourceHost = sourceHost;
+    }
+    SourceManager2.prototype.dirty = function() {
+      this._setLocalSource([], []);
+      this._storeList = [];
+      this._dirty = true;
+    };
+    SourceManager2.prototype._setLocalSource = function(sourceList, upstreamSignList) {
+      this._sourceList = sourceList;
+      this._upstreamSignList = upstreamSignList;
+      this._versionSignBase++;
+      if (this._versionSignBase > 9e10) {
+        this._versionSignBase = 0;
+      }
+    };
+    SourceManager2.prototype._getVersionSign = function() {
+      return this._sourceHost.uid + "_" + this._versionSignBase;
+    };
+    SourceManager2.prototype.prepareSource = function() {
+      if (this._isDirty()) {
+        this._createSource();
+        this._dirty = false;
+      }
+    };
+    SourceManager2.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;
+        if (hasUpstream) {
+          var upSourceMgr = upSourceMgrList[0];
+          upSourceMgr.prepareSource();
+          upSource = upSourceMgr.getSource();
+          data = upSource.data;
+          sourceFormat = upSource.sourceFormat;
+          upstreamSignList = [upSourceMgr._getVersionSign()];
+        } else {
+          data = seriesModel.get("data", true);
+          sourceFormat = util.isTypedArray(data) ? types.SOURCE_FORMAT_TYPED_ARRAY : types.SOURCE_FORMAT_ORIGINAL;
+          upstreamSignList = [];
+        }
+        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);
+        var dimensions = util.retrieve2(newMetaRawOption.dimensions, upMetaRawOption.dimensions);
+        var needsCreateSource = seriesLayoutBy !== upMetaRawOption.seriesLayoutBy || !!sourceHeader !== !!upMetaRawOption.sourceHeader || dimensions;
+        resultSourceList = needsCreateSource ? [Source.createSource(data, {
+          seriesLayoutBy,
+          sourceHeader,
+          dimensions
+        }, sourceFormat)] : [];
+      } else {
+        var datasetModel = sourceHost;
+        if (hasUpstream) {
+          var result = this._applyTransform(upSourceMgrList);
+          resultSourceList = result.sourceList;
+          upstreamSignList = result.upstreamSignList;
+        } else {
+          var sourceData = datasetModel.get("source", true);
+          resultSourceList = [Source.createSource(sourceData, this._getSourceMetaRawOption(), null)];
+          upstreamSignList = [];
+        }
+      }
+      this._setLocalSource(resultSourceList, upstreamSignList);
+    };
+    SourceManager2.prototype._applyTransform = function(upMgrList) {
+      var datasetModel = this._sourceHost;
+      var transformOption = datasetModel.get("transform", true);
+      var fromTransformResult = datasetModel.get("fromTransformResult", true);
+      if (fromTransformResult != null) {
+        var errMsg = "";
+        if (upMgrList.length !== 1) {
+          doThrow(errMsg);
+        }
+      }
+      var sourceList;
+      var upSourceList = [];
+      var upstreamSignList = [];
+      util.each(upMgrList, function(upMgr) {
+        upMgr.prepareSource();
+        var upSource = upMgr.getSource(fromTransformResult || 0);
+        var errMsg2 = "";
+        if (fromTransformResult != null && !upSource) {
+          doThrow(errMsg2);
+        }
+        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,
+        upstreamSignList
+      };
+    };
+    SourceManager2.prototype._isDirty = function() {
+      if (this._dirty) {
+        return true;
+      }
+      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;
+        }
+      }
+    };
+    SourceManager2.prototype.getSource = function(sourceIndex) {
+      sourceIndex = sourceIndex || 0;
+      var source = this._sourceList[sourceIndex];
+      if (!source) {
+        var upSourceMgrList = this._getUpstreamSourceManagers();
+        return upSourceMgrList[0] && upSourceMgrList[0].getSource(sourceIndex);
+      }
+      return source;
+    };
+    SourceManager2.prototype.getSharedDataStore = function(seriesDimRequest) {
+      var schema = seriesDimRequest.makeStoreSchema();
+      return this._innerGetDataStore(schema.dimensions, seriesDimRequest.source, schema.hash);
+    };
+    SourceManager2.prototype._innerGetDataStore = function(storeDims, seriesSource, sourceReadKey) {
+      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();
+          cachedStore.initData(new dataProvider.DefaultDataProvider(seriesSource, storeDims.length), storeDims);
+        }
+        cachedStoreMap[sourceReadKey] = cachedStore;
+      }
+      return cachedStore;
+    };
+    SourceManager2.prototype._getUpstreamSourceManagers = function() {
+      var sourceHost = this._sourceHost;
+      if (isSeries(sourceHost)) {
+        var datasetModel = sourceHelper.querySeriesUpstreamDatasetModel(sourceHost);
+        return !datasetModel ? [] : [datasetModel.getSourceManager()];
+      } else {
+        return util.map(sourceHelper.queryDatasetUpstreamDatasetModels(sourceHost), function(datasetModel2) {
+          return datasetModel2.getSourceManager();
+        });
+      }
+    };
+    SourceManager2.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);
+      } 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,
+        sourceHeader,
+        dimensions
+      };
+    };
+    return SourceManager2;
+  }()
+);
+function disableTransformOptionMerge(datasetModel) {
+  var transformOption = datasetModel.option.transform;
+  transformOption && util.setAsPrimitive(datasetModel.option.transform);
+}
+function isSeries(sourceHost) {
+  return sourceHost.mainType === "series";
+}
+function doThrow(errMsg) {
+  throw new Error(errMsg);
+}
+exports.SourceManager = SourceManager;
+exports.disableTransformOptionMerge = disableTransformOptionMerge;