@fmdevui/fm-dev 1.0.113 → 1.0.114

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/cartesian/Grid.mjs

@@ -0,0 +1,691 @@
+import { keys, each, isObject, indexOf, retrieve3, assert, find, eqNaN, retrieve2 } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+import { createBoxLayoutReference, getLayoutRect } from '../../util/layout.mjs';
+import { niceScaleExtent, createScaleByModel, getDataDimensionsOnAxis, ifAxisCrossZero, shouldAxisShow, isNameLocationCenter } from '../axisHelper.mjs';
+import Cartesian2D, { cartesian2DDimensions } from './Cartesian2D.mjs';
+import Axis2D from './Axis2D.mjs';
+import { SINGLE_REFERRING } from '../../util/model.mjs';
+import { OUTER_BOUNDS_DEFAULT, OUTER_BOUNDS_CLAMP_DEFAULT } from './GridModel.mjs';
+import { isCartesian2DInjectedAsDataCoordSys, findAxisModels, createCartesianAxisViewCommonPartBuilder, updateCartesianAxisViewCommonPartBuilder } from './cartesianAxisHelper.mjs';
+import { isIntervalOrLogScale } from '../../scale/helper.mjs';
+import { alignScaleTicks } from '../axisAlignTicks.mjs';
+import { expandOrShrinkRect, XY, WH } from '../../util/graphic.mjs';
+import { getLabelInner, AxisBuilderSharedContext, resolveAxisNameOverlapDefault, moveIfOverlapByLinearLabels } from '../../component/axis/AxisBuilder.mjs';
+import { log, error } from '../../util/log.mjs';
+import { AxisTickLabelComputingKind } from '../axisTickLabelBuilder.mjs';
+import { injectCoordSysByOption } from '../../core/CoordinateSystem.mjs';
+import { mathMax, parsePositionSizeOption } from '../../util/number.mjs';
+
+// margin is [top, right, bottom, left]
+var XY_TO_MARGIN_IDX = [[3, 1], [0, 2] // xyIdx 1 => 'y'
+];
+var Grid = /** @class */function () {
+  function Grid(gridModel, ecModel, api) {
+    // FIXME:TS where used (different from registered type 'cartesian2d')?
+    this.type = 'grid';
+    this._coordsMap = {};
+    this._coordsList = [];
+    this._axesMap = {};
+    this._axesList = [];
+    this.axisPointerEnabled = true;
+    this.dimensions = cartesian2DDimensions;
+    this._initCartesian(gridModel, ecModel, api);
+    this.model = gridModel;
+  }
+  Grid.prototype.getRect = function () {
+    return this._rect;
+  };
+  Grid.prototype.update = function (ecModel, api) {
+    var axesMap = this._axesMap;
+    this._updateScale(ecModel, this.model);
+    function updateAxisTicks(axes) {
+      var alignTo;
+      // Axis is added in order of axisIndex.
+      var axesIndices = keys(axes);
+      var len = axesIndices.length;
+      if (!len) {
+        return;
+      }
+      var axisNeedsAlign = [];
+      // Process once and calculate the ticks for those don't use alignTicks.
+      for (var i = len - 1; i >= 0; i--) {
+        var idx = +axesIndices[i]; // Convert to number.
+        var axis = axes[idx];
+        var model = axis.model;
+        var scale = axis.scale;
+        if (
+        // Only value and log axis without interval support alignTicks.
+        isIntervalOrLogScale(scale) && model.get('alignTicks') && model.get('interval') == null) {
+          axisNeedsAlign.push(axis);
+        } else {
+          niceScaleExtent(scale, model);
+          if (isIntervalOrLogScale(scale)) {
+            // Can only align to interval or log axis.
+            alignTo = axis;
+          }
+        }
+      }
+      ;
+      // All axes has set alignTicks. Pick the first one.
+      // PENDING. Should we find the axis that both set interval, min, max and align to this one?
+      if (axisNeedsAlign.length) {
+        if (!alignTo) {
+          alignTo = axisNeedsAlign.pop();
+          niceScaleExtent(alignTo.scale, alignTo.model);
+        }
+        each(axisNeedsAlign, function (axis) {
+          alignScaleTicks(axis.scale, axis.model, alignTo.scale);
+        });
+      }
+    }
+    updateAxisTicks(axesMap.x);
+    updateAxisTicks(axesMap.y);
+    // Key: axisDim_axisIndex, value: boolean, whether onZero target.
+    var onZeroRecords = {};
+    each(axesMap.x, function (xAxis) {
+      fixAxisOnZero(axesMap, 'y', xAxis, onZeroRecords);
+    });
+    each(axesMap.y, function (yAxis) {
+      fixAxisOnZero(axesMap, 'x', yAxis, onZeroRecords);
+    });
+    // Resize again if containLabel is enabled
+    // FIXME It may cause getting wrong grid size in data processing stage
+    this.resize(this.model, api);
+  };
+  /**
+   * Resize the grid.
+   *
+   * [NOTE]
+   * If both "grid.containLabel/grid.contain" and pixel-required-data-processing (such as, "dataSampling")
+   * exist, circular dependency occurs in logic.
+   * The final compromised sequence is:
+   *  1. Calculate "axis.extent" (pixel extent) and AffineTransform based on only "grid layout options".
+   *      Not accurate if "grid.containLabel/grid.contain" is required, but it is a compromise to avoid
+   *      circular dependency.
+   *  2. Perform "series data processing" (where "dataSampling" requires "axis.extent").
+   *  3. Calculate "scale.extent" (data extent) based on "processed series data".
+   *  4. Modify "axis.extent" for "grid.containLabel/grid.contain":
+   *      4.1. Calculate "axis labels" based on "scale.extent".
+   *      4.2. Modify "axis.extent" by the bounding rects of "axis labels and names".
+   */
+  Grid.prototype.resize = function (gridModel, api, beforeDataProcessing) {
+    var layoutRef = createBoxLayoutReference(gridModel, api);
+    var gridRect = this._rect = getLayoutRect(gridModel.getBoxLayoutParams(), layoutRef.refContainer);
+    // PENDING: whether to support that if the input `coord` is out of the base coord sys,
+    //  do not render anything. At present, the behavior is undefined.
+    var axesMap = this._axesMap;
+    var coordsList = this._coordsList;
+    var optionContainLabel = gridModel.get('containLabel'); // No `.get(, true)` for backward compat.
+    updateAllAxisExtentTransByGridRect(axesMap, gridRect);
+    if (!beforeDataProcessing) {
+      var axisBuilderSharedCtx = createAxisBiulders(gridRect, coordsList, axesMap, optionContainLabel, api);
+      var noPxChange = void 0;
+      if (optionContainLabel) {
+        if (legacyLayOutGridByContainLabel) {
+          // console.time('legacyLayOutGridByContainLabel');
+          legacyLayOutGridByContainLabel(this._axesList, gridRect);
+          updateAllAxisExtentTransByGridRect(axesMap, gridRect);
+          // console.timeEnd('legacyLayOutGridByContainLabel');
+        } else {
+          if (process.env.NODE_ENV !== 'production') {
+            log('Specified `grid.containLabel` but no `use(LegacyGridContainLabel)`;' + 'use `grid.outerBounds` instead.', true);
+          }
+          noPxChange = layOutGridByOuterBounds(gridRect.clone(), 'axisLabel', null, gridRect, axesMap, axisBuilderSharedCtx, layoutRef);
+        }
+      } else {
+        var _a = prepareOuterBounds(gridModel, gridRect, layoutRef),
+          outerBoundsRect = _a.outerBoundsRect,
+          parsedOuterBoundsContain = _a.parsedOuterBoundsContain,
+          outerBoundsClamp = _a.outerBoundsClamp;
+        if (outerBoundsRect) {
+          // console.time('layOutGridByOuterBounds');
+          noPxChange = layOutGridByOuterBounds(outerBoundsRect, parsedOuterBoundsContain, outerBoundsClamp, gridRect, axesMap, axisBuilderSharedCtx, layoutRef);
+          // console.timeEnd('layOutGridByOuterBounds');
+        }
+      }
+      // console.time('buildAxesView_determine');
+      createOrUpdateAxesView(gridRect, axesMap, AxisTickLabelComputingKind.determine, null, noPxChange, layoutRef);
+      // console.timeEnd('buildAxesView_determine');
+    } // End of beforeDataProcessing
+    each(this._coordsList, function (coord) {
+      // Calculate affine matrix to accelerate the data to point transform.
+      // If all the axes scales are time or value.
+      coord.calcAffineTransform();
+    });
+  };
+  Grid.prototype.getAxis = function (dim, axisIndex) {
+    var axesMapOnDim = this._axesMap[dim];
+    if (axesMapOnDim != null) {
+      return axesMapOnDim[axisIndex || 0];
+    }
+  };
+  Grid.prototype.getAxes = function () {
+    return this._axesList.slice();
+  };
+  Grid.prototype.getCartesian = function (xAxisIndex, yAxisIndex) {
+    if (xAxisIndex != null && yAxisIndex != null) {
+      var key = 'x' + xAxisIndex + 'y' + yAxisIndex;
+      return this._coordsMap[key];
+    }
+    if (isObject(xAxisIndex)) {
+      yAxisIndex = xAxisIndex.yAxisIndex;
+      xAxisIndex = xAxisIndex.xAxisIndex;
+    }
+    for (var i = 0, coordList = this._coordsList; i < coordList.length; i++) {
+      if (coordList[i].getAxis('x').index === xAxisIndex || coordList[i].getAxis('y').index === yAxisIndex) {
+        return coordList[i];
+      }
+    }
+  };
+  Grid.prototype.getCartesians = function () {
+    return this._coordsList.slice();
+  };
+  /**
+   * @implements
+   */
+  Grid.prototype.convertToPixel = function (ecModel, finder, value) {
+    var target = this._findConvertTarget(finder);
+    return target.cartesian ? target.cartesian.dataToPoint(value) : target.axis ? target.axis.toGlobalCoord(target.axis.dataToCoord(value)) : null;
+  };
+  /**
+   * @implements
+   */
+  Grid.prototype.convertFromPixel = function (ecModel, finder, value) {
+    var target = this._findConvertTarget(finder);
+    return target.cartesian ? target.cartesian.pointToData(value) : target.axis ? target.axis.coordToData(target.axis.toLocalCoord(value)) : null;
+  };
+  Grid.prototype._findConvertTarget = function (finder) {
+    var seriesModel = finder.seriesModel;
+    var xAxisModel = finder.xAxisModel || seriesModel && seriesModel.getReferringComponents('xAxis', SINGLE_REFERRING).models[0];
+    var yAxisModel = finder.yAxisModel || seriesModel && seriesModel.getReferringComponents('yAxis', SINGLE_REFERRING).models[0];
+    var gridModel = finder.gridModel;
+    var coordsList = this._coordsList;
+    var cartesian;
+    var axis;
+    if (seriesModel) {
+      cartesian = seriesModel.coordinateSystem;
+      indexOf(coordsList, cartesian) < 0 && (cartesian = null);
+    } else if (xAxisModel && yAxisModel) {
+      cartesian = this.getCartesian(xAxisModel.componentIndex, yAxisModel.componentIndex);
+    } else if (xAxisModel) {
+      axis = this.getAxis('x', xAxisModel.componentIndex);
+    } else if (yAxisModel) {
+      axis = this.getAxis('y', yAxisModel.componentIndex);
+    }
+    // Lowest priority.
+    else if (gridModel) {
+      var grid = gridModel.coordinateSystem;
+      if (grid === this) {
+        cartesian = this._coordsList[0];
+      }
+    }
+    return {
+      cartesian: cartesian,
+      axis: axis
+    };
+  };
+  /**
+   * @implements
+   */
+  Grid.prototype.containPoint = function (point) {
+    var coord = this._coordsList[0];
+    if (coord) {
+      return coord.containPoint(point);
+    }
+  };
+  /**
+   * Initialize cartesian coordinate systems
+   */
+  Grid.prototype._initCartesian = function (gridModel, ecModel, api) {
+    var _this = this;
+    var grid = this;
+    var axisPositionUsed = {
+      left: false,
+      right: false,
+      top: false,
+      bottom: false
+    };
+    var axesMap = {
+      x: {},
+      y: {}
+    };
+    var axesCount = {
+      x: 0,
+      y: 0
+    };
+    // Create axis
+    ecModel.eachComponent('xAxis', createAxisCreator('x'), this);
+    ecModel.eachComponent('yAxis', createAxisCreator('y'), this);
+    if (!axesCount.x || !axesCount.y) {
+      // Roll back when there no either x or y axis
+      this._axesMap = {};
+      this._axesList = [];
+      return;
+    }
+    this._axesMap = axesMap;
+    // Create cartesian2d
+    each(axesMap.x, function (xAxis, xAxisIndex) {
+      each(axesMap.y, function (yAxis, yAxisIndex) {
+        var key = 'x' + xAxisIndex + 'y' + yAxisIndex;
+        var cartesian = new Cartesian2D(key);
+        cartesian.master = _this;
+        cartesian.model = gridModel;
+        _this._coordsMap[key] = cartesian;
+        _this._coordsList.push(cartesian);
+        cartesian.addAxis(xAxis);
+        cartesian.addAxis(yAxis);
+      });
+    });
+    function createAxisCreator(dimName) {
+      return function (axisModel, idx) {
+        if (!isAxisUsedInTheGrid(axisModel, gridModel)) {
+          return;
+        }
+        var axisPosition = axisModel.get('position');
+        if (dimName === 'x') {
+          // Fix position
+          if (axisPosition !== 'top' && axisPosition !== 'bottom') {
+            // Default bottom of X
+            axisPosition = axisPositionUsed.bottom ? 'top' : 'bottom';
+          }
+        } else {
+          // Fix position
+          if (axisPosition !== 'left' && axisPosition !== 'right') {
+            // Default left of Y
+            axisPosition = axisPositionUsed.left ? 'right' : 'left';
+          }
+        }
+        axisPositionUsed[axisPosition] = true;
+        var axis = new Axis2D(dimName, createScaleByModel(axisModel), [0, 0], axisModel.get('type'), axisPosition);
+        var isCategory = axis.type === 'category';
+        axis.onBand = isCategory && axisModel.get('boundaryGap');
+        axis.inverse = axisModel.get('inverse');
+        // Inject axis into axisModel
+        axisModel.axis = axis;
+        // Inject axisModel into axis
+        axis.model = axisModel;
+        // Inject grid info axis
+        axis.grid = grid;
+        // Index of axis, can be used as key
+        axis.index = idx;
+        grid._axesList.push(axis);
+        axesMap[dimName][idx] = axis;
+        axesCount[dimName]++;
+      };
+    }
+  };
+  /**
+   * Update cartesian properties from series.
+   */
+  Grid.prototype._updateScale = function (ecModel, gridModel) {
+    // Reset scale
+    each(this._axesList, function (axis) {
+      axis.scale.setExtent(Infinity, -Infinity);
+      if (axis.type === 'category') {
+        var categorySortInfo = axis.model.get('categorySortInfo');
+        axis.scale.setSortInfo(categorySortInfo);
+      }
+    });
+    ecModel.eachSeries(function (seriesModel) {
+      // If pie (or other similar series) use cartesian2d, the unionExtent logic below is
+      // wrong, therefore skip it temporarily. See also in `defaultAxisExtentFromData.ts`.
+      // TODO: support union extent in this case.
+      if (isCartesian2DInjectedAsDataCoordSys(seriesModel)) {
+        var axesModelMap = findAxisModels(seriesModel);
+        var xAxisModel = axesModelMap.xAxisModel;
+        var yAxisModel = axesModelMap.yAxisModel;
+        if (!isAxisUsedInTheGrid(xAxisModel, gridModel) || !isAxisUsedInTheGrid(yAxisModel, gridModel)) {
+          return;
+        }
+        var cartesian = this.getCartesian(xAxisModel.componentIndex, yAxisModel.componentIndex);
+        var data = seriesModel.getData();
+        var xAxis = cartesian.getAxis('x');
+        var yAxis = cartesian.getAxis('y');
+        unionExtent(data, xAxis);
+        unionExtent(data, yAxis);
+      }
+    }, this);
+    function unionExtent(data, axis) {
+      each(getDataDimensionsOnAxis(data, axis.dim), function (dim) {
+        axis.scale.unionExtentFromData(data, dim);
+      });
+    }
+  };
+  /**
+   * @param dim 'x' or 'y' or 'auto' or null/undefined
+   */
+  Grid.prototype.getTooltipAxes = function (dim) {
+    var baseAxes = [];
+    var otherAxes = [];
+    each(this.getCartesians(), function (cartesian) {
+      var baseAxis = dim != null && dim !== 'auto' ? cartesian.getAxis(dim) : cartesian.getBaseAxis();
+      var otherAxis = cartesian.getOtherAxis(baseAxis);
+      indexOf(baseAxes, baseAxis) < 0 && baseAxes.push(baseAxis);
+      indexOf(otherAxes, otherAxis) < 0 && otherAxes.push(otherAxis);
+    });
+    return {
+      baseAxes: baseAxes,
+      otherAxes: otherAxes
+    };
+  };
+  Grid.create = function (ecModel, api) {
+    var grids = [];
+    ecModel.eachComponent('grid', function (gridModel, idx) {
+      var grid = new Grid(gridModel, ecModel, api);
+      grid.name = 'grid_' + idx;
+      // dataSampling requires axis extent, so resize
+      // should be performed in create stage.
+      grid.resize(gridModel, api, true);
+      gridModel.coordinateSystem = grid;
+      grids.push(grid);
+    });
+    // Inject the coordinateSystems into seriesModel
+    ecModel.eachSeries(function (seriesModel) {
+      injectCoordSysByOption({
+        targetModel: seriesModel,
+        coordSysType: 'cartesian2d',
+        coordSysProvider: coordSysProvider
+      });
+      function coordSysProvider() {
+        var axesModelMap = findAxisModels(seriesModel);
+        var xAxisModel = axesModelMap.xAxisModel;
+        var yAxisModel = axesModelMap.yAxisModel;
+        var gridModel = xAxisModel.getCoordSysModel();
+        if (process.env.NODE_ENV !== 'production') {
+          if (!gridModel) {
+            throw new Error('Grid "' + retrieve3(xAxisModel.get('gridIndex'), xAxisModel.get('gridId'), 0) + '" not found');
+          }
+          if (xAxisModel.getCoordSysModel() !== yAxisModel.getCoordSysModel()) {
+            throw new Error('xAxis and yAxis must use the same grid');
+          }
+        }
+        var grid = gridModel.coordinateSystem;
+        return grid.getCartesian(xAxisModel.componentIndex, yAxisModel.componentIndex);
+      }
+    });
+    return grids;
+  };
+  // For deciding which dimensions to use when creating list data
+  Grid.dimensions = cartesian2DDimensions;
+  return Grid;
+}();
+/**
+ * Check if the axis is used in the specified grid.
+ */
+function isAxisUsedInTheGrid(axisModel, gridModel) {
+  return axisModel.getCoordSysModel() === gridModel;
+}
+function fixAxisOnZero(axesMap, otherAxisDim, axis,
+// Key: see `getOnZeroRecordKey`
+onZeroRecords) {
+  axis.getAxesOnZeroOf = function () {
+    // TODO: onZero of multiple axes.
+    return otherAxisOnZeroOf ? [otherAxisOnZeroOf] : [];
+  };
+  // onZero can not be enabled in these two situations:
+  // 1. When any other axis is a category axis.
+  // 2. When no axis is cross 0 point.
+  var otherAxes = axesMap[otherAxisDim];
+  var otherAxisOnZeroOf;
+  var axisModel = axis.model;
+  var onZero = axisModel.get(['axisLine', 'onZero']);
+  var onZeroAxisIndex = axisModel.get(['axisLine', 'onZeroAxisIndex']);
+  if (!onZero) {
+    return;
+  }
+  // If target axis is specified.
+  if (onZeroAxisIndex != null) {
+    if (canOnZeroToAxis(otherAxes[onZeroAxisIndex])) {
+      otherAxisOnZeroOf = otherAxes[onZeroAxisIndex];
+    }
+  } else {
+    // Find the first available other axis.
+    for (var idx in otherAxes) {
+      if (otherAxes.hasOwnProperty(idx) && canOnZeroToAxis(otherAxes[idx])
+      // Consider that two Y axes on one value axis,
+      // if both onZero, the two Y axes overlap.
+      && !onZeroRecords[getOnZeroRecordKey(otherAxes[idx])]) {
+        otherAxisOnZeroOf = otherAxes[idx];
+        break;
+      }
+    }
+  }
+  if (otherAxisOnZeroOf) {
+    onZeroRecords[getOnZeroRecordKey(otherAxisOnZeroOf)] = true;
+  }
+  function getOnZeroRecordKey(axis) {
+    return axis.dim + '_' + axis.index;
+  }
+}
+function canOnZeroToAxis(axis) {
+  return axis && axis.type !== 'category' && axis.type !== 'time' && ifAxisCrossZero(axis);
+}
+function updateAxisTransform(axis, coordBase) {
+  var axisExtent = axis.getExtent();
+  var axisExtentSum = axisExtent[0] + axisExtent[1];
+  // Fast transform
+  axis.toGlobalCoord = axis.dim === 'x' ? function (coord) {
+    return coord + coordBase;
+  } : function (coord) {
+    return axisExtentSum - coord + coordBase;
+  };
+  axis.toLocalCoord = axis.dim === 'x' ? function (coord) {
+    return coord - coordBase;
+  } : function (coord) {
+    return axisExtentSum - coord + coordBase;
+  };
+}
+function updateAllAxisExtentTransByGridRect(axesMap, gridRect) {
+  each(axesMap.x, function (axis) {
+    return updateAxisExtentTransByGridRect(axis, gridRect.x, gridRect.width);
+  });
+  each(axesMap.y, function (axis) {
+    return updateAxisExtentTransByGridRect(axis, gridRect.y, gridRect.height);
+  });
+}
+function updateAxisExtentTransByGridRect(axis, gridXY, gridWH) {
+  var extent = [0, gridWH];
+  var idx = axis.inverse ? 1 : 0;
+  axis.setExtent(extent[idx], extent[1 - idx]);
+  updateAxisTransform(axis, gridXY);
+}
+var legacyLayOutGridByContainLabel;
+function registerLegacyGridContainLabelImpl(impl) {
+  legacyLayOutGridByContainLabel = impl;
+}
+// Return noPxChange.
+function layOutGridByOuterBounds(outerBoundsRect, outerBoundsContain, outerBoundsClamp, gridRect, axesMap, axisBuilderSharedCtx, layoutRef) {
+  if (process.env.NODE_ENV !== 'production') {
+    assert(outerBoundsContain === 'all' || outerBoundsContain === 'axisLabel');
+  }
+  // Assume `updateAllAxisExtentTransByGridRect` has been performed once before this call.
+  // [NOTE]:
+  // - The bounding rect of the axis elements might be sensitve to variations in `axis.extent` due to strategies
+  //  like hideOverlap/moveOverlap. @see the comment in `LabelLayoutBase['suggestIgnore']`.
+  // - The final `gridRect` might be slightly smaller than the ideally expected result if labels are giant and
+  //  get hidden due to overlapping. More iterations could improve precision, but not performant. We consider
+  //  the current result acceptable, since no alignment among charts can be guaranteed when using this feature.
+  createOrUpdateAxesView(gridRect, axesMap, AxisTickLabelComputingKind.estimate, outerBoundsContain, false, layoutRef);
+  var margin = [0, 0, 0, 0];
+  fillLabelNameOverflowOnOneDimension(0);
+  fillLabelNameOverflowOnOneDimension(1);
+  // If axis is blank, no label can be used to detect overflow.
+  // gridRect itself should not overflow.
+  fillMarginOnOneDimension(gridRect, 0, NaN);
+  fillMarginOnOneDimension(gridRect, 1, NaN);
+  var noPxChange = find(margin, function (item) {
+    return item > 0;
+  }) == null;
+  expandOrShrinkRect(gridRect, margin, true, true, outerBoundsClamp);
+  updateAllAxisExtentTransByGridRect(axesMap, gridRect);
+  return noPxChange;
+  function fillLabelNameOverflowOnOneDimension(xyIdx) {
+    each(axesMap[XY[xyIdx]], function (axis) {
+      if (!shouldAxisShow(axis.model)) {
+        return;
+      }
+      // FIXME: zr Group.union may wrongly union (0, 0, 0, 0) and not performant.
+      // unionRect.union(axis.axisBuilder.group.getBoundingRect());
+      // If ussing Group.getBoundingRect to calculate shrink space, it is not strictly accurate when
+      // the outermost label is ignored and the secondary label is very long and contribute to the
+      // union extension:
+      //      -|---|---|---|
+      //         1,000,000,000
+      // Therefore we calculate them one by one.
+      // Also considered axis may be blank or no labels.
+      var sharedRecord = axisBuilderSharedCtx.ensureRecord(axis.model);
+      var labelInfoList = sharedRecord.labelInfoList;
+      if (labelInfoList) {
+        for (var idx = 0; idx < labelInfoList.length; idx++) {
+          var labelInfo = labelInfoList[idx];
+          var proportion = axis.scale.normalize(getLabelInner(labelInfo.label).tickValue);
+          proportion = xyIdx === 1 ? 1 - proportion : proportion;
+          // xAxis use proportion on x, yAxis use proprotion on y, otherwise not.
+          fillMarginOnOneDimension(labelInfo.rect, xyIdx, proportion);
+          fillMarginOnOneDimension(labelInfo.rect, 1 - xyIdx, NaN);
+        }
+      }
+      var nameLayout = sharedRecord.nameLayout;
+      if (nameLayout) {
+        var proportion = isNameLocationCenter(sharedRecord.nameLocation) ? 0.5 : NaN;
+        fillMarginOnOneDimension(nameLayout.rect, xyIdx, proportion);
+        fillMarginOnOneDimension(nameLayout.rect, 1 - xyIdx, NaN);
+      }
+    });
+  }
+  function fillMarginOnOneDimension(itemRect, xyIdx, proportion // NaN mean no use proportion
+  ) {
+    var overflow1 = outerBoundsRect[XY[xyIdx]] - itemRect[XY[xyIdx]];
+    var overflow2 = itemRect[WH[xyIdx]] + itemRect[XY[xyIdx]] - (outerBoundsRect[WH[xyIdx]] + outerBoundsRect[XY[xyIdx]]);
+    overflow1 = applyProportion(overflow1, 1 - proportion);
+    overflow2 = applyProportion(overflow2, proportion);
+    var minIdx = XY_TO_MARGIN_IDX[xyIdx][0];
+    var maxIdx = XY_TO_MARGIN_IDX[xyIdx][1];
+    margin[minIdx] = mathMax(margin[minIdx], overflow1);
+    margin[maxIdx] = mathMax(margin[maxIdx], overflow2);
+  }
+  function applyProportion(overflow, proportion) {
+    // proportion is not likely to near zero. If so, give up shrink
+    if (overflow > 0 && !eqNaN(proportion) && proportion > 1e-4) {
+      overflow /= proportion;
+    }
+    return overflow;
+  }
+}
+function createAxisBiulders(gridRect, cartesians, axesMap, optionContainLabel, api) {
+  var axisBuilderSharedCtx = new AxisBuilderSharedContext(resolveAxisNameOverlapForGrid);
+  each(axesMap, function (axisList) {
+    return each(axisList, function (axis) {
+      if (shouldAxisShow(axis.model)) {
+        // See `AxisBaseOptionCommon['nameMoveOverlap']`.
+        var defaultNameMoveOverlap = !optionContainLabel;
+        axis.axisBuilder = createCartesianAxisViewCommonPartBuilder(gridRect, cartesians, axis.model, api, axisBuilderSharedCtx, defaultNameMoveOverlap);
+      }
+    });
+  });
+  return axisBuilderSharedCtx;
+}
+/**
+ * Promote the axis-elements-building from "view render" stage to "coordinate system resize" stage.
+ * This is aimed to resovle overlap across multiple axes, since currently it's hard to reconcile
+ * multiple axes in "view render" stage.
+ *
+ * [CAUTION] But this promotion assumes that the subsequent "visual mapping" stage does not affect
+ * this axis-elements-building; otherwise we have to refactor it again.
+ */
+function createOrUpdateAxesView(gridRect, axesMap, kind, outerBoundsContain, noPxChange, layoutRef) {
+  var isDetermine = kind === AxisTickLabelComputingKind.determine;
+  each(axesMap, function (axisList) {
+    return each(axisList, function (axis) {
+      if (shouldAxisShow(axis.model)) {
+        updateCartesianAxisViewCommonPartBuilder(axis.axisBuilder, gridRect, axis.model);
+        axis.axisBuilder.build(isDetermine ? {
+          axisTickLabelDetermine: true
+        } : {
+          axisTickLabelEstimate: true
+        }, {
+          noPxChange: noPxChange
+        });
+      }
+    });
+  });
+  var nameMarginLevelMap = {
+    x: 0,
+    y: 0
+  };
+  calcNameMarginLevel(0);
+  calcNameMarginLevel(1);
+  function calcNameMarginLevel(xyIdx) {
+    nameMarginLevelMap[XY[1 - xyIdx]] = gridRect[WH[xyIdx]] <= layoutRef.refContainer[WH[xyIdx]] * 0.5 ? 0 : 1 - xyIdx === 1 ? 2 : 1;
+  }
+  each(axesMap, function (axisList, xy) {
+    return each(axisList, function (axis) {
+      if (shouldAxisShow(axis.model)) {
+        if (outerBoundsContain === 'all' || isDetermine) {
+          // To resolve overlap, `axisName` layout depends on `axisTickLabel` layout result
+          // (all of the axes of the same `grid`; consider multiple x or y axes).
+          axis.axisBuilder.build({
+            axisName: true
+          }, {
+            nameMarginLevel: nameMarginLevelMap[xy]
+          });
+        }
+        if (isDetermine) {
+          axis.axisBuilder.build({
+            axisLine: true
+          });
+        }
+      }
+    });
+  });
+}
+function prepareOuterBounds(gridModel, rawRridRect, layoutRef) {
+  var outerBoundsRect;
+  var optionOuterBoundsMode = gridModel.get('outerBoundsMode', true);
+  if (optionOuterBoundsMode === 'same') {
+    outerBoundsRect = rawRridRect.clone();
+  } else if (optionOuterBoundsMode == null || optionOuterBoundsMode === 'auto') {
+    outerBoundsRect = getLayoutRect(gridModel.get('outerBounds', true) || OUTER_BOUNDS_DEFAULT, layoutRef.refContainer);
+  } else if (optionOuterBoundsMode !== 'none') {
+    if (process.env.NODE_ENV !== 'production') {
+      error("Invalid grid[" + gridModel.componentIndex + "].outerBoundsMode.");
+    }
+  }
+  var optionOuterBoundsContain = gridModel.get('outerBoundsContain', true);
+  var parsedOuterBoundsContain;
+  if (optionOuterBoundsContain == null || optionOuterBoundsContain === 'auto') {
+    parsedOuterBoundsContain = 'all';
+  } else if (indexOf(['all', 'axisLabel'], optionOuterBoundsContain) < 0) {
+    if (process.env.NODE_ENV !== 'production') {
+      error("Invalid grid[" + gridModel.componentIndex + "].outerBoundsContain.");
+    }
+    parsedOuterBoundsContain = 'all';
+  } else {
+    parsedOuterBoundsContain = optionOuterBoundsContain;
+  }
+  var outerBoundsClamp = [parsePositionSizeOption(retrieve2(gridModel.get('outerBoundsClampWidth', true), OUTER_BOUNDS_CLAMP_DEFAULT[0]), rawRridRect.width), parsePositionSizeOption(retrieve2(gridModel.get('outerBoundsClampHeight', true), OUTER_BOUNDS_CLAMP_DEFAULT[1]), rawRridRect.height)];
+  return {
+    outerBoundsRect: outerBoundsRect,
+    parsedOuterBoundsContain: parsedOuterBoundsContain,
+    outerBoundsClamp: outerBoundsClamp
+  };
+}
+var resolveAxisNameOverlapForGrid = function (cfg, ctx, axisModel, nameLayoutInfo, nameMoveDirVec, thisRecord) {
+  var perpendicularDim = axisModel.axis.dim === 'x' ? 'y' : 'x';
+  resolveAxisNameOverlapDefault(cfg, ctx, axisModel, nameLayoutInfo, nameMoveDirVec, thisRecord);
+  // If nameLocation 'center', and there are multiple axes parallel to this axis, do not adjust by
+  //  other axes, because the axis name should be close to its axis line as much as possible even
+  //  if overlapping; otherwise it might cause misleading.
+  // If nameLocation 'center', do not adjust by perpendicular axes, since they are not likely to overlap.
+  // If nameLocation 'start'/'end', move name within the same direction to escape overlap with the
+  //  perpendicular axes.
+  if (!isNameLocationCenter(cfg.nameLocation)) {
+    each(ctx.recordMap[perpendicularDim], function (perpenRecord) {
+      // perpendicular axis may be no name.
+      if (perpenRecord && perpenRecord.labelInfoList && perpenRecord.dirVec) {
+        moveIfOverlapByLinearLabels(perpenRecord.labelInfoList, perpenRecord.dirVec, nameLayoutInfo, nameMoveDirVec);
+      }
+    });
+  }
+};
+
+export { Grid as default, registerLegacyGridContainLabelImpl };