sun-card-design 1.1.16 → 1.1.18

package/dist/pc/sun-card-design-pc.es1872.js

@@ -1,181 +1,165 @@
-import { extend, each, map, mergeAll, retrieve, createHashMap, merge } from "./sun-card-design-pc.es922.js";
-import Geo, { geo2DDimensions } from "./sun-card-design-pc.es2091.js";
-import { getLayoutRect } from "./sun-card-design-pc.es1758.js";
-import { parsePercent } from "./sun-card-design-pc.es1962.js";
-import geoSourceManager from "./sun-card-design-pc.es1874.js";
-import { min, max } from "./sun-card-design-pc.es1965.js";
-function resizeGeo(geoModel, api) {
-  var boundingCoords = geoModel.get("boundingCoords");
-  if (boundingCoords != null) {
-    var leftTop_1 = boundingCoords[0];
-    var rightBottom_1 = boundingCoords[1];
-    if (!(isFinite(leftTop_1[0]) && isFinite(leftTop_1[1]) && isFinite(rightBottom_1[0]) && isFinite(rightBottom_1[1]))) {
-      if (process.env.NODE_ENV !== "production") {
-        console.error("Invalid boundingCoords");
+import { __extends } from "./sun-card-design-pc.es1717.js";
+import { each, defaults } from "./sun-card-design-pc.es922.js";
+import * as graphic from "./sun-card-design-pc.es1757.js";
+import { groupTransition, mergePath } from "./sun-card-design-pc.es1757.js";
+import AxisBuilder from "./sun-card-design-pc.es2100.js";
+import AxisView from "./sun-card-design-pc.es1866.js";
+import Group from "./sun-card-design-pc.es1753.js";
+import Sector from "./sun-card-design-pc.es1995.js";
+import Circle from "./sun-card-design-pc.es1993.js";
+var axisBuilderAttrs = ["axisLine", "axisTickLabel", "axisName"];
+var selfBuilderAttrs = ["splitLine", "splitArea", "minorSplitLine"];
+var RadiusAxisView = (
+  /** @class */
+  (function(_super) {
+    __extends(RadiusAxisView2, _super);
+    function RadiusAxisView2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = RadiusAxisView2.type;
+      _this.axisPointerClass = "PolarAxisPointer";
+      return _this;
+    }
+    RadiusAxisView2.prototype.render = function(radiusAxisModel, ecModel) {
+      this.group.removeAll();
+      if (!radiusAxisModel.get("show")) {
+        return;
       }
-    } else {
-      var projection_1 = this.projection;
-      if (projection_1) {
-        var xMin = leftTop_1[0];
-        var yMin = leftTop_1[1];
-        var xMax = rightBottom_1[0];
-        var yMax = rightBottom_1[1];
-        leftTop_1 = [Infinity, Infinity];
-        rightBottom_1 = [-Infinity, -Infinity];
-        var sampleLine = function(x0, y0, x1, y1) {
-          var dx = x1 - x0;
-          var dy = y1 - y0;
-          for (var i = 0; i <= 100; i++) {
-            var p = i / 100;
-            var pt = projection_1.project([x0 + dx * p, y0 + dy * p]);
-            min(leftTop_1, leftTop_1, pt);
-            max(rightBottom_1, rightBottom_1, pt);
+      var oldAxisGroup = this._axisGroup;
+      var newAxisGroup = this._axisGroup = new Group();
+      this.group.add(newAxisGroup);
+      var radiusAxis = radiusAxisModel.axis;
+      var polar = radiusAxis.polar;
+      var angleAxis = polar.getAngleAxis();
+      var ticksCoords = radiusAxis.getTicksCoords();
+      var minorTicksCoords = radiusAxis.getMinorTicksCoords();
+      var axisAngle = angleAxis.getExtent()[0];
+      var radiusExtent = radiusAxis.getExtent();
+      var layout = layoutAxis(polar, radiusAxisModel, axisAngle);
+      var axisBuilder = new AxisBuilder(radiusAxisModel, layout);
+      each(axisBuilderAttrs, axisBuilder.add, axisBuilder);
+      newAxisGroup.add(axisBuilder.getGroup());
+      groupTransition(oldAxisGroup, newAxisGroup, radiusAxisModel);
+      each(selfBuilderAttrs, function(name) {
+        if (radiusAxisModel.get([name, "show"]) && !radiusAxis.scale.isBlank()) {
+          axisElementBuilders[name](this.group, radiusAxisModel, polar, axisAngle, radiusExtent, ticksCoords, minorTicksCoords);
+        }
+      }, this);
+    };
+    RadiusAxisView2.type = "radiusAxis";
+    return RadiusAxisView2;
+  })(AxisView)
+);
+var axisElementBuilders = {
+  splitLine: function(group, radiusAxisModel, polar, axisAngle, radiusExtent, ticksCoords) {
+    var splitLineModel = radiusAxisModel.getModel("splitLine");
+    var lineStyleModel = splitLineModel.getModel("lineStyle");
+    var lineColors = lineStyleModel.get("color");
+    var lineCount = 0;
+    var angleAxis = polar.getAngleAxis();
+    var RADIAN = Math.PI / 180;
+    var angleExtent = angleAxis.getExtent();
+    var shapeType = Math.abs(angleExtent[1] - angleExtent[0]) === 360 ? "Circle" : "Arc";
+    lineColors = lineColors instanceof Array ? lineColors : [lineColors];
+    var splitLines = [];
+    for (var i = 0; i < ticksCoords.length; i++) {
+      var colorIndex = lineCount++ % lineColors.length;
+      splitLines[colorIndex] = splitLines[colorIndex] || [];
+      splitLines[colorIndex].push(new graphic[shapeType]({
+        shape: {
+          cx: polar.cx,
+          cy: polar.cy,
+          // ensure circle radius >= 0
+          r: Math.max(ticksCoords[i].coord, 0),
+          startAngle: -angleExtent[0] * RADIAN,
+          endAngle: -angleExtent[1] * RADIAN,
+          clockwise: angleAxis.inverse
+        }
+      }));
+    }
+    for (var i = 0; i < splitLines.length; i++) {
+      group.add(mergePath(splitLines[i], {
+        style: defaults({
+          stroke: lineColors[i % lineColors.length],
+          fill: null
+        }, lineStyleModel.getLineStyle()),
+        silent: true
+      }));
+    }
+  },
+  minorSplitLine: function(group, radiusAxisModel, polar, axisAngle, radiusExtent, ticksCoords, minorTicksCoords) {
+    if (!minorTicksCoords.length) {
+      return;
+    }
+    var minorSplitLineModel = radiusAxisModel.getModel("minorSplitLine");
+    var lineStyleModel = minorSplitLineModel.getModel("lineStyle");
+    var lines = [];
+    for (var i = 0; i < minorTicksCoords.length; i++) {
+      for (var k = 0; k < minorTicksCoords[i].length; k++) {
+        lines.push(new Circle({
+          shape: {
+            cx: polar.cx,
+            cy: polar.cy,
+            r: minorTicksCoords[i][k].coord
           }
-        };
-        sampleLine(xMin, yMin, xMax, yMin);
-        sampleLine(xMax, yMin, xMax, yMax);
-        sampleLine(xMax, yMax, xMin, yMax);
-        sampleLine(xMin, yMax, xMax, yMin);
+        }));
       }
-      this.setBoundingRect(leftTop_1[0], leftTop_1[1], rightBottom_1[0] - leftTop_1[0], rightBottom_1[1] - leftTop_1[1]);
     }
-  }
-  var rect = this.getBoundingRect();
-  var centerOption = geoModel.get("layoutCenter");
-  var sizeOption = geoModel.get("layoutSize");
-  var viewWidth = api.getWidth();
-  var viewHeight = api.getHeight();
-  var aspect = rect.width / rect.height * this.aspectScale;
-  var useCenterAndSize = false;
-  var center;
-  var size;
-  if (centerOption && sizeOption) {
-    center = [parsePercent(centerOption[0], viewWidth), parsePercent(centerOption[1], viewHeight)];
-    size = parsePercent(sizeOption, Math.min(viewWidth, viewHeight));
-    if (!isNaN(center[0]) && !isNaN(center[1]) && !isNaN(size)) {
-      useCenterAndSize = true;
-    } else {
-      if (process.env.NODE_ENV !== "production") {
-        console.warn("Given layoutCenter or layoutSize data are invalid. Use left/top/width/height instead.");
-      }
+    group.add(mergePath(lines, {
+      style: defaults({
+        fill: null
+      }, lineStyleModel.getLineStyle()),
+      silent: true
+    }));
+  },
+  splitArea: function(group, radiusAxisModel, polar, axisAngle, radiusExtent, ticksCoords) {
+    if (!ticksCoords.length) {
+      return;
     }
-  }
-  var viewRect;
-  if (useCenterAndSize) {
-    viewRect = {};
-    if (aspect > 1) {
-      viewRect.width = size;
-      viewRect.height = size / aspect;
-    } else {
-      viewRect.height = size;
-      viewRect.width = size * aspect;
+    var splitAreaModel = radiusAxisModel.getModel("splitArea");
+    var areaStyleModel = splitAreaModel.getModel("areaStyle");
+    var areaColors = areaStyleModel.get("color");
+    var lineCount = 0;
+    areaColors = areaColors instanceof Array ? areaColors : [areaColors];
+    var splitAreas = [];
+    var prevRadius = ticksCoords[0].coord;
+    for (var i = 1; i < ticksCoords.length; i++) {
+      var colorIndex = lineCount++ % areaColors.length;
+      splitAreas[colorIndex] = splitAreas[colorIndex] || [];
+      splitAreas[colorIndex].push(new Sector({
+        shape: {
+          cx: polar.cx,
+          cy: polar.cy,
+          r0: prevRadius,
+          r: ticksCoords[i].coord,
+          startAngle: 0,
+          endAngle: Math.PI * 2
+        },
+        silent: true
+      }));
+      prevRadius = ticksCoords[i].coord;
+    }
+    for (var i = 0; i < splitAreas.length; i++) {
+      group.add(mergePath(splitAreas[i], {
+        style: defaults({
+          fill: areaColors[i % areaColors.length]
+        }, areaStyleModel.getAreaStyle()),
+        silent: true
+      }));
     }
-    viewRect.y = center[1] - viewRect.height / 2;
-    viewRect.x = center[0] - viewRect.width / 2;
-  } else {
-    var boxLayoutOption = geoModel.getBoxLayoutParams();
-    boxLayoutOption.aspect = aspect;
-    viewRect = getLayoutRect(boxLayoutOption, {
-      width: viewWidth,
-      height: viewHeight
-    });
   }
-  this.setViewRect(viewRect.x, viewRect.y, viewRect.width, viewRect.height);
-  this.setCenter(geoModel.get("center"), api);
-  this.setZoom(geoModel.get("zoom"));
-}
-function setGeoCoords(geo, model) {
-  each(model.get("geoCoord"), function(geoCoord, name) {
-    geo.addGeoCoord(name, geoCoord);
-  });
+};
+function layoutAxis(polar, radiusAxisModel, axisAngle) {
+  return {
+    position: [polar.cx, polar.cy],
+    rotation: axisAngle / 180 * Math.PI,
+    labelDirection: -1,
+    tickDirection: -1,
+    nameDirection: 1,
+    labelRotate: radiusAxisModel.getModel("axisLabel").get("rotate"),
+    // Over splitLine and splitArea
+    z2: 1
+  };
 }
-var GeoCreator = (
-  /** @class */
-  (function() {
-    function GeoCreator2() {
-      this.dimensions = geo2DDimensions;
-    }
-    GeoCreator2.prototype.create = function(ecModel, api) {
-      var geoList = [];
-      function getCommonGeoProperties(model) {
-        return {
-          nameProperty: model.get("nameProperty"),
-          aspectScale: model.get("aspectScale"),
-          projection: model.get("projection")
-        };
-      }
-      ecModel.eachComponent("geo", function(geoModel, idx) {
-        var mapName = geoModel.get("map");
-        var geo = new Geo(mapName + idx, mapName, extend({
-          nameMap: geoModel.get("nameMap")
-        }, getCommonGeoProperties(geoModel)));
-        geo.zoomLimit = geoModel.get("scaleLimit");
-        geoList.push(geo);
-        geoModel.coordinateSystem = geo;
-        geo.model = geoModel;
-        geo.resize = resizeGeo;
-        geo.resize(geoModel, api);
-      });
-      ecModel.eachSeries(function(seriesModel) {
-        var coordSys = seriesModel.get("coordinateSystem");
-        if (coordSys === "geo") {
-          var geoIndex = seriesModel.get("geoIndex") || 0;
-          seriesModel.coordinateSystem = geoList[geoIndex];
-        }
-      });
-      var mapModelGroupBySeries = {};
-      ecModel.eachSeriesByType("map", function(seriesModel) {
-        if (!seriesModel.getHostGeoModel()) {
-          var mapType = seriesModel.getMapType();
-          mapModelGroupBySeries[mapType] = mapModelGroupBySeries[mapType] || [];
-          mapModelGroupBySeries[mapType].push(seriesModel);
-        }
-      });
-      each(mapModelGroupBySeries, function(mapSeries, mapType) {
-        var nameMapList = map(mapSeries, function(singleMapSeries) {
-          return singleMapSeries.get("nameMap");
-        });
-        var geo = new Geo(mapType, mapType, extend({
-          nameMap: mergeAll(nameMapList)
-        }, getCommonGeoProperties(mapSeries[0])));
-        geo.zoomLimit = retrieve.apply(null, map(mapSeries, function(singleMapSeries) {
-          return singleMapSeries.get("scaleLimit");
-        }));
-        geoList.push(geo);
-        geo.resize = resizeGeo;
-        geo.resize(mapSeries[0], api);
-        each(mapSeries, function(singleMapSeries) {
-          singleMapSeries.coordinateSystem = geo;
-          setGeoCoords(geo, singleMapSeries);
-        });
-      });
-      return geoList;
-    };
-    GeoCreator2.prototype.getFilledRegions = function(originRegionArr, mapName, nameMap, nameProperty) {
-      var regionsArr = (originRegionArr || []).slice();
-      var dataNameMap = createHashMap();
-      for (var i = 0; i < regionsArr.length; i++) {
-        dataNameMap.set(regionsArr[i].name, regionsArr[i]);
-      }
-      var source = geoSourceManager.load(mapName, nameMap, nameProperty);
-      each(source.regions, function(region) {
-        var name = region.name;
-        var regionOption = dataNameMap.get(name);
-        var specifiedGeoJSONRegionStyle = region.properties && region.properties.echartsStyle;
-        if (!regionOption) {
-          regionOption = {
-            name
-          };
-          regionsArr.push(regionOption);
-        }
-        specifiedGeoJSONRegionStyle && merge(regionOption, specifiedGeoJSONRegionStyle);
-      });
-      return regionsArr;
-    };
-    return GeoCreator2;
-  })()
-);
-var geoCreator = new GeoCreator();
 export {
-  geoCreator as default
+  RadiusAxisView as default
 };

package/dist/pc/sun-card-design-pc.es1873.js

@@ -1,71 +1,196 @@
-import { __extends } from "./sun-card-design-pc.es1717.js";
-import MapDraw from "./sun-card-design-pc.es2032.js";
-import ComponentView from "./sun-card-design-pc.es918.js";
-import { getECData } from "./sun-card-design-pc.es1727.js";
-import { findEventDispatcher } from "./sun-card-design-pc.es1744.js";
-var GeoView = (
-  /** @class */
-  (function(_super) {
-    __extends(GeoView2, _super);
-    function GeoView2() {
-      var _this = _super !== null && _super.apply(this, arguments) || this;
-      _this.type = GeoView2.type;
-      _this.focusBlurEnabled = true;
-      return _this;
+import { filter, each } from "./sun-card-design-pc.es922.js";
+import { parsePercent } from "./sun-card-design-pc.es1976.js";
+import { isDimensionStacked } from "./sun-card-design-pc.es2030.js";
+function getSeriesStackId(seriesModel) {
+  return seriesModel.get("stack") || "__ec_stack_" + seriesModel.seriesIndex;
+}
+function getAxisKey(polar, axis) {
+  return axis.dim + polar.model.componentIndex;
+}
+function barLayoutPolar(seriesType, ecModel, api) {
+  var lastStackCoords = {};
+  var barWidthAndOffset = calRadialBar(filter(ecModel.getSeriesByType(seriesType), function(seriesModel) {
+    return !ecModel.isSeriesFiltered(seriesModel) && seriesModel.coordinateSystem && seriesModel.coordinateSystem.type === "polar";
+  }));
+  ecModel.eachSeriesByType(seriesType, function(seriesModel) {
+    if (seriesModel.coordinateSystem.type !== "polar") {
+      return;
     }
-    GeoView2.prototype.init = function(ecModel, api) {
-      this._api = api;
-    };
-    GeoView2.prototype.render = function(geoModel, ecModel, api, payload) {
-      this._model = geoModel;
-      if (!geoModel.get("show")) {
-        this._mapDraw && this._mapDraw.remove();
-        this._mapDraw = null;
-        return;
-      }
-      if (!this._mapDraw) {
-        this._mapDraw = new MapDraw(api);
-      }
-      var mapDraw = this._mapDraw;
-      mapDraw.draw(geoModel, ecModel, api, this, payload);
-      mapDraw.group.on("click", this._handleRegionClick, this);
-      mapDraw.group.silent = geoModel.get("silent");
-      this.group.add(mapDraw.group);
-      this.updateSelectStatus(geoModel, ecModel, api);
-    };
-    GeoView2.prototype._handleRegionClick = function(e) {
-      var eventData;
-      findEventDispatcher(e.target, function(current) {
-        return (eventData = getECData(current).eventData) != null;
-      }, true);
-      if (eventData) {
-        this._api.dispatchAction({
-          type: "geoToggleSelect",
-          geoId: this._model.id,
-          name: eventData.name
-        });
+    var data = seriesModel.getData();
+    var polar = seriesModel.coordinateSystem;
+    var baseAxis = polar.getBaseAxis();
+    var axisKey = getAxisKey(polar, baseAxis);
+    var stackId = getSeriesStackId(seriesModel);
+    var columnLayoutInfo = barWidthAndOffset[axisKey][stackId];
+    var columnOffset = columnLayoutInfo.offset;
+    var columnWidth = columnLayoutInfo.width;
+    var valueAxis = polar.getOtherAxis(baseAxis);
+    var cx = seriesModel.coordinateSystem.cx;
+    var cy = seriesModel.coordinateSystem.cy;
+    var barMinHeight = seriesModel.get("barMinHeight") || 0;
+    var barMinAngle = seriesModel.get("barMinAngle") || 0;
+    lastStackCoords[stackId] = lastStackCoords[stackId] || [];
+    var valueDim = data.mapDimension(valueAxis.dim);
+    var baseDim = data.mapDimension(baseAxis.dim);
+    var stacked = isDimensionStacked(
+      data,
+      valueDim
+      /* , baseDim */
+    );
+    var clampLayout = baseAxis.dim !== "radius" || !seriesModel.get("roundCap", true);
+    var valueAxisModel = valueAxis.model;
+    var startValue = valueAxisModel.get("startValue");
+    var valueAxisStart = valueAxis.dataToCoord(startValue || 0);
+    for (var idx = 0, len = data.count(); idx < len; idx++) {
+      var value = data.get(valueDim, idx);
+      var baseValue = data.get(baseDim, idx);
+      var sign = value >= 0 ? "p" : "n";
+      var baseCoord = valueAxisStart;
+      if (stacked) {
+        if (!lastStackCoords[stackId][baseValue]) {
+          lastStackCoords[stackId][baseValue] = {
+            p: valueAxisStart,
+            n: valueAxisStart
+            // Negative stack
+          };
+        }
+        baseCoord = lastStackCoords[stackId][baseValue][sign];
       }
-    };
-    GeoView2.prototype.updateSelectStatus = function(model, ecModel, api) {
-      var _this = this;
-      this._mapDraw.group.traverse(function(node) {
-        var eventData = getECData(node).eventData;
-        if (eventData) {
-          _this._model.isSelected(eventData.name) ? api.enterSelect(node) : api.leaveSelect(node);
-          return true;
+      var r0 = void 0;
+      var r = void 0;
+      var startAngle = void 0;
+      var endAngle = void 0;
+      if (valueAxis.dim === "radius") {
+        var radiusSpan = valueAxis.dataToCoord(value) - valueAxisStart;
+        var angle = baseAxis.dataToCoord(baseValue);
+        if (Math.abs(radiusSpan) < barMinHeight) {
+          radiusSpan = (radiusSpan < 0 ? -1 : 1) * barMinHeight;
         }
+        r0 = baseCoord;
+        r = baseCoord + radiusSpan;
+        startAngle = angle - columnOffset;
+        endAngle = startAngle - columnWidth;
+        stacked && (lastStackCoords[stackId][baseValue][sign] = r);
+      } else {
+        var angleSpan = valueAxis.dataToCoord(value, clampLayout) - valueAxisStart;
+        var radius = baseAxis.dataToCoord(baseValue);
+        if (Math.abs(angleSpan) < barMinAngle) {
+          angleSpan = (angleSpan < 0 ? -1 : 1) * barMinAngle;
+        }
+        r0 = radius + columnOffset;
+        r = r0 + columnWidth;
+        startAngle = baseCoord;
+        endAngle = baseCoord + angleSpan;
+        stacked && (lastStackCoords[stackId][baseValue][sign] = endAngle);
+      }
+      data.setItemLayout(idx, {
+        cx,
+        cy,
+        r0,
+        r,
+        // Consider that positive angle is anti-clockwise,
+        // while positive radian of sector is clockwise
+        startAngle: -startAngle * Math.PI / 180,
+        endAngle: -endAngle * Math.PI / 180,
+        /**
+         * Keep the same logic with bar in catesion: use end value to
+         * control direction. Notice that if clockwise is true (by
+         * default), the sector will always draw clockwisely, no matter
+         * whether endAngle is greater or less than startAngle.
+         */
+        clockwise: startAngle >= endAngle
       });
+    }
+  });
+}
+function calRadialBar(barSeries) {
+  var columnsMap = {};
+  each(barSeries, function(seriesModel, idx) {
+    var data = seriesModel.getData();
+    var polar = seriesModel.coordinateSystem;
+    var baseAxis = polar.getBaseAxis();
+    var axisKey = getAxisKey(polar, baseAxis);
+    var axisExtent = baseAxis.getExtent();
+    var bandWidth = baseAxis.type === "category" ? baseAxis.getBandWidth() : Math.abs(axisExtent[1] - axisExtent[0]) / data.count();
+    var columnsOnAxis = columnsMap[axisKey] || {
+      bandWidth,
+      remainedWidth: bandWidth,
+      autoWidthCount: 0,
+      categoryGap: "20%",
+      gap: "30%",
+      stacks: {}
     };
-    GeoView2.prototype.findHighDownDispatchers = function(name) {
-      return this._mapDraw && this._mapDraw.findHighDownDispatchers(name, this._model);
-    };
-    GeoView2.prototype.dispose = function() {
-      this._mapDraw && this._mapDraw.remove();
+    var stacks = columnsOnAxis.stacks;
+    columnsMap[axisKey] = columnsOnAxis;
+    var stackId = getSeriesStackId(seriesModel);
+    if (!stacks[stackId]) {
+      columnsOnAxis.autoWidthCount++;
+    }
+    stacks[stackId] = stacks[stackId] || {
+      width: 0,
+      maxWidth: 0
     };
-    GeoView2.type = "geo";
-    return GeoView2;
-  })(ComponentView)
-);
+    var barWidth = parsePercent(seriesModel.get("barWidth"), bandWidth);
+    var barMaxWidth = parsePercent(seriesModel.get("barMaxWidth"), bandWidth);
+    var barGap = seriesModel.get("barGap");
+    var barCategoryGap = seriesModel.get("barCategoryGap");
+    if (barWidth && !stacks[stackId].width) {
+      barWidth = Math.min(columnsOnAxis.remainedWidth, barWidth);
+      stacks[stackId].width = barWidth;
+      columnsOnAxis.remainedWidth -= barWidth;
+    }
+    barMaxWidth && (stacks[stackId].maxWidth = barMaxWidth);
+    barGap != null && (columnsOnAxis.gap = barGap);
+    barCategoryGap != null && (columnsOnAxis.categoryGap = barCategoryGap);
+  });
+  var result = {};
+  each(columnsMap, function(columnsOnAxis, coordSysName) {
+    result[coordSysName] = {};
+    var stacks = columnsOnAxis.stacks;
+    var bandWidth = columnsOnAxis.bandWidth;
+    var categoryGap = parsePercent(columnsOnAxis.categoryGap, bandWidth);
+    var barGapPercent = parsePercent(columnsOnAxis.gap, 1);
+    var remainedWidth = columnsOnAxis.remainedWidth;
+    var autoWidthCount = columnsOnAxis.autoWidthCount;
+    var autoWidth = (remainedWidth - categoryGap) / (autoWidthCount + (autoWidthCount - 1) * barGapPercent);
+    autoWidth = Math.max(autoWidth, 0);
+    each(stacks, function(column, stack) {
+      var maxWidth = column.maxWidth;
+      if (maxWidth && maxWidth < autoWidth) {
+        maxWidth = Math.min(maxWidth, remainedWidth);
+        if (column.width) {
+          maxWidth = Math.min(maxWidth, column.width);
+        }
+        remainedWidth -= maxWidth;
+        column.width = maxWidth;
+        autoWidthCount--;
+      }
+    });
+    autoWidth = (remainedWidth - categoryGap) / (autoWidthCount + (autoWidthCount - 1) * barGapPercent);
+    autoWidth = Math.max(autoWidth, 0);
+    var widthSum = 0;
+    var lastColumn;
+    each(stacks, function(column, idx) {
+      if (!column.width) {
+        column.width = autoWidth;
+      }
+      lastColumn = column;
+      widthSum += column.width * (1 + barGapPercent);
+    });
+    if (lastColumn) {
+      widthSum -= lastColumn.width * barGapPercent;
+    }
+    var offset = -widthSum / 2;
+    each(stacks, function(column, stackId) {
+      result[coordSysName][stackId] = result[coordSysName][stackId] || {
+        offset,
+        width: column.width
+      };
+      offset += column.width * (1 + barGapPercent);
+    });
+  });
+  return result;
+}
 export {
-  GeoView as default
+  barLayoutPolar as default
 };