@fmdevui/fm-dev 1.0.113 → 1.0.114

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

@@ -0,0 +1,189 @@
+'use strict';
+
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var model = require('../../util/model.js');
+var Source = require('../Source.js');
+
+var inner = model.makeInner();
+var dimTypeShort = {
+  float: 'f',
+  int: 'i',
+  ordinal: 'o',
+  number: 'n',
+  time: 't'
+};
+/**
+ * Represents the dimension requirement of a series.
+ *
+ * NOTICE:
+ * When there are too many dimensions in dataset and many series, only the used dimensions
+ * (i.e., used by coord sys and declared in `series.encode`) are add to `dimensionDefineList`.
+ * But users may query data by other unused dimension names.
+ * In this case, users can only query data if and only if they have defined dimension names
+ * via ec option, so we provide `getDimensionIndexFromSource`, which only query them from
+ * `source` dimensions.
+ */
+var SeriesDataSchema = /** @class */function () {
+  function SeriesDataSchema(opt) {
+    this.dimensions = opt.dimensions;
+    this._dimOmitted = opt.dimensionOmitted;
+    this.source = opt.source;
+    this._fullDimCount = opt.fullDimensionCount;
+    this._updateDimOmitted(opt.dimensionOmitted);
+  }
+  SeriesDataSchema.prototype.isDimensionOmitted = function () {
+    return this._dimOmitted;
+  };
+  SeriesDataSchema.prototype._updateDimOmitted = function (dimensionOmitted) {
+    this._dimOmitted = dimensionOmitted;
+    if (!dimensionOmitted) {
+      return;
+    }
+    if (!this._dimNameMap) {
+      this._dimNameMap = ensureSourceDimNameMap(this.source);
+    }
+  };
+  /**
+   * @caution Can only be used when `dimensionOmitted: true`.
+   *
+   * Get index by user defined dimension name (i.e., not internal generate name).
+   * That is, get index from `dimensionsDefine`.
+   * If no `dimensionsDefine`, or no name get, return -1.
+   */
+  SeriesDataSchema.prototype.getSourceDimensionIndex = function (dimName) {
+    return util.retrieve2(this._dimNameMap.get(dimName), -1);
+  };
+  /**
+   * @caution Can only be used when `dimensionOmitted: true`.
+   *
+   * Notice: may return `null`/`undefined` if user not specify dimension names.
+   */
+  SeriesDataSchema.prototype.getSourceDimension = function (dimIndex) {
+    var dimensionsDefine = this.source.dimensionsDefine;
+    if (dimensionsDefine) {
+      return dimensionsDefine[dimIndex];
+    }
+  };
+  SeriesDataSchema.prototype.makeStoreSchema = function () {
+    var dimCount = this._fullDimCount;
+    var willRetrieveDataByName = Source.shouldRetrieveDataByName(this.source);
+    var makeHashStrict = !shouldOmitUnusedDimensions(dimCount);
+    // If source don't have dimensions or series don't omit unsed dimensions.
+    // Generate from seriesDimList directly
+    var dimHash = '';
+    var dims = [];
+    for (var fullDimIdx = 0, seriesDimIdx = 0; fullDimIdx < dimCount; fullDimIdx++) {
+      var property = void 0;
+      var type = void 0;
+      var ordinalMeta = void 0;
+      var seriesDimDef = this.dimensions[seriesDimIdx];
+      // The list has been sorted by `storeDimIndex` asc.
+      if (seriesDimDef && seriesDimDef.storeDimIndex === fullDimIdx) {
+        property = willRetrieveDataByName ? seriesDimDef.name : null;
+        type = seriesDimDef.type;
+        ordinalMeta = seriesDimDef.ordinalMeta;
+        seriesDimIdx++;
+      } else {
+        var sourceDimDef = this.getSourceDimension(fullDimIdx);
+        if (sourceDimDef) {
+          property = willRetrieveDataByName ? sourceDimDef.name : null;
+          type = sourceDimDef.type;
+        }
+      }
+      dims.push({
+        property: property,
+        type: type,
+        ordinalMeta: ordinalMeta
+      });
+      // If retrieving data by index,
+      //   use <index, type, ordinalMeta> to determine whether data can be shared.
+      //   (Because in this case there might be no dimension name defined in dataset, but indices always exists).
+      //   (Indices are always 0, 1, 2, ..., so we can ignore them to shorten the hash).
+      // Otherwise if retrieving data by property name (like `data: [{aa: 123, bb: 765}, ...]`),
+      //   use <property, type, ordinalMeta> in hash.
+      if (willRetrieveDataByName && property != null
+      // For data stack, we have make sure each series has its own dim on this store.
+      // So we do not add property to hash to make sure they can share this store.
+      && (!seriesDimDef || !seriesDimDef.isCalculationCoord)) {
+        dimHash += makeHashStrict
+        // Use escape character '`' in case that property name contains '$'.
+        ? property.replace(/\`/g, '`1').replace(/\$/g, '`2')
+        // For better performance, when there are large dimensions, tolerant this defects that hardly meet.
+        : property;
+      }
+      dimHash += '$';
+      dimHash += dimTypeShort[type] || 'f';
+      if (ordinalMeta) {
+        dimHash += ordinalMeta.uid;
+      }
+      dimHash += '$';
+    }
+    // Source from endpoint(usually series) will be read differently
+    // when seriesLayoutBy or startIndex(which is affected by sourceHeader) are different.
+    // So we use this three props as key.
+    var source = this.source;
+    var hash = [source.seriesLayoutBy, source.startIndex, dimHash].join('$$');
+    return {
+      dimensions: dims,
+      hash: hash
+    };
+  };
+  SeriesDataSchema.prototype.makeOutputDimensionNames = function () {
+    var result = [];
+    for (var fullDimIdx = 0, seriesDimIdx = 0; fullDimIdx < this._fullDimCount; fullDimIdx++) {
+      var name_1 = void 0;
+      var seriesDimDef = this.dimensions[seriesDimIdx];
+      // The list has been sorted by `storeDimIndex` asc.
+      if (seriesDimDef && seriesDimDef.storeDimIndex === fullDimIdx) {
+        if (!seriesDimDef.isCalculationCoord) {
+          name_1 = seriesDimDef.name;
+        }
+        seriesDimIdx++;
+      } else {
+        var sourceDimDef = this.getSourceDimension(fullDimIdx);
+        if (sourceDimDef) {
+          name_1 = sourceDimDef.name;
+        }
+      }
+      result.push(name_1);
+    }
+    return result;
+  };
+  SeriesDataSchema.prototype.appendCalculationDimension = function (dimDef) {
+    this.dimensions.push(dimDef);
+    dimDef.isCalculationCoord = true;
+    this._fullDimCount++;
+    // If append dimension on a data store, consider the store
+    // might be shared by different series, series dimensions not
+    // really map to store dimensions.
+    this._updateDimOmitted(true);
+  };
+  return SeriesDataSchema;
+}();
+function isSeriesDataSchema(schema) {
+  return schema instanceof SeriesDataSchema;
+}
+function createDimNameMap(dimsDef) {
+  var dataDimNameMap = util.createHashMap();
+  for (var i = 0; i < (dimsDef || []).length; i++) {
+    var dimDefItemRaw = dimsDef[i];
+    var userDimName = util.isObject(dimDefItemRaw) ? dimDefItemRaw.name : dimDefItemRaw;
+    if (userDimName != null && dataDimNameMap.get(userDimName) == null) {
+      dataDimNameMap.set(userDimName, i);
+    }
+  }
+  return dataDimNameMap;
+}
+function ensureSourceDimNameMap(source) {
+  var innerSource = inner(source);
+  return innerSource.dimNameMap || (innerSource.dimNameMap = createDimNameMap(source.dimensionsDefine));
+}
+function shouldOmitUnusedDimensions(dimCount) {
+  return dimCount > 30;
+}
+
+exports.SeriesDataSchema = SeriesDataSchema;
+exports.createDimNameMap = createDimNameMap;
+exports.ensureSourceDimNameMap = ensureSourceDimNameMap;
+exports.isSeriesDataSchema = isSeriesDataSchema;
+exports.shouldOmitUnusedDimensions = shouldOmitUnusedDimensions;

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

@@ -0,0 +1,287 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var types = require('../../util/types.js');
+var SeriesDimensionDefine = require('../SeriesDimensionDefine.js');
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var Source = require('../Source.js');
+var DataStore = require('../DataStore.js');
+var model = require('../../util/model.js');
+var sourceHelper = require('./sourceHelper.js');
+var SeriesDataSchema = require('./SeriesDataSchema.js');
+
+/**
+ * For outside usage compat (like echarts-gl are using it).
+ */
+function createDimensions(source, opt) {
+  return prepareSeriesDataSchema(source, opt).dimensions;
+}
+/**
+ * This method builds the relationship between:
+ * + "what the coord sys or series requires (see `coordDimensions`)",
+ * + "what the user defines (in `encode` and `dimensions`, see `opt.dimensionsDefine` and `opt.encodeDefine`)"
+ * + "what the data source provids (see `source`)".
+ *
+ * Some guess strategy will be adapted if user does not define something.
+ * If no 'value' dimension specified, the first no-named dimension will be
+ * named as 'value'.
+ *
+ * @return The results are always sorted by `storeDimIndex` asc.
+ */
+function prepareSeriesDataSchema(
+// TODO: TYPE completeDimensions type
+source, opt) {
+  if (!Source.isSourceInstance(source)) {
+    source = Source.createSourceFromSeriesDataOption(source);
+  }
+  opt = opt || {};
+  var sysDims = opt.coordDimensions || [];
+  var dimsDef = opt.dimensionsDefine || source.dimensionsDefine || [];
+  var coordDimNameMap = util.createHashMap();
+  var resultList = [];
+  var dimCount = getDimCount(source, sysDims, dimsDef, opt.dimensionsCount);
+  // Try to ignore unused dimensions if sharing a high dimension datastore
+  // 30 is an experience value.
+  var omitUnusedDimensions = opt.canOmitUnusedDimensions && SeriesDataSchema.shouldOmitUnusedDimensions(dimCount);
+  var isUsingSourceDimensionsDef = dimsDef === source.dimensionsDefine;
+  var dataDimNameMap = isUsingSourceDimensionsDef ? SeriesDataSchema.ensureSourceDimNameMap(source) : SeriesDataSchema.createDimNameMap(dimsDef);
+  var encodeDef = opt.encodeDefine;
+  if (!encodeDef && opt.encodeDefaulter) {
+    encodeDef = opt.encodeDefaulter(source, dimCount);
+  }
+  var encodeDefMap = util.createHashMap(encodeDef);
+  var indicesMap = new DataStore.CtorInt32Array(dimCount);
+  for (var i = 0; i < indicesMap.length; i++) {
+    indicesMap[i] = -1;
+  }
+  function getResultItem(dimIdx) {
+    var idx = indicesMap[dimIdx];
+    if (idx < 0) {
+      var dimDefItemRaw = dimsDef[dimIdx];
+      var dimDefItem = util.isObject(dimDefItemRaw) ? dimDefItemRaw : {
+        name: dimDefItemRaw
+      };
+      var resultItem = new SeriesDimensionDefine.default();
+      var userDimName = dimDefItem.name;
+      if (userDimName != null && dataDimNameMap.get(userDimName) != null) {
+        // Only if `series.dimensions` is defined in option
+        // displayName, will be set, and dimension will be displayed vertically in
+        // tooltip by default.
+        resultItem.name = resultItem.displayName = userDimName;
+      }
+      dimDefItem.type != null && (resultItem.type = dimDefItem.type);
+      dimDefItem.displayName != null && (resultItem.displayName = dimDefItem.displayName);
+      var newIdx = resultList.length;
+      indicesMap[dimIdx] = newIdx;
+      resultItem.storeDimIndex = dimIdx;
+      resultList.push(resultItem);
+      return resultItem;
+    }
+    return resultList[idx];
+  }
+  if (!omitUnusedDimensions) {
+    for (var i = 0; i < dimCount; i++) {
+      getResultItem(i);
+    }
+  }
+  // Set `coordDim` and `coordDimIndex` by `encodeDefMap` and normalize `encodeDefMap`.
+  encodeDefMap.each(function (dataDimsRaw, coordDim) {
+    var dataDims = model.normalizeToArray(dataDimsRaw).slice();
+    // Note: It is allowed that `dataDims.length` is `0`, e.g., options is
+    // `{encode: {x: -1, y: 1}}`. Should not filter anything in
+    // this case.
+    if (dataDims.length === 1 && !util.isString(dataDims[0]) && dataDims[0] < 0) {
+      encodeDefMap.set(coordDim, false);
+      return;
+    }
+    var validDataDims = encodeDefMap.set(coordDim, []);
+    util.each(dataDims, function (resultDimIdxOrName, idx) {
+      // The input resultDimIdx can be dim name or index.
+      var resultDimIdx = util.isString(resultDimIdxOrName) ? dataDimNameMap.get(resultDimIdxOrName) : resultDimIdxOrName;
+      if (resultDimIdx != null && resultDimIdx < dimCount) {
+        validDataDims[idx] = resultDimIdx;
+        applyDim(getResultItem(resultDimIdx), coordDim, idx);
+      }
+    });
+  });
+  // Apply templates and default order from `sysDims`.
+  var availDimIdx = 0;
+  util.each(sysDims, function (sysDimItemRaw) {
+    var coordDim;
+    var sysDimItemDimsDef;
+    var sysDimItemOtherDims;
+    var sysDimItem;
+    if (util.isString(sysDimItemRaw)) {
+      coordDim = sysDimItemRaw;
+      sysDimItem = {};
+    } else {
+      sysDimItem = sysDimItemRaw;
+      coordDim = sysDimItem.name;
+      var ordinalMeta = sysDimItem.ordinalMeta;
+      sysDimItem.ordinalMeta = null;
+      sysDimItem = util.extend({}, sysDimItem);
+      sysDimItem.ordinalMeta = ordinalMeta;
+      // `coordDimIndex` should not be set directly.
+      sysDimItemDimsDef = sysDimItem.dimsDef;
+      sysDimItemOtherDims = sysDimItem.otherDims;
+      sysDimItem.name = sysDimItem.coordDim = sysDimItem.coordDimIndex = sysDimItem.dimsDef = sysDimItem.otherDims = null;
+    }
+    var dataDims = encodeDefMap.get(coordDim);
+    // negative resultDimIdx means no need to mapping.
+    if (dataDims === false) {
+      return;
+    }
+    dataDims = model.normalizeToArray(dataDims);
+    // dimensions provides default dim sequences.
+    if (!dataDims.length) {
+      for (var i = 0; i < (sysDimItemDimsDef && sysDimItemDimsDef.length || 1); i++) {
+        while (availDimIdx < dimCount && getResultItem(availDimIdx).coordDim != null) {
+          availDimIdx++;
+        }
+        availDimIdx < dimCount && dataDims.push(availDimIdx++);
+      }
+    }
+    // Apply templates.
+    util.each(dataDims, function (resultDimIdx, coordDimIndex) {
+      var resultItem = getResultItem(resultDimIdx);
+      // Coordinate system has a higher priority on dim type than source.
+      if (isUsingSourceDimensionsDef && sysDimItem.type != null) {
+        resultItem.type = sysDimItem.type;
+      }
+      applyDim(util.defaults(resultItem, sysDimItem), coordDim, coordDimIndex);
+      if (resultItem.name == null && sysDimItemDimsDef) {
+        var sysDimItemDimsDefItem = sysDimItemDimsDef[coordDimIndex];
+        !util.isObject(sysDimItemDimsDefItem) && (sysDimItemDimsDefItem = {
+          name: sysDimItemDimsDefItem
+        });
+        resultItem.name = resultItem.displayName = sysDimItemDimsDefItem.name;
+        resultItem.defaultTooltip = sysDimItemDimsDefItem.defaultTooltip;
+      }
+      // FIXME refactor, currently only used in case: {otherDims: {tooltip: false}}
+      sysDimItemOtherDims && util.defaults(resultItem.otherDims, sysDimItemOtherDims);
+    });
+  });
+  function applyDim(resultItem, coordDim, coordDimIndex) {
+    if (types.VISUAL_DIMENSIONS.get(coordDim) != null) {
+      resultItem.otherDims[coordDim] = coordDimIndex;
+    } else {
+      resultItem.coordDim = coordDim;
+      resultItem.coordDimIndex = coordDimIndex;
+      coordDimNameMap.set(coordDim, true);
+    }
+  }
+  // Make sure the first extra dim is 'value'.
+  var generateCoord = opt.generateCoord;
+  var generateCoordCount = opt.generateCoordCount;
+  var fromZero = generateCoordCount != null;
+  generateCoordCount = generateCoord ? generateCoordCount || 1 : 0;
+  var extra = generateCoord || 'value';
+  function ifNoNameFillWithCoordName(resultItem) {
+    if (resultItem.name == null) {
+      // Duplication will be removed in the next step.
+      resultItem.name = resultItem.coordDim;
+    }
+  }
+  // Set dim `name` and other `coordDim` and other props.
+  if (!omitUnusedDimensions) {
+    for (var resultDimIdx = 0; resultDimIdx < dimCount; resultDimIdx++) {
+      var resultItem = getResultItem(resultDimIdx);
+      var coordDim = resultItem.coordDim;
+      if (coordDim == null) {
+        // TODO no need to generate coordDim for isExtraCoord?
+        resultItem.coordDim = genCoordDimName(extra, coordDimNameMap, fromZero);
+        resultItem.coordDimIndex = 0;
+        // Series specified generateCoord is using out.
+        if (!generateCoord || generateCoordCount <= 0) {
+          resultItem.isExtraCoord = true;
+        }
+        generateCoordCount--;
+      }
+      ifNoNameFillWithCoordName(resultItem);
+      if (resultItem.type == null && (sourceHelper.guessOrdinal(source, resultDimIdx) === sourceHelper.BE_ORDINAL.Must
+      // Consider the case:
+      // {
+      //    dataset: {source: [
+      //        ['2001', 123],
+      //        ['2002', 456],
+      //        ...
+      //        ['The others', 987],
+      //    ]},
+      //    series: {type: 'pie'}
+      // }
+      // The first column should better be treated as a "ordinal" although it
+      // might not be detected as an "ordinal" by `guessOrdinal`.
+      || resultItem.isExtraCoord && (resultItem.otherDims.itemName != null || resultItem.otherDims.seriesName != null))) {
+        resultItem.type = 'ordinal';
+      }
+    }
+  } else {
+    util.each(resultList, function (resultItem) {
+      // PENDING: guessOrdinal or let user specify type: 'ordinal' manually?
+      ifNoNameFillWithCoordName(resultItem);
+    });
+    // Sort dimensions: there are some rule that use the last dim as label,
+    // and for some latter travel process easier.
+    resultList.sort(function (item0, item1) {
+      return item0.storeDimIndex - item1.storeDimIndex;
+    });
+  }
+  removeDuplication(resultList);
+  return new SeriesDataSchema.SeriesDataSchema({
+    source: source,
+    dimensions: resultList,
+    fullDimensionCount: dimCount,
+    dimensionOmitted: omitUnusedDimensions
+  });
+}
+function removeDuplication(result) {
+  var duplicationMap = util.createHashMap();
+  for (var i = 0; i < result.length; i++) {
+    var dim = result[i];
+    var dimOriginalName = dim.name;
+    var count = duplicationMap.get(dimOriginalName) || 0;
+    if (count > 0) {
+      // Starts from 0.
+      dim.name = dimOriginalName + (count - 1);
+    }
+    count++;
+    duplicationMap.set(dimOriginalName, count);
+  }
+}
+// ??? TODO
+// Originally detect dimCount by data[0]. Should we
+// optimize it to only by sysDims and dimensions and encode.
+// So only necessary dims will be initialized.
+// But
+// (1) custom series should be considered. where other dims
+// may be visited.
+// (2) sometimes user need to calculate bubble size or use visualMap
+// on other dimensions besides coordSys needed.
+// So, dims that is not used by system, should be shared in data store?
+function getDimCount(source, sysDims, dimsDef, optDimCount) {
+  // Note that the result dimCount should not small than columns count
+  // of data, otherwise `dataDimNameMap` checking will be incorrect.
+  var dimCount = Math.max(source.dimensionsDetectedCount || 1, sysDims.length, dimsDef.length, optDimCount || 0);
+  util.each(sysDims, function (sysDimItem) {
+    var sysDimItemDimsDef;
+    if (util.isObject(sysDimItem) && (sysDimItemDimsDef = sysDimItem.dimsDef)) {
+      dimCount = Math.max(dimCount, sysDimItemDimsDef.length);
+    }
+  });
+  return dimCount;
+}
+function genCoordDimName(name, map, fromZero) {
+  if (fromZero || map.hasKey(name)) {
+    var i = 0;
+    while (map.hasKey(name + i)) {
+      i++;
+    }
+    name += i;
+  }
+  map.set(name, true);
+  return name;
+}
+
+exports.createDimensions = createDimensions;
+exports.default = prepareSeriesDataSchema;