sun-card-design 1.1.34 → 1.1.35

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

@@ -1,314 +1,393 @@
-import { __extends } from "./sun-card-design-pc.es1967.js";
-import Element from "./sun-card-design-pc.es1968.js";
-import BoundingRect from "./sun-card-design-pc.es1969.js";
-import { keys, extend, createObject } from "./sun-card-design-pc.es930.js";
-import { STYLE_CHANGED_BIT, REDRAW_BIT } from "./sun-card-design-pc.es2003.js";
-var STYLE_MAGIC_KEY = "__zr_style_" + Math.round(Math.random() * 10);
-var DEFAULT_COMMON_STYLE = {
-  shadowBlur: 0,
-  shadowOffsetX: 0,
-  shadowOffsetY: 0,
-  shadowColor: "#000",
-  opacity: 1,
-  blend: "source-over"
-};
-var DEFAULT_COMMON_ANIMATION_PROPS = {
-  style: {
-    shadowBlur: true,
-    shadowOffsetX: true,
-    shadowOffsetY: true,
-    shadowColor: true,
-    opacity: true
+import { each, keys, defaults } from "./sun-card-design-pc.es931.js";
+import { parsePercent } from "./sun-card-design-pc.es1971.js";
+import { isDimensionStacked } from "./sun-card-design-pc.es2025.js";
+import createRenderPlanner from "./sun-card-design-pc.es1764.js";
+import { createFloat32Array } from "./sun-card-design-pc.es2024.js";
+var STACK_PREFIX = "__ec_stack_";
+function getSeriesStackId(seriesModel) {
+  return seriesModel.get("stack") || STACK_PREFIX + seriesModel.seriesIndex;
+}
+function getAxisKey(axis) {
+  return axis.dim + axis.index;
+}
+function getLayoutOnAxis(opt) {
+  var params = [];
+  var baseAxis = opt.axis;
+  var axisKey = "axis0";
+  if (baseAxis.type !== "category") {
+    return;
   }
-};
-DEFAULT_COMMON_STYLE[STYLE_MAGIC_KEY] = true;
-var PRIMARY_STATES_KEYS = ["z", "z2", "invisible"];
-var PRIMARY_STATES_KEYS_IN_HOVER_LAYER = ["invisible"];
-var Displayable = (function(_super) {
-  __extends(Displayable2, _super);
-  function Displayable2(props) {
-    return _super.call(this, props) || this;
+  var bandWidth = baseAxis.getBandWidth();
+  for (var i = 0; i < opt.count || 0; i++) {
+    params.push(defaults({
+      bandWidth,
+      axisKey,
+      stackId: STACK_PREFIX + i
+    }, opt));
   }
-  Displayable2.prototype._init = function(props) {
-    var keysArr = keys(props);
-    for (var i = 0; i < keysArr.length; i++) {
-      var key = keysArr[i];
-      if (key === "style") {
-        this.useStyle(props[key]);
-      } else {
-        _super.prototype.attrKV.call(this, key, props[key]);
-      }
-    }
-    if (!this.style) {
-      this.useStyle({});
-    }
-  };
-  Displayable2.prototype.beforeBrush = function() {
-  };
-  Displayable2.prototype.afterBrush = function() {
-  };
-  Displayable2.prototype.innerBeforeBrush = function() {
-  };
-  Displayable2.prototype.innerAfterBrush = function() {
-  };
-  Displayable2.prototype.shouldBePainted = function(viewWidth, viewHeight, considerClipPath, considerAncestors) {
-    var m = this.transform;
-    if (this.ignore || this.invisible || this.style.opacity === 0 || this.culling && isDisplayableCulled(this, viewWidth, viewHeight) || m && !m[0] && !m[3]) {
-      return false;
-    }
-    if (considerClipPath && this.__clipPaths) {
-      for (var i = 0; i < this.__clipPaths.length; ++i) {
-        if (this.__clipPaths[i].isZeroArea()) {
-          return false;
-        }
-      }
+  var widthAndOffsets = doCalBarWidthAndOffset(params);
+  var result = [];
+  for (var i = 0; i < opt.count; i++) {
+    var item = widthAndOffsets[axisKey][STACK_PREFIX + i];
+    item.offsetCenter = item.offset + item.width / 2;
+    result.push(item);
+  }
+  return result;
+}
+function prepareLayoutBarSeries(seriesType, ecModel) {
+  var seriesModels = [];
+  ecModel.eachSeriesByType(seriesType, function(seriesModel) {
+    if (isOnCartesian(seriesModel)) {
+      seriesModels.push(seriesModel);
     }
-    if (considerAncestors && this.parent) {
-      var parent_1 = this.parent;
-      while (parent_1) {
-        if (parent_1.ignore) {
-          return false;
-        }
-        parent_1 = parent_1.parent;
-      }
+  });
+  return seriesModels;
+}
+function getValueAxesMinGaps(barSeries) {
+  var axisValues = {};
+  each(barSeries, function(seriesModel) {
+    var cartesian = seriesModel.coordinateSystem;
+    var baseAxis = cartesian.getBaseAxis();
+    if (baseAxis.type !== "time" && baseAxis.type !== "value") {
+      return;
     }
-    return true;
-  };
-  Displayable2.prototype.contain = function(x, y) {
-    return this.rectContain(x, y);
-  };
-  Displayable2.prototype.traverse = function(cb, context) {
-    cb.call(context, this);
-  };
-  Displayable2.prototype.rectContain = function(x, y) {
-    var coord = this.transformCoordToLocal(x, y);
-    var rect = this.getBoundingRect();
-    return rect.contain(coord[0], coord[1]);
-  };
-  Displayable2.prototype.getPaintRect = function() {
-    var rect = this._paintRect;
-    if (!this._paintRect || this.__dirty) {
-      var transform = this.transform;
-      var elRect = this.getBoundingRect();
-      var style = this.style;
-      var shadowSize = style.shadowBlur || 0;
-      var shadowOffsetX = style.shadowOffsetX || 0;
-      var shadowOffsetY = style.shadowOffsetY || 0;
-      rect = this._paintRect || (this._paintRect = new BoundingRect(0, 0, 0, 0));
-      if (transform) {
-        BoundingRect.applyTransform(rect, elRect, transform);
+    var data = seriesModel.getData();
+    var key2 = baseAxis.dim + "_" + baseAxis.index;
+    var dimIdx = data.getDimensionIndex(data.mapDimension(baseAxis.dim));
+    var store = data.getStore();
+    for (var i = 0, cnt = store.count(); i < cnt; ++i) {
+      var value = store.get(dimIdx, i);
+      if (!axisValues[key2]) {
+        axisValues[key2] = [value];
       } else {
-        rect.copy(elRect);
-      }
-      if (shadowSize || shadowOffsetX || shadowOffsetY) {
-        rect.width += shadowSize * 2 + Math.abs(shadowOffsetX);
-        rect.height += shadowSize * 2 + Math.abs(shadowOffsetY);
-        rect.x = Math.min(rect.x, rect.x + shadowOffsetX - shadowSize);
-        rect.y = Math.min(rect.y, rect.y + shadowOffsetY - shadowSize);
+        axisValues[key2].push(value);
       }
-      var tolerance = this.dirtyRectTolerance;
-      if (!rect.isZero()) {
-        rect.x = Math.floor(rect.x - tolerance);
-        rect.y = Math.floor(rect.y - tolerance);
-        rect.width = Math.ceil(rect.width + 1 + tolerance * 2);
-        rect.height = Math.ceil(rect.height + 1 + tolerance * 2);
-      }
-    }
-    return rect;
-  };
-  Displayable2.prototype.setPrevPaintRect = function(paintRect) {
-    if (paintRect) {
-      this._prevPaintRect = this._prevPaintRect || new BoundingRect(0, 0, 0, 0);
-      this._prevPaintRect.copy(paintRect);
-    } else {
-      this._prevPaintRect = null;
-    }
-  };
-  Displayable2.prototype.getPrevPaintRect = function() {
-    return this._prevPaintRect;
-  };
-  Displayable2.prototype.animateStyle = function(loop) {
-    return this.animate("style", loop);
-  };
-  Displayable2.prototype.updateDuringAnimation = function(targetKey) {
-    if (targetKey === "style") {
-      this.dirtyStyle();
-    } else {
-      this.markRedraw();
     }
-  };
-  Displayable2.prototype.attrKV = function(key, value) {
-    if (key !== "style") {
-      _super.prototype.attrKV.call(this, key, value);
-    } else {
-      if (!this.style) {
-        this.useStyle(value);
-      } else {
-        this.setStyle(value);
+  });
+  var axisMinGaps = {};
+  for (var key in axisValues) {
+    if (axisValues.hasOwnProperty(key)) {
+      var valuesInAxis = axisValues[key];
+      if (valuesInAxis) {
+        valuesInAxis.sort(function(a, b) {
+          return a - b;
+        });
+        var min = null;
+        for (var j = 1; j < valuesInAxis.length; ++j) {
+          var delta = valuesInAxis[j] - valuesInAxis[j - 1];
+          if (delta > 0) {
+            min = min === null ? delta : Math.min(min, delta);
+          }
+        }
+        axisMinGaps[key] = min;
       }
     }
-  };
-  Displayable2.prototype.setStyle = function(keyOrObj, value) {
-    if (typeof keyOrObj === "string") {
-      this.style[keyOrObj] = value;
+  }
+  return axisMinGaps;
+}
+function makeColumnLayout(barSeries) {
+  var axisMinGaps = getValueAxesMinGaps(barSeries);
+  var seriesInfoList = [];
+  each(barSeries, function(seriesModel) {
+    var cartesian = seriesModel.coordinateSystem;
+    var baseAxis = cartesian.getBaseAxis();
+    var axisExtent = baseAxis.getExtent();
+    var bandWidth;
+    if (baseAxis.type === "category") {
+      bandWidth = baseAxis.getBandWidth();
+    } else if (baseAxis.type === "value" || baseAxis.type === "time") {
+      var key = baseAxis.dim + "_" + baseAxis.index;
+      var minGap = axisMinGaps[key];
+      var extentSpan = Math.abs(axisExtent[1] - axisExtent[0]);
+      var scale = baseAxis.scale.getExtent();
+      var scaleSpan = Math.abs(scale[1] - scale[0]);
+      bandWidth = minGap ? extentSpan / scaleSpan * minGap : extentSpan;
     } else {
-      extend(this.style, keyOrObj);
+      var data = seriesModel.getData();
+      bandWidth = Math.abs(axisExtent[1] - axisExtent[0]) / data.count();
     }
-    this.dirtyStyle();
-    return this;
-  };
-  Displayable2.prototype.dirtyStyle = function(notRedraw) {
-    if (!notRedraw) {
-      this.markRedraw();
+    var barWidth = parsePercent(seriesModel.get("barWidth"), bandWidth);
+    var barMaxWidth = parsePercent(seriesModel.get("barMaxWidth"), bandWidth);
+    var barMinWidth = parsePercent(
+      // barMinWidth by default is 0.5 / 1 in cartesian. Because in value axis,
+      // the auto-calculated bar width might be less than 0.5 / 1.
+      seriesModel.get("barMinWidth") || (isInLargeMode(seriesModel) ? 0.5 : 1),
+      bandWidth
+    );
+    var barGap = seriesModel.get("barGap");
+    var barCategoryGap = seriesModel.get("barCategoryGap");
+    seriesInfoList.push({
+      bandWidth,
+      barWidth,
+      barMaxWidth,
+      barMinWidth,
+      barGap,
+      barCategoryGap,
+      axisKey: getAxisKey(baseAxis),
+      stackId: getSeriesStackId(seriesModel)
+    });
+  });
+  return doCalBarWidthAndOffset(seriesInfoList);
+}
+function doCalBarWidthAndOffset(seriesInfoList) {
+  var columnsMap = {};
+  each(seriesInfoList, function(seriesInfo, idx) {
+    var axisKey = seriesInfo.axisKey;
+    var bandWidth = seriesInfo.bandWidth;
+    var columnsOnAxis = columnsMap[axisKey] || {
+      bandWidth,
+      remainedWidth: bandWidth,
+      autoWidthCount: 0,
+      categoryGap: null,
+      gap: "20%",
+      stacks: {}
+    };
+    var stacks = columnsOnAxis.stacks;
+    columnsMap[axisKey] = columnsOnAxis;
+    var stackId = seriesInfo.stackId;
+    if (!stacks[stackId]) {
+      columnsOnAxis.autoWidthCount++;
     }
-    this.__dirty |= STYLE_CHANGED_BIT;
-    if (this._rect) {
-      this._rect = null;
+    stacks[stackId] = stacks[stackId] || {
+      width: 0,
+      maxWidth: 0
+    };
+    var barWidth = seriesInfo.barWidth;
+    if (barWidth && !stacks[stackId].width) {
+      stacks[stackId].width = barWidth;
+      barWidth = Math.min(columnsOnAxis.remainedWidth, barWidth);
+      columnsOnAxis.remainedWidth -= barWidth;
     }
-  };
-  Displayable2.prototype.dirty = function() {
-    this.dirtyStyle();
-  };
-  Displayable2.prototype.styleChanged = function() {
-    return !!(this.__dirty & STYLE_CHANGED_BIT);
-  };
-  Displayable2.prototype.styleUpdated = function() {
-    this.__dirty &= ~STYLE_CHANGED_BIT;
-  };
-  Displayable2.prototype.createStyle = function(obj) {
-    return createObject(DEFAULT_COMMON_STYLE, obj);
-  };
-  Displayable2.prototype.useStyle = function(obj) {
-    if (!obj[STYLE_MAGIC_KEY]) {
-      obj = this.createStyle(obj);
-    }
-    if (this.__inHover) {
-      this.__hoverStyle = obj;
-    } else {
-      this.style = obj;
+    var barMaxWidth = seriesInfo.barMaxWidth;
+    barMaxWidth && (stacks[stackId].maxWidth = barMaxWidth);
+    var barMinWidth = seriesInfo.barMinWidth;
+    barMinWidth && (stacks[stackId].minWidth = barMinWidth);
+    var barGap = seriesInfo.barGap;
+    barGap != null && (columnsOnAxis.gap = barGap);
+    var barCategoryGap = seriesInfo.barCategoryGap;
+    barCategoryGap != null && (columnsOnAxis.categoryGap = barCategoryGap);
+  });
+  var result = {};
+  each(columnsMap, function(columnsOnAxis, coordSysName) {
+    result[coordSysName] = {};
+    var stacks = columnsOnAxis.stacks;
+    var bandWidth = columnsOnAxis.bandWidth;
+    var categoryGapPercent = columnsOnAxis.categoryGap;
+    if (categoryGapPercent == null) {
+      var columnCount = keys(stacks).length;
+      categoryGapPercent = Math.max(35 - columnCount * 4, 15) + "%";
     }
-    this.dirtyStyle();
-  };
-  Displayable2.prototype.isStyleObject = function(obj) {
-    return obj[STYLE_MAGIC_KEY];
-  };
-  Displayable2.prototype._innerSaveToNormal = function(toState) {
-    _super.prototype._innerSaveToNormal.call(this, toState);
-    var normalState = this._normalState;
-    if (toState.style && !normalState.style) {
-      normalState.style = this._mergeStyle(this.createStyle(), this.style);
-    }
-    this._savePrimaryToNormal(toState, normalState, PRIMARY_STATES_KEYS);
-  };
-  Displayable2.prototype._applyStateObj = function(stateName, state, normalState, keepCurrentStates, transition, animationCfg) {
-    _super.prototype._applyStateObj.call(this, stateName, state, normalState, keepCurrentStates, transition, animationCfg);
-    var needsRestoreToNormal = !(state && keepCurrentStates);
-    var targetStyle;
-    if (state && state.style) {
-      if (transition) {
-        if (keepCurrentStates) {
-          targetStyle = state.style;
-        } else {
-          targetStyle = this._mergeStyle(this.createStyle(), normalState.style);
-          this._mergeStyle(targetStyle, state.style);
+    var categoryGap = parsePercent(categoryGapPercent, 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) {
+      var maxWidth = column.maxWidth;
+      var minWidth = column.minWidth;
+      if (!column.width) {
+        var finalWidth = autoWidth;
+        if (maxWidth && maxWidth < finalWidth) {
+          finalWidth = Math.min(maxWidth, remainedWidth);
         }
-      } else {
-        targetStyle = this._mergeStyle(this.createStyle(), keepCurrentStates ? this.style : normalState.style);
-        this._mergeStyle(targetStyle, state.style);
-      }
-    } else if (needsRestoreToNormal) {
-      targetStyle = normalState.style;
-    }
-    if (targetStyle) {
-      if (transition) {
-        var sourceStyle = this.style;
-        this.style = this.createStyle(needsRestoreToNormal ? {} : sourceStyle);
-        if (needsRestoreToNormal) {
-          var changedKeys = keys(sourceStyle);
-          for (var i = 0; i < changedKeys.length; i++) {
-            var key = changedKeys[i];
-            if (key in targetStyle) {
-              targetStyle[key] = targetStyle[key];
-              this.style[key] = sourceStyle[key];
-            }
-          }
+        if (minWidth && minWidth > finalWidth) {
+          finalWidth = minWidth;
         }
-        var targetKeys = keys(targetStyle);
-        for (var i = 0; i < targetKeys.length; i++) {
-          var key = targetKeys[i];
-          this.style[key] = this.style[key];
+        if (finalWidth !== autoWidth) {
+          column.width = finalWidth;
+          remainedWidth -= finalWidth + barGapPercent * finalWidth;
+          autoWidthCount--;
         }
-        this._transitionState(stateName, {
-          style: targetStyle
-        }, animationCfg, this.getAnimationStyleProps());
       } else {
-        this.useStyle(targetStyle);
-      }
-    }
-    var statesKeys = this.__inHover ? PRIMARY_STATES_KEYS_IN_HOVER_LAYER : PRIMARY_STATES_KEYS;
-    for (var i = 0; i < statesKeys.length; i++) {
-      var key = statesKeys[i];
-      if (state && state[key] != null) {
-        this[key] = state[key];
-      } else if (needsRestoreToNormal) {
-        if (normalState[key] != null) {
-          this[key] = normalState[key];
+        var finalWidth = column.width;
+        if (maxWidth) {
+          finalWidth = Math.min(finalWidth, maxWidth);
+        }
+        if (minWidth) {
+          finalWidth = Math.max(finalWidth, minWidth);
         }
+        column.width = finalWidth;
+        remainedWidth -= finalWidth + barGapPercent * finalWidth;
+        autoWidthCount--;
       }
-    }
-  };
-  Displayable2.prototype._mergeStates = function(states) {
-    var mergedState = _super.prototype._mergeStates.call(this, states);
-    var mergedStyle;
-    for (var i = 0; i < states.length; i++) {
-      var state = states[i];
-      if (state.style) {
-        mergedStyle = mergedStyle || {};
-        this._mergeStyle(mergedStyle, state.style);
+    });
+    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;
     }
-    if (mergedStyle) {
-      mergedState.style = mergedStyle;
+    var offset = -widthSum / 2;
+    each(stacks, function(column, stackId) {
+      result[coordSysName][stackId] = result[coordSysName][stackId] || {
+        bandWidth,
+        offset,
+        width: column.width
+      };
+      offset += column.width * (1 + barGapPercent);
+    });
+  });
+  return result;
+}
+function retrieveColumnLayout(barWidthAndOffset, axis, seriesModel) {
+  if (barWidthAndOffset && axis) {
+    var result = barWidthAndOffset[getAxisKey(axis)];
+    return result;
+  }
+}
+function layout(seriesType, ecModel) {
+  var seriesModels = prepareLayoutBarSeries(seriesType, ecModel);
+  var barWidthAndOffset = makeColumnLayout(seriesModels);
+  each(seriesModels, function(seriesModel) {
+    var data = seriesModel.getData();
+    var cartesian = seriesModel.coordinateSystem;
+    var baseAxis = cartesian.getBaseAxis();
+    var stackId = getSeriesStackId(seriesModel);
+    var columnLayoutInfo = barWidthAndOffset[getAxisKey(baseAxis)][stackId];
+    var columnOffset = columnLayoutInfo.offset;
+    var columnWidth = columnLayoutInfo.width;
+    data.setLayout({
+      bandWidth: columnLayoutInfo.bandWidth,
+      offset: columnOffset,
+      size: columnWidth
+    });
+  });
+}
+function createProgressiveLayout(seriesType) {
+  return {
+    seriesType,
+    plan: createRenderPlanner(),
+    reset: function(seriesModel) {
+      if (!isOnCartesian(seriesModel)) {
+        return;
+      }
+      var data = seriesModel.getData();
+      var cartesian = seriesModel.coordinateSystem;
+      var baseAxis = cartesian.getBaseAxis();
+      var valueAxis = cartesian.getOtherAxis(baseAxis);
+      var valueDimIdx = data.getDimensionIndex(data.mapDimension(valueAxis.dim));
+      var baseDimIdx = data.getDimensionIndex(data.mapDimension(baseAxis.dim));
+      var drawBackground = seriesModel.get("showBackground", true);
+      var valueDim = data.mapDimension(valueAxis.dim);
+      var stackResultDim = data.getCalculationInfo("stackResultDimension");
+      var stacked = isDimensionStacked(data, valueDim) && !!data.getCalculationInfo("stackedOnSeries");
+      var isValueAxisH = valueAxis.isHorizontal();
+      var valueAxisStart = getValueAxisStart(baseAxis, valueAxis);
+      var isLarge = isInLargeMode(seriesModel);
+      var barMinHeight = seriesModel.get("barMinHeight") || 0;
+      var stackedDimIdx = stackResultDim && data.getDimensionIndex(stackResultDim);
+      var columnWidth = data.getLayout("size");
+      var columnOffset = data.getLayout("offset");
+      return {
+        progress: function(params, data2) {
+          var count = params.count;
+          var largePoints = isLarge && createFloat32Array(count * 3);
+          var largeBackgroundPoints = isLarge && drawBackground && createFloat32Array(count * 3);
+          var largeDataIndices = isLarge && createFloat32Array(count);
+          var coordLayout = cartesian.master.getRect();
+          var bgSize = isValueAxisH ? coordLayout.width : coordLayout.height;
+          var dataIndex;
+          var store = data2.getStore();
+          var idxOffset = 0;
+          while ((dataIndex = params.next()) != null) {
+            var value = store.get(stacked ? stackedDimIdx : valueDimIdx, dataIndex);
+            var baseValue = store.get(baseDimIdx, dataIndex);
+            var baseCoord = valueAxisStart;
+            var stackStartValue = void 0;
+            if (stacked) {
+              stackStartValue = +value - store.get(valueDimIdx, dataIndex);
+            }
+            var x = void 0;
+            var y = void 0;
+            var width = void 0;
+            var height = void 0;
+            if (isValueAxisH) {
+              var coord = cartesian.dataToPoint([value, baseValue]);
+              if (stacked) {
+                var startCoord = cartesian.dataToPoint([stackStartValue, baseValue]);
+                baseCoord = startCoord[0];
+              }
+              x = baseCoord;
+              y = coord[1] + columnOffset;
+              width = coord[0] - baseCoord;
+              height = columnWidth;
+              if (Math.abs(width) < barMinHeight) {
+                width = (width < 0 ? -1 : 1) * barMinHeight;
+              }
+            } else {
+              var coord = cartesian.dataToPoint([baseValue, value]);
+              if (stacked) {
+                var startCoord = cartesian.dataToPoint([baseValue, stackStartValue]);
+                baseCoord = startCoord[1];
+              }
+              x = coord[0] + columnOffset;
+              y = baseCoord;
+              width = columnWidth;
+              height = coord[1] - baseCoord;
+              if (Math.abs(height) < barMinHeight) {
+                height = (height <= 0 ? -1 : 1) * barMinHeight;
+              }
+            }
+            if (!isLarge) {
+              data2.setItemLayout(dataIndex, {
+                x,
+                y,
+                width,
+                height
+              });
+            } else {
+              largePoints[idxOffset] = x;
+              largePoints[idxOffset + 1] = y;
+              largePoints[idxOffset + 2] = isValueAxisH ? width : height;
+              if (largeBackgroundPoints) {
+                largeBackgroundPoints[idxOffset] = isValueAxisH ? coordLayout.x : x;
+                largeBackgroundPoints[idxOffset + 1] = isValueAxisH ? y : coordLayout.y;
+                largeBackgroundPoints[idxOffset + 2] = bgSize;
+              }
+              largeDataIndices[dataIndex] = dataIndex;
+            }
+            idxOffset += 3;
+          }
+          if (isLarge) {
+            data2.setLayout({
+              largePoints,
+              largeDataIndices,
+              largeBackgroundPoints,
+              valueAxisHorizontal: isValueAxisH
+            });
+          }
+        }
+      };
     }
-    return mergedState;
   };
-  Displayable2.prototype._mergeStyle = function(targetStyle, sourceStyle) {
-    extend(targetStyle, sourceStyle);
-    return targetStyle;
-  };
-  Displayable2.prototype.getAnimationStyleProps = function() {
-    return DEFAULT_COMMON_ANIMATION_PROPS;
-  };
-  Displayable2.initDefaultProps = (function() {
-    var dispProto = Displayable2.prototype;
-    dispProto.type = "displayable";
-    dispProto.invisible = false;
-    dispProto.z = 0;
-    dispProto.z2 = 0;
-    dispProto.zlevel = 0;
-    dispProto.culling = false;
-    dispProto.cursor = "pointer";
-    dispProto.rectHover = false;
-    dispProto.incremental = false;
-    dispProto._rect = null;
-    dispProto.dirtyRectTolerance = 0;
-    dispProto.__dirty = REDRAW_BIT | STYLE_CHANGED_BIT;
-  })();
-  return Displayable2;
-})(Element);
-var tmpRect = new BoundingRect(0, 0, 0, 0);
-var viewRect = new BoundingRect(0, 0, 0, 0);
-function isDisplayableCulled(el, width, height) {
-  tmpRect.copy(el.getBoundingRect());
-  if (el.transform) {
-    tmpRect.applyTransform(el.transform);
+}
+function isOnCartesian(seriesModel) {
+  return seriesModel.coordinateSystem && seriesModel.coordinateSystem.type === "cartesian2d";
+}
+function isInLargeMode(seriesModel) {
+  return seriesModel.pipelineContext && seriesModel.pipelineContext.large;
+}
+function getValueAxisStart(baseAxis, valueAxis) {
+  var startValue = valueAxis.model.get("startValue");
+  if (!startValue) {
+    startValue = 0;
   }
-  viewRect.width = width;
-  viewRect.height = height;
-  return !tmpRect.intersect(viewRect);
+  return valueAxis.toGlobalCoord(valueAxis.dataToCoord(valueAxis.type === "log" ? startValue > 0 ? startValue : 1 : startValue));
 }
 export {
-  DEFAULT_COMMON_ANIMATION_PROPS,
-  DEFAULT_COMMON_STYLE,
-  Displayable as default
+  createProgressiveLayout,
+  getLayoutOnAxis,
+  layout,
+  makeColumnLayout,
+  prepareLayoutBarSeries,
+  retrieveColumnLayout
 };