text: 
  /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
  
  
  /**
   * AUTO-GENERATED FILE. DO NOT MODIFY.
   */
  
  /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
  import { VISUAL_DIMENSIONS } from '../../util/types';
  import SeriesDimensionDefine from '../SeriesDimensionDefine';
  import { createHashMap, defaults, each, extend, isObject, isString } from 'zrender/lib/core/util';
  import { createSourceFromSeriesDataOption, isSourceInstance } from '../Source';
  import { CtorInt32Array } from '../DataStore';
  import { normalizeToArray } from '../../util/model';
  import { BE_ORDINAL, guessOrdinal } from './sourceHelper';
  import { createDimNameMap, ensureSourceDimNameMap, SeriesDataSchema, shouldOmitUnusedDimensions } from './SeriesDataSchema';
  /**
   * For outside usage compat (like echarts-gl are using it).
   */
  
  export 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.
   */
  
  export default function prepareSeriesDataSchema( // TODO: TYPE completeDimensions type
  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); // Try to ignore unsed dimensions if sharing a high dimension datastore
    // 30 is an experience value.
  
    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 resultItem = new SeriesDimensionDefine();
        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 diplayed 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 = 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 && !isString(dataDims[0]) && dataDims[0] < 0) {
        encodeDefMap.set(coordDim, false);
        return;
      }
  
      var validDataDims = encodeDefMap.set(coordDim, []);
      each(dataDims, function (resultDimIdxOrName, idx) {
        // The input resultDimIdx can be dim name or index.
        var resultDimIdx = isString(resultDimIdxOrName) ? dataDimNameMap.get(resultDimIdxOrName) : resultDimIdxOrName;
  
        if (resultDimIdx != null && resultDimIdx < dimCount) {
          validDataDims[idx] = resultDimIdx;
          applyDim(getResultItem(resultDimIdx), coordDim, idx);
        }
      });
    }); // Apply templetes and default order from `sysDims`.
  
    var availDimIdx = 0;
    each(sysDims, function (sysDimItemRaw) {
      var coordDim;
      var sysDimItemDimsDef;
      var sysDimItemOtherDims;
      var sysDimItem;
  
      if (isString(sysDimItemRaw)) {
        coordDim = sysDimItemRaw;
        sysDimItem = {};
      } else {
        sysDimItem = sysDimItemRaw;
        coordDim = sysDimItem.name;
        var ordinalMeta = sysDimItem.ordinalMeta;
        sysDimItem.ordinalMeta = null;
        sysDimItem = 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 = 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.
  
  
      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(defaults(resultItem, sysDimItem), coordDim, coordDimIndex);
  
        if (resultItem.name == null && sysDimItemDimsDef) {
          var sysDimItemDimsDefItem = sysDimItemDimsDef[coordDimIndex];
          !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 && defaults(resultItem.otherDims, sysDimItemOtherDims);
      });
    });
  
    function applyDim(resultItem, coordDim, coordDimIndex) {
      if (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 && (guessOrdinal(source, resultDimIdx) === BE_ORDINAL.Must // Consider the case:
        // {
        //    dataset: {source: [
        //        ['2001', 123],
        //        ['2002', 456],
        //        ...
        //        ['The others', 987],
        //    ]},
        //    series: {type: 'pie'}
        // }
        // The first colum should better be treated as a "ordinal" although it
        // might not able to be detected as an "ordinal" by `guessOrdinal`.
        || resultItem.isExtraCoord && (resultItem.otherDims.itemName != null || resultItem.otherDims.seriesName != null))) {
          resultItem.type = 'ordinal';
        }
      }
    } else {
      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({
      source: 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) {
        // 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 calcualte 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);
    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) {
    var mapData = map.data;
  
    if (fromZero || mapData.hasOwnProperty(name)) {
      var i = 0;
  
      while (mapData.hasOwnProperty(name + i)) {
        i++;
      }
  
      name += i;
    }
  
    map.set(name, true);
    return name;
  }