sun-card-design 1.1.16 → 1.1.18

package/dist/mobile/sun-card-design-mobile.es1860.js

@@ -1,62 +1,693 @@
 import { __extends } from "./sun-card-design-mobile.es1717.js";
-import axisDefault from "./sun-card-design-mobile.es2091.js";
-import { fetchLayoutMode, getLayoutParams, mergeLayoutParam } from "./sun-card-design-mobile.es1758.js";
-import OrdinalMeta from "./sun-card-design-mobile.es2092.js";
-import { AXIS_TYPES } from "./sun-card-design-mobile.es2093.js";
-import { each, merge } from "./sun-card-design-mobile.es922.js";
-function axisModelCreator(registers, axisName, BaseAxisModelClass, extraDefaultOption) {
-  each(AXIS_TYPES, function(v, axisType) {
-    var defaultOption = merge(merge({}, axisDefault[axisType], true), extraDefaultOption, true);
-    var AxisModel = (
-      /** @class */
-      (function(_super) {
-        __extends(AxisModel2, _super);
-        function AxisModel2() {
-          var _this = _super !== null && _super.apply(this, arguments) || this;
-          _this.type = axisName + "Axis." + axisType;
-          return _this;
+import { assert, defaults, retrieve2, retrieve3, hasOwn, each, indexOf, isString } from "./sun-card-design-mobile.es922.js";
+import { traverseElements, makePath, getShapeClass } from "./sun-card-design-mobile.es1757.js";
+import { toggleHoverEmphasis, setDefaultStateProxy } from "./sun-card-design-mobile.es1728.js";
+import { createTextStyle, createTextConfig, getFont } from "./sun-card-design-mobile.es1918.js";
+import { getDefaultLabel } from "./sun-card-design-mobile.es2036.js";
+import { getLayoutOnAxis } from "./sun-card-design-mobile.es1779.js";
+import DataDiffer from "./sun-card-design-mobile.es1773.js";
+import ChartView from "./sun-card-design-mobile.es919.js";
+import { createClipPath } from "./sun-card-design-mobile.es2033.js";
+import cartesianPrepareCustom from "./sun-card-design-mobile.es2084.js";
+import geoPrepareCustom from "./sun-card-design-mobile.es2085.js";
+import singlePrepareCustom from "./sun-card-design-mobile.es2086.js";
+import polarPrepareCustom from "./sun-card-design-mobile.es2087.js";
+import calendarPrepareCustom from "./sun-card-design-mobile.es2088.js";
+import Displayable from "./sun-card-design-mobile.es1774.js";
+import { warnDeprecated, convertToEC4StyleForCustomSerise, isEC4CompatibleStyle, convertFromEC4CompatibleStyle } from "./sun-card-design-mobile.es2089.js";
+import { throwError } from "./sun-card-design-mobile.es1740.js";
+import { createOrUpdatePatternFromDecal } from "./sun-card-design-mobile.es2017.js";
+import { customInnerStore, STYLE_VISUAL_TYPE, NON_STYLE_VISUAL_PROPS } from "./sun-card-design-mobile.es1859.js";
+import { applyLeaveTransition, applyUpdateTransition } from "./sun-card-design-mobile.es2090.js";
+import { stopPreviousKeyframeAnimationAndRestore, applyKeyframeAnimation } from "./sun-card-design-mobile.es2091.js";
+import ZRImage from "./sun-card-design-mobile.es1749.js";
+import ZRText from "./sun-card-design-mobile.es1920.js";
+import Group from "./sun-card-design-mobile.es1753.js";
+import Path from "./sun-card-design-mobile.es1750.js";
+var EMPHASIS = "emphasis";
+var NORMAL = "normal";
+var BLUR = "blur";
+var SELECT = "select";
+var STATES = [NORMAL, EMPHASIS, BLUR, SELECT];
+var PATH_ITEM_STYLE = {
+  normal: ["itemStyle"],
+  emphasis: [EMPHASIS, "itemStyle"],
+  blur: [BLUR, "itemStyle"],
+  select: [SELECT, "itemStyle"]
+};
+var PATH_LABEL = {
+  normal: ["label"],
+  emphasis: [EMPHASIS, "label"],
+  blur: [BLUR, "label"],
+  select: [SELECT, "label"]
+};
+var DEFAULT_TRANSITION = ["x", "y"];
+var GROUP_DIFF_PREFIX = "e\0\0";
+var attachedTxInfoTmp = {
+  normal: {},
+  emphasis: {},
+  blur: {},
+  select: {}
+};
+var prepareCustoms = {
+  cartesian2d: cartesianPrepareCustom,
+  geo: geoPrepareCustom,
+  single: singlePrepareCustom,
+  polar: polarPrepareCustom,
+  calendar: calendarPrepareCustom
+};
+function isPath(el) {
+  return el instanceof Path;
+}
+function isDisplayable(el) {
+  return el instanceof Displayable;
+}
+function copyElement(sourceEl, targetEl) {
+  targetEl.copyTransform(sourceEl);
+  if (isDisplayable(targetEl) && isDisplayable(sourceEl)) {
+    targetEl.setStyle(sourceEl.style);
+    targetEl.z = sourceEl.z;
+    targetEl.z2 = sourceEl.z2;
+    targetEl.zlevel = sourceEl.zlevel;
+    targetEl.invisible = sourceEl.invisible;
+    targetEl.ignore = sourceEl.ignore;
+    if (isPath(targetEl) && isPath(sourceEl)) {
+      targetEl.setShape(sourceEl.shape);
+    }
+  }
+}
+var CustomChartView = (
+  /** @class */
+  (function(_super) {
+    __extends(CustomChartView2, _super);
+    function CustomChartView2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = CustomChartView2.type;
+      return _this;
+    }
+    CustomChartView2.prototype.render = function(customSeries, ecModel, api, payload) {
+      this._progressiveEls = null;
+      var oldData = this._data;
+      var data = customSeries.getData();
+      var group = this.group;
+      var renderItem = makeRenderItem(customSeries, data, ecModel, api);
+      if (!oldData) {
+        group.removeAll();
+      }
+      data.diff(oldData).add(function(newIdx) {
+        createOrUpdateItem(api, null, newIdx, renderItem(newIdx, payload), customSeries, group, data);
+      }).remove(function(oldIdx) {
+        var el = oldData.getItemGraphicEl(oldIdx);
+        el && applyLeaveTransition(el, customInnerStore(el).option, customSeries);
+      }).update(function(newIdx, oldIdx) {
+        var oldEl = oldData.getItemGraphicEl(oldIdx);
+        createOrUpdateItem(api, oldEl, newIdx, renderItem(newIdx, payload), customSeries, group, data);
+      }).execute();
+      var clipPath = customSeries.get("clip", true) ? createClipPath(customSeries.coordinateSystem, false, customSeries) : null;
+      if (clipPath) {
+        group.setClipPath(clipPath);
+      } else {
+        group.removeClipPath();
+      }
+      this._data = data;
+    };
+    CustomChartView2.prototype.incrementalPrepareRender = function(customSeries, ecModel, api) {
+      this.group.removeAll();
+      this._data = null;
+    };
+    CustomChartView2.prototype.incrementalRender = function(params, customSeries, ecModel, api, payload) {
+      var data = customSeries.getData();
+      var renderItem = makeRenderItem(customSeries, data, ecModel, api);
+      var progressiveEls = this._progressiveEls = [];
+      function setIncrementalAndHoverLayer(el2) {
+        if (!el2.isGroup) {
+          el2.incremental = true;
+          el2.ensureState("emphasis").hoverLayer = true;
+        }
+      }
+      for (var idx = params.start; idx < params.end; idx++) {
+        var el = createOrUpdateItem(null, null, idx, renderItem(idx, payload), customSeries, this.group, data);
+        if (el) {
+          el.traverse(setIncrementalAndHoverLayer);
+          progressiveEls.push(el);
         }
-        AxisModel2.prototype.mergeDefaultAndTheme = function(option, ecModel) {
-          var layoutMode = fetchLayoutMode(this);
-          var inputPositionParams = layoutMode ? getLayoutParams(option) : {};
-          var themeModel = ecModel.getTheme();
-          merge(option, themeModel.get(axisType + "Axis"));
-          merge(option, this.getDefaultOption());
-          option.type = getAxisType(option);
-          if (layoutMode) {
-            mergeLayoutParam(option, inputPositionParams, layoutMode);
-          }
-        };
-        AxisModel2.prototype.optionUpdated = function() {
-          var thisOption = this.option;
-          if (thisOption.type === "category") {
-            this.__ordinalMeta = OrdinalMeta.createByAxisModel(this);
-          }
-        };
-        AxisModel2.prototype.getCategories = function(rawData) {
-          var option = this.option;
-          if (option.type === "category") {
-            if (rawData) {
-              return option.data;
-            }
-            return this.__ordinalMeta.categories;
-          }
-        };
-        AxisModel2.prototype.getOrdinalMeta = function() {
-          return this.__ordinalMeta;
-        };
-        AxisModel2.type = axisName + "Axis." + axisType;
-        AxisModel2.defaultOption = defaultOption;
-        return AxisModel2;
-      })(BaseAxisModelClass)
-    );
-    registers.registerComponentModel(AxisModel);
+      }
+    };
+    CustomChartView2.prototype.eachRendered = function(cb) {
+      traverseElements(this._progressiveEls || this.group, cb);
+    };
+    CustomChartView2.prototype.filterForExposedEvent = function(eventType, query, targetEl, packedEvent) {
+      var elementName = query.element;
+      if (elementName == null || targetEl.name === elementName) {
+        return true;
+      }
+      while ((targetEl = targetEl.__hostTarget || targetEl.parent) && targetEl !== this.group) {
+        if (targetEl.name === elementName) {
+          return true;
+        }
+      }
+      return false;
+    };
+    CustomChartView2.type = "custom";
+    return CustomChartView2;
+  })(ChartView)
+);
+function createEl(elOption) {
+  var graphicType = elOption.type;
+  var el;
+  if (graphicType === "path") {
+    var shape = elOption.shape;
+    var pathRect = shape.width != null && shape.height != null ? {
+      x: shape.x || 0,
+      y: shape.y || 0,
+      width: shape.width,
+      height: shape.height
+    } : null;
+    var pathData = getPathData(shape);
+    el = makePath(pathData, null, pathRect, shape.layout || "center");
+    customInnerStore(el).customPathData = pathData;
+  } else if (graphicType === "image") {
+    el = new ZRImage({});
+    customInnerStore(el).customImagePath = elOption.style.image;
+  } else if (graphicType === "text") {
+    el = new ZRText({});
+  } else if (graphicType === "group") {
+    el = new Group();
+  } else if (graphicType === "compoundPath") {
+    throw new Error('"compoundPath" is not supported yet.');
+  } else {
+    var Clz = getShapeClass(graphicType);
+    if (!Clz) {
+      var errMsg = "";
+      if (process.env.NODE_ENV !== "production") {
+        errMsg = 'graphic type "' + graphicType + '" can not be found.';
+      }
+      throwError(errMsg);
+    }
+    el = new Clz();
+  }
+  customInnerStore(el).customGraphicType = graphicType;
+  el.name = elOption.name;
+  el.z2EmphasisLift = 1;
+  el.z2SelectLift = 1;
+  return el;
+}
+function updateElNormal(api, el, dataIndex, elOption, attachedTxInfo, seriesModel, isInit) {
+  stopPreviousKeyframeAnimationAndRestore(el);
+  var txCfgOpt = attachedTxInfo && attachedTxInfo.normal.cfg;
+  if (txCfgOpt) {
+    el.setTextConfig(txCfgOpt);
+  }
+  if (elOption && elOption.transition == null) {
+    elOption.transition = DEFAULT_TRANSITION;
+  }
+  var styleOpt = elOption && elOption.style;
+  if (styleOpt) {
+    if (el.type === "text") {
+      var textOptionStyle = styleOpt;
+      hasOwn(textOptionStyle, "textFill") && (textOptionStyle.fill = textOptionStyle.textFill);
+      hasOwn(textOptionStyle, "textStroke") && (textOptionStyle.stroke = textOptionStyle.textStroke);
+    }
+    var decalPattern = void 0;
+    var decalObj = isPath(el) ? styleOpt.decal : null;
+    if (api && decalObj) {
+      decalObj.dirty = true;
+      decalPattern = createOrUpdatePatternFromDecal(decalObj, api);
+    }
+    styleOpt.__decalPattern = decalPattern;
+  }
+  if (isDisplayable(el)) {
+    if (styleOpt) {
+      var decalPattern = styleOpt.__decalPattern;
+      if (decalPattern) {
+        styleOpt.decal = decalPattern;
+      }
+    }
+  }
+  applyUpdateTransition(el, elOption, seriesModel, {
+    dataIndex,
+    isInit,
+    clearStyle: true
+  });
+  applyKeyframeAnimation(el, elOption.keyframeAnimation, seriesModel);
+}
+function updateElOnState(state, el, elStateOpt, styleOpt, attachedTxInfo) {
+  var elDisplayable = el.isGroup ? null : el;
+  var txCfgOpt = attachedTxInfo && attachedTxInfo[state].cfg;
+  if (elDisplayable) {
+    var stateObj = elDisplayable.ensureState(state);
+    if (styleOpt === false) {
+      var existingEmphasisState = elDisplayable.getState(state);
+      if (existingEmphasisState) {
+        existingEmphasisState.style = null;
+      }
+    } else {
+      stateObj.style = styleOpt || null;
+    }
+    if (txCfgOpt) {
+      stateObj.textConfig = txCfgOpt;
+    }
+    setDefaultStateProxy(elDisplayable);
+  }
+}
+function updateZ(el, elOption, seriesModel) {
+  if (el.isGroup) {
+    return;
+  }
+  var elDisplayable = el;
+  var currentZ = seriesModel.currentZ;
+  var currentZLevel = seriesModel.currentZLevel;
+  elDisplayable.z = currentZ;
+  elDisplayable.zlevel = currentZLevel;
+  var optZ2 = elOption.z2;
+  optZ2 != null && (elDisplayable.z2 = optZ2 || 0);
+  for (var i = 0; i < STATES.length; i++) {
+    updateZForEachState(elDisplayable, elOption, STATES[i]);
+  }
+}
+function updateZForEachState(elDisplayable, elOption, state) {
+  var isNormal = state === NORMAL;
+  var elStateOpt = isNormal ? elOption : retrieveStateOption(elOption, state);
+  var optZ2 = elStateOpt ? elStateOpt.z2 : null;
+  var stateObj;
+  if (optZ2 != null) {
+    stateObj = isNormal ? elDisplayable : elDisplayable.ensureState(state);
+    stateObj.z2 = optZ2 || 0;
+  }
+}
+function makeRenderItem(customSeries, data, ecModel, api) {
+  var renderItem = customSeries.get("renderItem");
+  var coordSys = customSeries.coordinateSystem;
+  var prepareResult = {};
+  if (coordSys) {
+    if (process.env.NODE_ENV !== "production") {
+      assert(renderItem, "series.render is required.");
+      assert(coordSys.prepareCustoms || prepareCustoms[coordSys.type], "This coordSys does not support custom series.");
+    }
+    prepareResult = coordSys.prepareCustoms ? coordSys.prepareCustoms(coordSys) : prepareCustoms[coordSys.type](coordSys);
+  }
+  var userAPI = defaults({
+    getWidth: api.getWidth,
+    getHeight: api.getHeight,
+    getZr: api.getZr,
+    getDevicePixelRatio: api.getDevicePixelRatio,
+    value,
+    style,
+    ordinalRawValue,
+    styleEmphasis,
+    visual,
+    barLayout,
+    currentSeriesIndices,
+    font
+  }, prepareResult.api || {});
+  var userParams = {
+    // The life cycle of context: current round of rendering.
+    // The global life cycle is probably not necessary, because
+    // user can store global status by themselves.
+    context: {},
+    seriesId: customSeries.id,
+    seriesName: customSeries.name,
+    seriesIndex: customSeries.seriesIndex,
+    coordSys: prepareResult.coordSys,
+    dataInsideLength: data.count(),
+    encode: wrapEncodeDef(customSeries.getData())
+  };
+  var currDataIndexInside;
+  var currItemModel;
+  var currItemStyleModels = {};
+  var currLabelModels = {};
+  var seriesItemStyleModels = {};
+  var seriesLabelModels = {};
+  for (var i = 0; i < STATES.length; i++) {
+    var stateName = STATES[i];
+    seriesItemStyleModels[stateName] = customSeries.getModel(PATH_ITEM_STYLE[stateName]);
+    seriesLabelModels[stateName] = customSeries.getModel(PATH_LABEL[stateName]);
+  }
+  function getItemModel(dataIndexInside) {
+    return dataIndexInside === currDataIndexInside ? currItemModel || (currItemModel = data.getItemModel(dataIndexInside)) : data.getItemModel(dataIndexInside);
+  }
+  function getItemStyleModel(dataIndexInside, state) {
+    return !data.hasItemOption ? seriesItemStyleModels[state] : dataIndexInside === currDataIndexInside ? currItemStyleModels[state] || (currItemStyleModels[state] = getItemModel(dataIndexInside).getModel(PATH_ITEM_STYLE[state])) : getItemModel(dataIndexInside).getModel(PATH_ITEM_STYLE[state]);
+  }
+  function getLabelModel(dataIndexInside, state) {
+    return !data.hasItemOption ? seriesLabelModels[state] : dataIndexInside === currDataIndexInside ? currLabelModels[state] || (currLabelModels[state] = getItemModel(dataIndexInside).getModel(PATH_LABEL[state])) : getItemModel(dataIndexInside).getModel(PATH_LABEL[state]);
+  }
+  return function(dataIndexInside, payload) {
+    currDataIndexInside = dataIndexInside;
+    currItemModel = null;
+    currItemStyleModels = {};
+    currLabelModels = {};
+    return renderItem && renderItem(defaults({
+      dataIndexInside,
+      dataIndex: data.getRawIndex(dataIndexInside),
+      // Can be used for optimization when zoom or roam.
+      actionType: payload ? payload.type : null
+    }, userParams), userAPI);
+  };
+  function value(dim, dataIndexInside) {
+    dataIndexInside == null && (dataIndexInside = currDataIndexInside);
+    return data.getStore().get(data.getDimensionIndex(dim || 0), dataIndexInside);
+  }
+  function ordinalRawValue(dim, dataIndexInside) {
+    dataIndexInside == null && (dataIndexInside = currDataIndexInside);
+    dim = dim || 0;
+    var dimInfo = data.getDimensionInfo(dim);
+    if (!dimInfo) {
+      var dimIndex = data.getDimensionIndex(dim);
+      return dimIndex >= 0 ? data.getStore().get(dimIndex, dataIndexInside) : void 0;
+    }
+    var val = data.get(dimInfo.name, dataIndexInside);
+    var ordinalMeta = dimInfo && dimInfo.ordinalMeta;
+    return ordinalMeta ? ordinalMeta.categories[val] : val;
+  }
+  function style(userProps, dataIndexInside) {
+    if (process.env.NODE_ENV !== "production") {
+      warnDeprecated("api.style", "Please write literal style directly instead.");
+    }
+    dataIndexInside == null && (dataIndexInside = currDataIndexInside);
+    var style2 = data.getItemVisual(dataIndexInside, "style");
+    var visualColor = style2 && style2.fill;
+    var opacity = style2 && style2.opacity;
+    var itemStyle = getItemStyleModel(dataIndexInside, NORMAL).getItemStyle();
+    visualColor != null && (itemStyle.fill = visualColor);
+    opacity != null && (itemStyle.opacity = opacity);
+    var opt = {
+      inheritColor: isString(visualColor) ? visualColor : "#000"
+    };
+    var labelModel = getLabelModel(dataIndexInside, NORMAL);
+    var textStyle = createTextStyle(labelModel, null, opt, false, true);
+    textStyle.text = labelModel.getShallow("show") ? retrieve2(customSeries.getFormattedLabel(dataIndexInside, NORMAL), getDefaultLabel(data, dataIndexInside)) : null;
+    var textConfig = createTextConfig(labelModel, opt, false);
+    preFetchFromExtra(userProps, itemStyle);
+    itemStyle = convertToEC4StyleForCustomSerise(itemStyle, textStyle, textConfig);
+    userProps && applyUserPropsAfter(itemStyle, userProps);
+    itemStyle.legacy = true;
+    return itemStyle;
+  }
+  function styleEmphasis(userProps, dataIndexInside) {
+    if (process.env.NODE_ENV !== "production") {
+      warnDeprecated("api.styleEmphasis", "Please write literal style directly instead.");
+    }
+    dataIndexInside == null && (dataIndexInside = currDataIndexInside);
+    var itemStyle = getItemStyleModel(dataIndexInside, EMPHASIS).getItemStyle();
+    var labelModel = getLabelModel(dataIndexInside, EMPHASIS);
+    var textStyle = createTextStyle(labelModel, null, null, true, true);
+    textStyle.text = labelModel.getShallow("show") ? retrieve3(customSeries.getFormattedLabel(dataIndexInside, EMPHASIS), customSeries.getFormattedLabel(dataIndexInside, NORMAL), getDefaultLabel(data, dataIndexInside)) : null;
+    var textConfig = createTextConfig(labelModel, null, true);
+    preFetchFromExtra(userProps, itemStyle);
+    itemStyle = convertToEC4StyleForCustomSerise(itemStyle, textStyle, textConfig);
+    userProps && applyUserPropsAfter(itemStyle, userProps);
+    itemStyle.legacy = true;
+    return itemStyle;
+  }
+  function applyUserPropsAfter(itemStyle, extra) {
+    for (var key in extra) {
+      if (hasOwn(extra, key)) {
+        itemStyle[key] = extra[key];
+      }
+    }
+  }
+  function preFetchFromExtra(extra, itemStyle) {
+    if (extra) {
+      extra.textFill && (itemStyle.textFill = extra.textFill);
+      extra.textPosition && (itemStyle.textPosition = extra.textPosition);
+    }
+  }
+  function visual(visualType, dataIndexInside) {
+    dataIndexInside == null && (dataIndexInside = currDataIndexInside);
+    if (hasOwn(STYLE_VISUAL_TYPE, visualType)) {
+      var style_1 = data.getItemVisual(dataIndexInside, "style");
+      return style_1 ? style_1[STYLE_VISUAL_TYPE[visualType]] : null;
+    }
+    if (hasOwn(NON_STYLE_VISUAL_PROPS, visualType)) {
+      return data.getItemVisual(dataIndexInside, visualType);
+    }
+  }
+  function barLayout(opt) {
+    if (coordSys.type === "cartesian2d") {
+      var baseAxis = coordSys.getBaseAxis();
+      return getLayoutOnAxis(defaults({
+        axis: baseAxis
+      }, opt));
+    }
+  }
+  function currentSeriesIndices() {
+    return ecModel.getCurrentSeriesIndices();
+  }
+  function font(opt) {
+    return getFont(opt, ecModel);
+  }
+}
+function wrapEncodeDef(data) {
+  var encodeDef = {};
+  each(data.dimensions, function(dimName) {
+    var dimInfo = data.getDimensionInfo(dimName);
+    if (!dimInfo.isExtraCoord) {
+      var coordDim = dimInfo.coordDim;
+      var dataDims = encodeDef[coordDim] = encodeDef[coordDim] || [];
+      dataDims[dimInfo.coordDimIndex] = data.getDimensionIndex(dimName);
+    }
   });
-  registers.registerSubTypeDefaulter(axisName + "Axis", getAxisType);
+  return encodeDef;
+}
+function createOrUpdateItem(api, existsEl, dataIndex, elOption, seriesModel, group, data) {
+  if (!elOption) {
+    group.remove(existsEl);
+    return;
+  }
+  var el = doCreateOrUpdateEl(api, existsEl, dataIndex, elOption, seriesModel, group);
+  el && data.setItemGraphicEl(dataIndex, el);
+  el && toggleHoverEmphasis(el, elOption.focus, elOption.blurScope, elOption.emphasisDisabled);
+  return el;
+}
+function doCreateOrUpdateEl(api, existsEl, dataIndex, elOption, seriesModel, group) {
+  if (process.env.NODE_ENV !== "production") {
+    assert(elOption, "should not have an null/undefined element setting");
+  }
+  var toBeReplacedIdx = -1;
+  var oldEl = existsEl;
+  if (existsEl && doesElNeedRecreate(existsEl, elOption, seriesModel)) {
+    toBeReplacedIdx = indexOf(group.childrenRef(), existsEl);
+    existsEl = null;
+  }
+  var isInit = !existsEl;
+  var el = existsEl;
+  if (!el) {
+    el = createEl(elOption);
+    if (oldEl) {
+      copyElement(oldEl, el);
+    }
+  } else {
+    el.clearStates();
+  }
+  if (elOption.morph === false) {
+    el.disableMorphing = true;
+  } else if (el.disableMorphing) {
+    el.disableMorphing = false;
+  }
+  attachedTxInfoTmp.normal.cfg = attachedTxInfoTmp.normal.conOpt = attachedTxInfoTmp.emphasis.cfg = attachedTxInfoTmp.emphasis.conOpt = attachedTxInfoTmp.blur.cfg = attachedTxInfoTmp.blur.conOpt = attachedTxInfoTmp.select.cfg = attachedTxInfoTmp.select.conOpt = null;
+  attachedTxInfoTmp.isLegacy = false;
+  doCreateOrUpdateAttachedTx(el, dataIndex, elOption, seriesModel, isInit, attachedTxInfoTmp);
+  doCreateOrUpdateClipPath(el, dataIndex, elOption, seriesModel, isInit);
+  updateElNormal(api, el, dataIndex, elOption, attachedTxInfoTmp, seriesModel, isInit);
+  hasOwn(elOption, "info") && (customInnerStore(el).info = elOption.info);
+  for (var i = 0; i < STATES.length; i++) {
+    var stateName = STATES[i];
+    if (stateName !== NORMAL) {
+      var otherStateOpt = retrieveStateOption(elOption, stateName);
+      var otherStyleOpt = retrieveStyleOptionOnState(elOption, otherStateOpt, stateName);
+      updateElOnState(stateName, el, otherStateOpt, otherStyleOpt, attachedTxInfoTmp);
+    }
+  }
+  updateZ(el, elOption, seriesModel);
+  if (elOption.type === "group") {
+    mergeChildren(api, el, dataIndex, elOption, seriesModel);
+  }
+  if (toBeReplacedIdx >= 0) {
+    group.replaceAt(el, toBeReplacedIdx);
+  } else {
+    group.add(el);
+  }
+  return el;
+}
+function doesElNeedRecreate(el, elOption, seriesModel) {
+  var elInner = customInnerStore(el);
+  var elOptionType = elOption.type;
+  var elOptionShape = elOption.shape;
+  var elOptionStyle = elOption.style;
+  return (
+    // Always create new if universal transition is enabled.
+    // Because we do transition after render. It needs to know what old element is. Replacement will loose it.
+    seriesModel.isUniversalTransitionEnabled() || elOptionType != null && elOptionType !== elInner.customGraphicType || elOptionType === "path" && hasOwnPathData(elOptionShape) && getPathData(elOptionShape) !== elInner.customPathData || elOptionType === "image" && hasOwn(elOptionStyle, "image") && elOptionStyle.image !== elInner.customImagePath
+  );
+}
+function doCreateOrUpdateClipPath(el, dataIndex, elOption, seriesModel, isInit) {
+  var clipPathOpt = elOption.clipPath;
+  if (clipPathOpt === false) {
+    if (el && el.getClipPath()) {
+      el.removeClipPath();
+    }
+  } else if (clipPathOpt) {
+    var clipPath = el.getClipPath();
+    if (clipPath && doesElNeedRecreate(clipPath, clipPathOpt, seriesModel)) {
+      clipPath = null;
+    }
+    if (!clipPath) {
+      clipPath = createEl(clipPathOpt);
+      if (process.env.NODE_ENV !== "production") {
+        assert(isPath(clipPath), "Only any type of `path` can be used in `clipPath`, rather than " + clipPath.type + ".");
+      }
+      el.setClipPath(clipPath);
+    }
+    updateElNormal(null, clipPath, dataIndex, clipPathOpt, null, seriesModel, isInit);
+  }
+}
+function doCreateOrUpdateAttachedTx(el, dataIndex, elOption, seriesModel, isInit, attachedTxInfo) {
+  if (el.isGroup) {
+    return;
+  }
+  processTxInfo(elOption, null, attachedTxInfo);
+  processTxInfo(elOption, EMPHASIS, attachedTxInfo);
+  var txConOptNormal = attachedTxInfo.normal.conOpt;
+  var txConOptEmphasis = attachedTxInfo.emphasis.conOpt;
+  var txConOptBlur = attachedTxInfo.blur.conOpt;
+  var txConOptSelect = attachedTxInfo.select.conOpt;
+  if (txConOptNormal != null || txConOptEmphasis != null || txConOptSelect != null || txConOptBlur != null) {
+    var textContent = el.getTextContent();
+    if (txConOptNormal === false) {
+      textContent && el.removeTextContent();
+    } else {
+      txConOptNormal = attachedTxInfo.normal.conOpt = txConOptNormal || {
+        type: "text"
+      };
+      if (!textContent) {
+        textContent = createEl(txConOptNormal);
+        el.setTextContent(textContent);
+      } else {
+        textContent.clearStates();
+      }
+      updateElNormal(null, textContent, dataIndex, txConOptNormal, null, seriesModel, isInit);
+      var txConStlOptNormal = txConOptNormal && txConOptNormal.style;
+      for (var i = 0; i < STATES.length; i++) {
+        var stateName = STATES[i];
+        if (stateName !== NORMAL) {
+          var txConOptOtherState = attachedTxInfo[stateName].conOpt;
+          updateElOnState(stateName, textContent, txConOptOtherState, retrieveStyleOptionOnState(txConOptNormal, txConOptOtherState, stateName), null);
+        }
+      }
+      txConStlOptNormal ? textContent.dirty() : textContent.markRedraw();
+    }
+  }
+}
+function processTxInfo(elOption, state, attachedTxInfo) {
+  var stateOpt = !state ? elOption : retrieveStateOption(elOption, state);
+  var styleOpt = !state ? elOption.style : retrieveStyleOptionOnState(elOption, stateOpt, EMPHASIS);
+  var elType = elOption.type;
+  var txCfg = stateOpt ? stateOpt.textConfig : null;
+  var txConOptNormal = elOption.textContent;
+  var txConOpt = !txConOptNormal ? null : !state ? txConOptNormal : retrieveStateOption(txConOptNormal, state);
+  if (styleOpt && // Because emphasis style has little info to detect legacy,
+  // if normal is legacy, emphasis is trade as legacy.
+  (attachedTxInfo.isLegacy || isEC4CompatibleStyle(styleOpt, elType, !!txCfg, !!txConOpt))) {
+    attachedTxInfo.isLegacy = true;
+    var convertResult = convertFromEC4CompatibleStyle(styleOpt, elType, !state);
+    if (!txCfg && convertResult.textConfig) {
+      txCfg = convertResult.textConfig;
+    }
+    if (!txConOpt && convertResult.textContent) {
+      txConOpt = convertResult.textContent;
+    }
+  }
+  if (!state && txConOpt) {
+    var txConOptNormal_1 = txConOpt;
+    !txConOptNormal_1.type && (txConOptNormal_1.type = "text");
+    if (process.env.NODE_ENV !== "production") {
+      assert(txConOptNormal_1.type === "text", 'textContent.type must be "text"');
+    }
+  }
+  var info = !state ? attachedTxInfo.normal : attachedTxInfo[state];
+  info.cfg = txCfg;
+  info.conOpt = txConOpt;
+}
+function retrieveStateOption(elOption, state) {
+  return !state ? elOption : elOption ? elOption[state] : null;
+}
+function retrieveStyleOptionOnState(stateOptionNormal, stateOption, state) {
+  var style = stateOption && stateOption.style;
+  if (style == null && state === EMPHASIS && stateOptionNormal) {
+    style = stateOptionNormal.styleEmphasis;
+  }
+  return style;
+}
+function mergeChildren(api, el, dataIndex, elOption, seriesModel) {
+  var newChildren = elOption.children;
+  var newLen = newChildren ? newChildren.length : 0;
+  var mergeChildren2 = elOption.$mergeChildren;
+  var byName = mergeChildren2 === "byName" || elOption.diffChildrenByName;
+  var notMerge = mergeChildren2 === false;
+  if (!newLen && !byName && !notMerge) {
+    return;
+  }
+  if (byName) {
+    diffGroupChildren({
+      api,
+      oldChildren: el.children() || [],
+      newChildren: newChildren || [],
+      dataIndex,
+      seriesModel,
+      group: el
+    });
+    return;
+  }
+  notMerge && el.removeAll();
+  var index = 0;
+  for (; index < newLen; index++) {
+    var newChild = newChildren[index];
+    var oldChild = el.childAt(index);
+    if (newChild) {
+      if (newChild.ignore == null) {
+        newChild.ignore = false;
+      }
+      doCreateOrUpdateEl(api, oldChild, dataIndex, newChild, seriesModel, el);
+    } else {
+      if (process.env.NODE_ENV !== "production") {
+        assert(oldChild, "renderItem should not return a group containing elements as null/undefined/{} if they do not exist before.");
+      }
+      oldChild.ignore = true;
+    }
+  }
+  for (var i = el.childCount() - 1; i >= index; i--) {
+    var child = el.childAt(i);
+    removeChildFromGroup(el, child, seriesModel);
+  }
+}
+function removeChildFromGroup(group, child, seriesModel) {
+  child && applyLeaveTransition(child, customInnerStore(group).option, seriesModel);
+}
+function diffGroupChildren(context) {
+  new DataDiffer(context.oldChildren, context.newChildren, getKey, getKey, context).add(processAddUpdate).update(processAddUpdate).remove(processRemove).execute();
+}
+function getKey(item, idx) {
+  var name = item && item.name;
+  return name != null ? name : GROUP_DIFF_PREFIX + idx;
+}
+function processAddUpdate(newIndex, oldIndex) {
+  var context = this.context;
+  var childOption = newIndex != null ? context.newChildren[newIndex] : null;
+  var child = oldIndex != null ? context.oldChildren[oldIndex] : null;
+  doCreateOrUpdateEl(context.api, child, context.dataIndex, childOption, context.seriesModel, context.group);
+}
+function processRemove(oldIndex) {
+  var context = this.context;
+  var child = context.oldChildren[oldIndex];
+  child && applyLeaveTransition(child, customInnerStore(child).option, context.seriesModel);
+}
+function getPathData(shape) {
+  return shape && (shape.pathData || shape.d);
 }
-function getAxisType(option) {
-  return option.type || (option.data ? "category" : "value");
+function hasOwnPathData(shape) {
+  return shape && (hasOwn(shape, "pathData") || hasOwn(shape, "d"));
 }
 export {
-  axisModelCreator as default
+  CustomChartView as default
 };