@fecp/mobile 1.0.79 → 1.1.1

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/data/Source.mjs

@@ -0,0 +1,211 @@
+import { isTypedArray, clone, isArray, isObject, hasOwn, isArrayLike, isNumber, each, createHashMap, map, keys, isString } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { SOURCE_FORMAT_TYPED_ARRAY, SOURCE_FORMAT_ORIGINAL, SOURCE_FORMAT_KEYED_COLUMNS, SOURCE_FORMAT_UNKNOWN, SERIES_LAYOUT_BY_COLUMN, SOURCE_FORMAT_OBJECT_ROWS, SOURCE_FORMAT_ARRAY_ROWS, SERIES_LAYOUT_BY_ROW } from "../util/types.mjs";
+import { getDataItemValue } from "../util/model.mjs";
+import { guessOrdinal, BE_ORDINAL } from "./helper/sourceHelper.mjs";
+var SourceImpl = (
+  /** @class */
+  /* @__PURE__ */ function() {
+    function SourceImpl2(fields) {
+      this.data = fields.data || (fields.sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS ? {} : []);
+      this.sourceFormat = fields.sourceFormat || SOURCE_FORMAT_UNKNOWN;
+      this.seriesLayoutBy = fields.seriesLayoutBy || SERIES_LAYOUT_BY_COLUMN;
+      this.startIndex = fields.startIndex || 0;
+      this.dimensionsDetectedCount = fields.dimensionsDetectedCount;
+      this.metaRawOption = fields.metaRawOption;
+      var dimensionsDefine = this.dimensionsDefine = fields.dimensionsDefine;
+      if (dimensionsDefine) {
+        for (var i = 0; i < dimensionsDefine.length; i++) {
+          var dim = dimensionsDefine[i];
+          if (dim.type == null) {
+            if (guessOrdinal(this, i) === BE_ORDINAL.Must) {
+              dim.type = "ordinal";
+            }
+          }
+        }
+      }
+    }
+    return SourceImpl2;
+  }()
+);
+function isSourceInstance(val) {
+  return val instanceof SourceImpl;
+}
+function createSource(sourceData, thisMetaRawOption, sourceFormat) {
+  sourceFormat = sourceFormat || detectSourceFormat(sourceData);
+  var seriesLayoutBy = thisMetaRawOption.seriesLayoutBy;
+  var determined = determineSourceDimensions(sourceData, sourceFormat, seriesLayoutBy, thisMetaRawOption.sourceHeader, thisMetaRawOption.dimensions);
+  var source = new SourceImpl({
+    data: sourceData,
+    sourceFormat,
+    seriesLayoutBy,
+    dimensionsDefine: determined.dimensionsDefine,
+    startIndex: determined.startIndex,
+    dimensionsDetectedCount: determined.dimensionsDetectedCount,
+    metaRawOption: clone(thisMetaRawOption)
+  });
+  return source;
+}
+function createSourceFromSeriesDataOption(data) {
+  return new SourceImpl({
+    data,
+    sourceFormat: isTypedArray(data) ? SOURCE_FORMAT_TYPED_ARRAY : SOURCE_FORMAT_ORIGINAL
+  });
+}
+function cloneSourceShallow(source) {
+  return new SourceImpl({
+    data: source.data,
+    sourceFormat: source.sourceFormat,
+    seriesLayoutBy: source.seriesLayoutBy,
+    dimensionsDefine: clone(source.dimensionsDefine),
+    startIndex: source.startIndex,
+    dimensionsDetectedCount: source.dimensionsDetectedCount
+  });
+}
+function detectSourceFormat(data) {
+  var sourceFormat = SOURCE_FORMAT_UNKNOWN;
+  if (isTypedArray(data)) {
+    sourceFormat = SOURCE_FORMAT_TYPED_ARRAY;
+  } else if (isArray(data)) {
+    if (data.length === 0) {
+      sourceFormat = SOURCE_FORMAT_ARRAY_ROWS;
+    }
+    for (var i = 0, len = data.length; i < len; i++) {
+      var item = data[i];
+      if (item == null) {
+        continue;
+      } else if (isArray(item) || isTypedArray(item)) {
+        sourceFormat = SOURCE_FORMAT_ARRAY_ROWS;
+        break;
+      } else if (isObject(item)) {
+        sourceFormat = SOURCE_FORMAT_OBJECT_ROWS;
+        break;
+      }
+    }
+  } else if (isObject(data)) {
+    for (var key in data) {
+      if (hasOwn(data, key) && isArrayLike(data[key])) {
+        sourceFormat = SOURCE_FORMAT_KEYED_COLUMNS;
+        break;
+      }
+    }
+  }
+  return sourceFormat;
+}
+function determineSourceDimensions(data, sourceFormat, seriesLayoutBy, sourceHeader, dimensionsDefine) {
+  var dimensionsDetectedCount;
+  var startIndex;
+  if (!data) {
+    return {
+      dimensionsDefine: normalizeDimensionsOption(dimensionsDefine),
+      startIndex,
+      dimensionsDetectedCount
+    };
+  }
+  if (sourceFormat === SOURCE_FORMAT_ARRAY_ROWS) {
+    var dataArrayRows = data;
+    if (sourceHeader === "auto" || sourceHeader == null) {
+      arrayRowsTravelFirst(function(val) {
+        if (val != null && val !== "-") {
+          if (isString(val)) {
+            startIndex == null && (startIndex = 1);
+          } else {
+            startIndex = 0;
+          }
+        }
+      }, seriesLayoutBy, dataArrayRows, 10);
+    } else {
+      startIndex = isNumber(sourceHeader) ? sourceHeader : sourceHeader ? 1 : 0;
+    }
+    if (!dimensionsDefine && startIndex === 1) {
+      dimensionsDefine = [];
+      arrayRowsTravelFirst(function(val, index) {
+        dimensionsDefine[index] = val != null ? val + "" : "";
+      }, seriesLayoutBy, dataArrayRows, Infinity);
+    }
+    dimensionsDetectedCount = dimensionsDefine ? dimensionsDefine.length : seriesLayoutBy === SERIES_LAYOUT_BY_ROW ? dataArrayRows.length : dataArrayRows[0] ? dataArrayRows[0].length : null;
+  } else if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS) {
+    if (!dimensionsDefine) {
+      dimensionsDefine = objectRowsCollectDimensions(data);
+    }
+  } else if (sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS) {
+    if (!dimensionsDefine) {
+      dimensionsDefine = [];
+      each(data, function(colArr, key) {
+        dimensionsDefine.push(key);
+      });
+    }
+  } else if (sourceFormat === SOURCE_FORMAT_ORIGINAL) {
+    var value0 = getDataItemValue(data[0]);
+    dimensionsDetectedCount = isArray(value0) && value0.length || 1;
+  } else ;
+  return {
+    startIndex,
+    dimensionsDefine: normalizeDimensionsOption(dimensionsDefine),
+    dimensionsDetectedCount
+  };
+}
+function objectRowsCollectDimensions(data) {
+  var firstIndex = 0;
+  var obj;
+  while (firstIndex < data.length && !(obj = data[firstIndex++])) {
+  }
+  if (obj) {
+    return keys(obj);
+  }
+}
+function normalizeDimensionsOption(dimensionsDefine) {
+  if (!dimensionsDefine) {
+    return;
+  }
+  var nameMap = createHashMap();
+  return map(dimensionsDefine, function(rawItem, index) {
+    rawItem = isObject(rawItem) ? rawItem : {
+      name: rawItem
+    };
+    var item = {
+      name: rawItem.name,
+      displayName: rawItem.displayName,
+      type: rawItem.type
+    };
+    if (item.name == null) {
+      return item;
+    }
+    item.name += "";
+    if (item.displayName == null) {
+      item.displayName = item.name;
+    }
+    var exist = nameMap.get(item.name);
+    if (!exist) {
+      nameMap.set(item.name, {
+        count: 1
+      });
+    } else {
+      item.name += "-" + exist.count++;
+    }
+    return item;
+  });
+}
+function arrayRowsTravelFirst(cb, seriesLayoutBy, data, maxLoop) {
+  if (seriesLayoutBy === SERIES_LAYOUT_BY_ROW) {
+    for (var i = 0; i < data.length && i < maxLoop; i++) {
+      cb(data[i] ? data[i][0] : null, i);
+    }
+  } else {
+    var value0 = data[0] || [];
+    for (var i = 0; i < value0.length && i < maxLoop; i++) {
+      cb(value0[i], i);
+    }
+  }
+}
+function shouldRetrieveDataByName(source) {
+  var sourceFormat = source.sourceFormat;
+  return sourceFormat === SOURCE_FORMAT_OBJECT_ROWS || sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS;
+}
+export {
+  cloneSourceShallow,
+  createSource,
+  createSourceFromSeriesDataOption,
+  detectSourceFormat,
+  isSourceInstance,
+  shouldRetrieveDataByName
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/data/helper/SeriesDataSchema.mjs

@@ -0,0 +1,144 @@
+import { createHashMap, isObject, retrieve2 } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { makeInner } from "../../util/model.mjs";
+import { shouldRetrieveDataByName } from "../Source.mjs";
+var inner = makeInner();
+var dimTypeShort = {
+  float: "f",
+  int: "i",
+  ordinal: "o",
+  number: "n",
+  time: "t"
+};
+var SeriesDataSchema = (
+  /** @class */
+  function() {
+    function SeriesDataSchema2(opt) {
+      this.dimensions = opt.dimensions;
+      this._dimOmitted = opt.dimensionOmitted;
+      this.source = opt.source;
+      this._fullDimCount = opt.fullDimensionCount;
+      this._updateDimOmitted(opt.dimensionOmitted);
+    }
+    SeriesDataSchema2.prototype.isDimensionOmitted = function() {
+      return this._dimOmitted;
+    };
+    SeriesDataSchema2.prototype._updateDimOmitted = function(dimensionOmitted) {
+      this._dimOmitted = dimensionOmitted;
+      if (!dimensionOmitted) {
+        return;
+      }
+      if (!this._dimNameMap) {
+        this._dimNameMap = ensureSourceDimNameMap(this.source);
+      }
+    };
+    SeriesDataSchema2.prototype.getSourceDimensionIndex = function(dimName) {
+      return retrieve2(this._dimNameMap.get(dimName), -1);
+    };
+    SeriesDataSchema2.prototype.getSourceDimension = function(dimIndex) {
+      var dimensionsDefine = this.source.dimensionsDefine;
+      if (dimensionsDefine) {
+        return dimensionsDefine[dimIndex];
+      }
+    };
+    SeriesDataSchema2.prototype.makeStoreSchema = function() {
+      var dimCount = this._fullDimCount;
+      var willRetrieveDataByName = shouldRetrieveDataByName(this.source);
+      var makeHashStrict = !shouldOmitUnusedDimensions(dimCount);
+      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];
+        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,
+          type,
+          ordinalMeta
+        });
+        if (willRetrieveDataByName && property != null && (!seriesDimDef || !seriesDimDef.isCalculationCoord)) {
+          dimHash += makeHashStrict ? property.replace(/\`/g, "`1").replace(/\$/g, "`2") : property;
+        }
+        dimHash += "$";
+        dimHash += dimTypeShort[type] || "f";
+        if (ordinalMeta) {
+          dimHash += ordinalMeta.uid;
+        }
+        dimHash += "$";
+      }
+      var source = this.source;
+      var hash = [source.seriesLayoutBy, source.startIndex, dimHash].join("$$");
+      return {
+        dimensions: dims,
+        hash
+      };
+    };
+    SeriesDataSchema2.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];
+        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;
+    };
+    SeriesDataSchema2.prototype.appendCalculationDimension = function(dimDef) {
+      this.dimensions.push(dimDef);
+      dimDef.isCalculationCoord = true;
+      this._fullDimCount++;
+      this._updateDimOmitted(true);
+    };
+    return SeriesDataSchema2;
+  }()
+);
+function isSeriesDataSchema(schema) {
+  return schema instanceof SeriesDataSchema;
+}
+function createDimNameMap(dimsDef) {
+  var dataDimNameMap = createHashMap();
+  for (var i = 0; i < (dimsDef || []).length; i++) {
+    var dimDefItemRaw = dimsDef[i];
+    var userDimName = 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;
+}
+export {
+  SeriesDataSchema,
+  createDimNameMap,
+  ensureSourceDimNameMap,
+  isSeriesDataSchema,
+  shouldOmitUnusedDimensions
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/data/helper/createDimensions.mjs

@@ -0,0 +1,215 @@
+import { VISUAL_DIMENSIONS } from "../../util/types.mjs";
+import SeriesDimensionDefine from "../SeriesDimensionDefine.mjs";
+import { createHashMap, isString, each, extend, defaults, isObject } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { isSourceInstance, createSourceFromSeriesDataOption } from "../Source.mjs";
+import { CtorInt32Array } from "../DataStore.mjs";
+import { normalizeToArray } from "../../util/model.mjs";
+import { guessOrdinal, BE_ORDINAL } from "./sourceHelper.mjs";
+import { shouldOmitUnusedDimensions, ensureSourceDimNameMap, createDimNameMap, SeriesDataSchema } from "./SeriesDataSchema.mjs";
+function createDimensions(source, opt) {
+  return prepareSeriesDataSchema(source, opt).dimensions;
+}
+function prepareSeriesDataSchema(source, opt) {
+  if (!isSourceInstance(source)) {
+    source = createSourceFromSeriesDataOption(source);
+  }
+  opt = opt || {};
+  var sysDims = opt.coordDimensions || [];
+  var dimsDef = opt.dimensionsDefine || source.dimensionsDefine || [];
+  var coordDimNameMap = createHashMap();
+  var resultList = [];
+  var dimCount = getDimCount(source, sysDims, dimsDef, opt.dimensionsCount);
+  var omitUnusedDimensions = opt.canOmitUnusedDimensions && shouldOmitUnusedDimensions(dimCount);
+  var isUsingSourceDimensionsDef = dimsDef === source.dimensionsDefine;
+  var dataDimNameMap = isUsingSourceDimensionsDef ? ensureSourceDimNameMap(source) : createDimNameMap(dimsDef);
+  var encodeDef = opt.encodeDefine;
+  if (!encodeDef && opt.encodeDefaulter) {
+    encodeDef = opt.encodeDefaulter(source, dimCount);
+  }
+  var encodeDefMap = createHashMap(encodeDef);
+  var indicesMap = new 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 = isObject(dimDefItemRaw) ? dimDefItemRaw : {
+        name: dimDefItemRaw
+      };
+      var resultItem2 = new SeriesDimensionDefine();
+      var userDimName = dimDefItem.name;
+      if (userDimName != null && dataDimNameMap.get(userDimName) != null) {
+        resultItem2.name = resultItem2.displayName = userDimName;
+      }
+      dimDefItem.type != null && (resultItem2.type = dimDefItem.type);
+      dimDefItem.displayName != null && (resultItem2.displayName = dimDefItem.displayName);
+      var newIdx = resultList.length;
+      indicesMap[dimIdx] = newIdx;
+      resultItem2.storeDimIndex = dimIdx;
+      resultList.push(resultItem2);
+      return resultItem2;
+    }
+    return resultList[idx];
+  }
+  if (!omitUnusedDimensions) {
+    for (var i = 0; i < dimCount; i++) {
+      getResultItem(i);
+    }
+  }
+  encodeDefMap.each(function(dataDimsRaw, coordDim2) {
+    var dataDims = normalizeToArray(dataDimsRaw).slice();
+    if (dataDims.length === 1 && !isString(dataDims[0]) && dataDims[0] < 0) {
+      encodeDefMap.set(coordDim2, false);
+      return;
+    }
+    var validDataDims = encodeDefMap.set(coordDim2, []);
+    each(dataDims, function(resultDimIdxOrName, idx) {
+      var resultDimIdx2 = isString(resultDimIdxOrName) ? dataDimNameMap.get(resultDimIdxOrName) : resultDimIdxOrName;
+      if (resultDimIdx2 != null && resultDimIdx2 < dimCount) {
+        validDataDims[idx] = resultDimIdx2;
+        applyDim(getResultItem(resultDimIdx2), coordDim2, idx);
+      }
+    });
+  });
+  var availDimIdx = 0;
+  each(sysDims, function(sysDimItemRaw) {
+    var coordDim2;
+    var sysDimItemDimsDef;
+    var sysDimItemOtherDims;
+    var sysDimItem;
+    if (isString(sysDimItemRaw)) {
+      coordDim2 = sysDimItemRaw;
+      sysDimItem = {};
+    } else {
+      sysDimItem = sysDimItemRaw;
+      coordDim2 = sysDimItem.name;
+      var ordinalMeta = sysDimItem.ordinalMeta;
+      sysDimItem.ordinalMeta = null;
+      sysDimItem = extend({}, sysDimItem);
+      sysDimItem.ordinalMeta = ordinalMeta;
+      sysDimItemDimsDef = sysDimItem.dimsDef;
+      sysDimItemOtherDims = sysDimItem.otherDims;
+      sysDimItem.name = sysDimItem.coordDim = sysDimItem.coordDimIndex = sysDimItem.dimsDef = sysDimItem.otherDims = null;
+    }
+    var dataDims = encodeDefMap.get(coordDim2);
+    if (dataDims === false) {
+      return;
+    }
+    dataDims = normalizeToArray(dataDims);
+    if (!dataDims.length) {
+      for (var i2 = 0; i2 < (sysDimItemDimsDef && sysDimItemDimsDef.length || 1); i2++) {
+        while (availDimIdx < dimCount && getResultItem(availDimIdx).coordDim != null) {
+          availDimIdx++;
+        }
+        availDimIdx < dimCount && dataDims.push(availDimIdx++);
+      }
+    }
+    each(dataDims, function(resultDimIdx2, coordDimIndex) {
+      var resultItem2 = getResultItem(resultDimIdx2);
+      if (isUsingSourceDimensionsDef && sysDimItem.type != null) {
+        resultItem2.type = sysDimItem.type;
+      }
+      applyDim(defaults(resultItem2, sysDimItem), coordDim2, coordDimIndex);
+      if (resultItem2.name == null && sysDimItemDimsDef) {
+        var sysDimItemDimsDefItem = sysDimItemDimsDef[coordDimIndex];
+        !isObject(sysDimItemDimsDefItem) && (sysDimItemDimsDefItem = {
+          name: sysDimItemDimsDefItem
+        });
+        resultItem2.name = resultItem2.displayName = sysDimItemDimsDefItem.name;
+        resultItem2.defaultTooltip = sysDimItemDimsDefItem.defaultTooltip;
+      }
+      sysDimItemOtherDims && defaults(resultItem2.otherDims, sysDimItemOtherDims);
+    });
+  });
+  function applyDim(resultItem2, coordDim2, coordDimIndex) {
+    if (VISUAL_DIMENSIONS.get(coordDim2) != null) {
+      resultItem2.otherDims[coordDim2] = coordDimIndex;
+    } else {
+      resultItem2.coordDim = coordDim2;
+      resultItem2.coordDimIndex = coordDimIndex;
+      coordDimNameMap.set(coordDim2, true);
+    }
+  }
+  var generateCoord = opt.generateCoord;
+  var generateCoordCount = opt.generateCoordCount;
+  var fromZero = generateCoordCount != null;
+  generateCoordCount = generateCoord ? generateCoordCount || 1 : 0;
+  var extra = generateCoord || "value";
+  function ifNoNameFillWithCoordName(resultItem2) {
+    if (resultItem2.name == null) {
+      resultItem2.name = resultItem2.coordDim;
+    }
+  }
+  if (!omitUnusedDimensions) {
+    for (var resultDimIdx = 0; resultDimIdx < dimCount; resultDimIdx++) {
+      var resultItem = getResultItem(resultDimIdx);
+      var coordDim = resultItem.coordDim;
+      if (coordDim == null) {
+        resultItem.coordDim = genCoordDimName(extra, coordDimNameMap, fromZero);
+        resultItem.coordDimIndex = 0;
+        if (!generateCoord || generateCoordCount <= 0) {
+          resultItem.isExtraCoord = true;
+        }
+        generateCoordCount--;
+      }
+      ifNoNameFillWithCoordName(resultItem);
+      if (resultItem.type == null && (guessOrdinal(source, resultDimIdx) === BE_ORDINAL.Must || resultItem.isExtraCoord && (resultItem.otherDims.itemName != null || resultItem.otherDims.seriesName != null))) {
+        resultItem.type = "ordinal";
+      }
+    }
+  } else {
+    each(resultList, function(resultItem2) {
+      ifNoNameFillWithCoordName(resultItem2);
+    });
+    resultList.sort(function(item0, item1) {
+      return item0.storeDimIndex - item1.storeDimIndex;
+    });
+  }
+  removeDuplication(resultList);
+  return new SeriesDataSchema({
+    source,
+    dimensions: resultList,
+    fullDimensionCount: dimCount,
+    dimensionOmitted: omitUnusedDimensions
+  });
+}
+function removeDuplication(result) {
+  var duplicationMap = 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) {
+      dim.name = dimOriginalName + (count - 1);
+    }
+    count++;
+    duplicationMap.set(dimOriginalName, count);
+  }
+}
+function getDimCount(source, sysDims, dimsDef, optDimCount) {
+  var dimCount = Math.max(source.dimensionsDetectedCount || 1, sysDims.length, dimsDef.length, optDimCount || 0);
+  each(sysDims, function(sysDimItem) {
+    var sysDimItemDimsDef;
+    if (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;
+}
+export {
+  createDimensions,
+  prepareSeriesDataSchema as default
+};