sun-card-design 1.1.33 → 1.1.34

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

@@ -1,562 +1,732 @@
-import { __extends } from "./sun-card-design-mobile.es1730.js";
-import { concatArray, defaults } from "./sun-card-design-mobile.es932.js";
-import { getECData } from "./sun-card-design-mobile.es1740.js";
-import Symbol$1 from "./sun-card-design-mobile.es2030.js";
-import { radialCoordinate } from "./sun-card-design-mobile.es2050.js";
-import { fromPoints } from "./sun-card-design-mobile.es2051.js";
-import View from "./sun-card-design-mobile.es1825.js";
-import { updateViewOnPan, updateViewOnZoom } from "./sun-card-design-mobile.es2052.js";
-import RoamController from "./sun-card-design-mobile.es2053.js";
-import { onIrrelevantElement } from "./sun-card-design-mobile.es2054.js";
-import { parsePercent } from "./sun-card-design-mobile.es1979.js";
-import ChartView from "./sun-card-design-mobile.es929.js";
-import Path from "./sun-card-design-mobile.es1763.js";
-import { HOVER_STATE_BLUR, setStatesFlag, setStatesStylesFromModel, setDefaultStateProxy } from "./sun-card-design-mobile.es1741.js";
-import Group from "./sun-card-design-mobile.es1765.js";
-import BezierCurve from "./sun-card-design-mobile.es1991.js";
-import { updateProps, removeElement } from "./sun-card-design-mobile.es1764.js";
-var TreeEdgeShape = (
-  /** @class */
-  /* @__PURE__ */ (function() {
-    function TreeEdgeShape2() {
-      this.parentPoint = [];
-      this.childPoints = [];
-    }
-    return TreeEdgeShape2;
-  })()
-);
-var TreePath = (
+import { __extends } from "./sun-card-design-mobile.es1725.js";
+import { indexOf, each, curry, extend, bind, isFunction, normalizeCssArray } from "./sun-card-design-mobile.es930.js";
+import { getECData } from "./sun-card-design-mobile.es1735.js";
+import { isHighDownDispatcher, setAsHighDownDispatcher, enableHoverFocus, setDefaultStateProxy, Z2_EMPHASIS_LIFT } from "./sun-card-design-mobile.es1736.js";
+import DataDiffer from "./sun-card-design-mobile.es1961.js";
+import { retrieveTargetInfo, aboveViewRoot } from "./sun-card-design-mobile.es2044.js";
+import Breadcrumb from "./sun-card-design-mobile.es2047.js";
+import RoamController from "./sun-card-design-mobile.es2041.js";
+import BoundingRect from "./sun-card-design-mobile.es1972.js";
+import { translate, create, scale } from "./sun-card-design-mobile.es1976.js";
+import { createWrap } from "./sun-card-design-mobile.es2048.js";
+import makeStyleMapper from "./sun-card-design-mobile.es2022.js";
+import ChartView from "./sun-card-design-mobile.es927.js";
+import Displayable from "./sun-card-design-mobile.es1962.js";
+import { makeInner, convertOptionIdName } from "./sun-card-design-mobile.es1737.js";
+import { windowOpen } from "./sun-card-design-mobile.es1922.js";
+import { setLabelStyle, getLabelStatesModels } from "./sun-card-design-mobile.es1921.js";
+import Group$1 from "./sun-card-design-mobile.es1760.js";
+import Rect$1 from "./sun-card-design-mobile.es1756.js";
+var Group = Group$1;
+var Rect = Rect$1;
+var DRAG_THRESHOLD = 3;
+var PATH_LABEL_NOAMAL = "label";
+var PATH_UPPERLABEL_NORMAL = "upperLabel";
+var Z2_BASE = Z2_EMPHASIS_LIFT * 10;
+var Z2_BG = Z2_EMPHASIS_LIFT * 2;
+var Z2_CONTENT = Z2_EMPHASIS_LIFT * 3;
+var getStateItemStyle = makeStyleMapper([
+  ["fill", "color"],
+  // `borderColor` and `borderWidth` has been occupied,
+  // so use `stroke` to indicate the stroke of the rect.
+  ["stroke", "strokeColor"],
+  ["lineWidth", "strokeWidth"],
+  ["shadowBlur"],
+  ["shadowOffsetX"],
+  ["shadowOffsetY"],
+  ["shadowColor"]
+  // Option decal is in `DecalObject` but style.decal is in `PatternObject`.
+  // So do not transfer decal directly.
+]);
+var getItemStyleNormal = function(model) {
+  var itemStyle = getStateItemStyle(model);
+  itemStyle.stroke = itemStyle.fill = itemStyle.lineWidth = null;
+  return itemStyle;
+};
+var inner = makeInner();
+var TreemapView = (
   /** @class */
   (function(_super) {
-    __extends(TreePath2, _super);
-    function TreePath2(opts) {
-      return _super.call(this, opts) || this;
+    __extends(TreemapView2, _super);
+    function TreemapView2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = TreemapView2.type;
+      _this._state = "ready";
+      _this._storage = createStorage();
+      return _this;
     }
-    TreePath2.prototype.getDefaultStyle = function() {
-      return {
-        stroke: "#000",
-        fill: null
-      };
-    };
-    TreePath2.prototype.getDefaultShape = function() {
-      return new TreeEdgeShape();
-    };
-    TreePath2.prototype.buildPath = function(ctx, shape) {
-      var childPoints = shape.childPoints;
-      var childLen = childPoints.length;
-      var parentPoint = shape.parentPoint;
-      var firstChildPos = childPoints[0];
-      var lastChildPos = childPoints[childLen - 1];
-      if (childLen === 1) {
-        ctx.moveTo(parentPoint[0], parentPoint[1]);
-        ctx.lineTo(firstChildPos[0], firstChildPos[1]);
+    TreemapView2.prototype.render = function(seriesModel, ecModel, api, payload) {
+      var models = ecModel.findComponents({
+        mainType: "series",
+        subType: "treemap",
+        query: payload
+      });
+      if (indexOf(models, seriesModel) < 0) {
         return;
       }
-      var orient = shape.orient;
-      var forkDim = orient === "TB" || orient === "BT" ? 0 : 1;
-      var otherDim = 1 - forkDim;
-      var forkPosition = parsePercent(shape.forkPosition, 1);
-      var tmpPoint = [];
-      tmpPoint[forkDim] = parentPoint[forkDim];
-      tmpPoint[otherDim] = parentPoint[otherDim] + (lastChildPos[otherDim] - parentPoint[otherDim]) * forkPosition;
-      ctx.moveTo(parentPoint[0], parentPoint[1]);
-      ctx.lineTo(tmpPoint[0], tmpPoint[1]);
-      ctx.moveTo(firstChildPos[0], firstChildPos[1]);
-      tmpPoint[forkDim] = firstChildPos[forkDim];
-      ctx.lineTo(tmpPoint[0], tmpPoint[1]);
-      tmpPoint[forkDim] = lastChildPos[forkDim];
-      ctx.lineTo(tmpPoint[0], tmpPoint[1]);
-      ctx.lineTo(lastChildPos[0], lastChildPos[1]);
-      for (var i = 1; i < childLen - 1; i++) {
-        var point = childPoints[i];
-        ctx.moveTo(point[0], point[1]);
-        tmpPoint[forkDim] = point[forkDim];
-        ctx.lineTo(tmpPoint[0], tmpPoint[1]);
-      }
+      this.seriesModel = seriesModel;
+      this.api = api;
+      this.ecModel = ecModel;
+      var types = ["treemapZoomToNode", "treemapRootToNode"];
+      var targetInfo = retrieveTargetInfo(payload, types, seriesModel);
+      var payloadType = payload && payload.type;
+      var layoutInfo = seriesModel.layoutInfo;
+      var isInit = !this._oldTree;
+      var thisStorage = this._storage;
+      var reRoot = payloadType === "treemapRootToNode" && targetInfo && thisStorage ? {
+        rootNodeGroup: thisStorage.nodeGroup[targetInfo.node.getRawIndex()],
+        direction: payload.direction
+      } : null;
+      var containerGroup = this._giveContainerGroup(layoutInfo);
+      var hasAnimation = seriesModel.get("animation");
+      var renderResult = this._doRender(containerGroup, seriesModel, reRoot);
+      hasAnimation && !isInit && (!payloadType || payloadType === "treemapZoomToNode" || payloadType === "treemapRootToNode") ? this._doAnimation(containerGroup, renderResult, seriesModel, reRoot) : renderResult.renderFinally();
+      this._resetController(api);
+      this._renderBreadcrumb(seriesModel, api, targetInfo);
     };
-    return TreePath2;
-  })(Path)
-);
-var TreeView = (
-  /** @class */
-  (function(_super) {
-    __extends(TreeView2, _super);
-    function TreeView2() {
-      var _this = _super !== null && _super.apply(this, arguments) || this;
-      _this.type = TreeView2.type;
-      _this._mainGroup = new Group();
-      return _this;
-    }
-    TreeView2.prototype.init = function(ecModel, api) {
-      this._controller = new RoamController(api.getZr());
-      this._controllerHost = {
-        target: this.group
-      };
-      this.group.add(this._mainGroup);
+    TreemapView2.prototype._giveContainerGroup = function(layoutInfo) {
+      var containerGroup = this._containerGroup;
+      if (!containerGroup) {
+        containerGroup = this._containerGroup = new Group();
+        this._initEvents(containerGroup);
+        this.group.add(containerGroup);
+      }
+      containerGroup.x = layoutInfo.x;
+      containerGroup.y = layoutInfo.y;
+      return containerGroup;
     };
-    TreeView2.prototype.render = function(seriesModel, ecModel, api) {
-      var data = seriesModel.getData();
-      var layoutInfo = seriesModel.layoutInfo;
-      var group = this._mainGroup;
-      var layout = seriesModel.get("layout");
-      if (layout === "radial") {
-        group.x = layoutInfo.x + layoutInfo.width / 2;
-        group.y = layoutInfo.y + layoutInfo.height / 2;
-      } else {
-        group.x = layoutInfo.x;
-        group.y = layoutInfo.y;
+    TreemapView2.prototype._doRender = function(containerGroup, seriesModel, reRoot) {
+      var thisTree = seriesModel.getData().tree;
+      var oldTree = this._oldTree;
+      var lastsForAnimation = createStorage();
+      var thisStorage = createStorage();
+      var oldStorage = this._storage;
+      var willInvisibleEls = [];
+      function doRenderNode(thisNode, oldNode, parentGroup, depth) {
+        return renderNode(seriesModel, thisStorage, oldStorage, reRoot, lastsForAnimation, willInvisibleEls, thisNode, oldNode, parentGroup, depth);
       }
-      this._updateViewCoordSys(seriesModel, api);
-      this._updateController(seriesModel, ecModel, api);
-      var oldData = this._data;
-      data.diff(oldData).add(function(newIdx) {
-        if (symbolNeedsDraw(data, newIdx)) {
-          updateNode(data, newIdx, null, group, seriesModel);
+      dualTravel(thisTree.root ? [thisTree.root] : [], oldTree && oldTree.root ? [oldTree.root] : [], containerGroup, thisTree === oldTree || !oldTree, 0);
+      var willDeleteEls = clearStorage(oldStorage);
+      this._oldTree = thisTree;
+      this._storage = thisStorage;
+      if (this._controllerHost) {
+        var _oldRootLayout = this.seriesModel.layoutInfo;
+        var rootLayout = thisTree.root.getLayout();
+        if (rootLayout.width === _oldRootLayout.width && rootLayout.height === _oldRootLayout.height) {
+          this._controllerHost.zoom = 1;
         }
-      }).update(function(newIdx, oldIdx) {
-        var symbolEl = oldData.getItemGraphicEl(oldIdx);
-        if (!symbolNeedsDraw(data, newIdx)) {
-          symbolEl && removeNode(oldData, oldIdx, symbolEl, group, seriesModel);
-          return;
+      }
+      return {
+        lastsForAnimation,
+        willDeleteEls,
+        renderFinally
+      };
+      function dualTravel(thisViewChildren, oldViewChildren, parentGroup, sameTree, depth) {
+        if (sameTree) {
+          oldViewChildren = thisViewChildren;
+          each(thisViewChildren, function(child, index) {
+            !child.isRemoved() && processNode(index, index);
+          });
+        } else {
+          new DataDiffer(oldViewChildren, thisViewChildren, getKey, getKey).add(processNode).update(processNode).remove(curry(processNode, null)).execute();
+        }
+        function getKey(node) {
+          return node.getId();
         }
-        updateNode(data, newIdx, symbolEl, group, seriesModel);
-      }).remove(function(oldIdx) {
-        var symbolEl = oldData.getItemGraphicEl(oldIdx);
-        if (symbolEl) {
-          removeNode(oldData, oldIdx, symbolEl, group, seriesModel);
+        function processNode(newIndex, oldIndex) {
+          var thisNode = newIndex != null ? thisViewChildren[newIndex] : null;
+          var oldNode = oldIndex != null ? oldViewChildren[oldIndex] : null;
+          var group = doRenderNode(thisNode, oldNode, parentGroup, depth);
+          group && dualTravel(thisNode && thisNode.viewChildren || [], oldNode && oldNode.viewChildren || [], group, sameTree, depth + 1);
         }
-      }).execute();
-      this._nodeScaleRatio = seriesModel.get("nodeScaleRatio");
-      this._updateNodeAndLinkScale(seriesModel);
-      if (seriesModel.get("expandAndCollapse") === true) {
-        data.eachItemGraphicEl(function(el, dataIndex) {
-          el.off("click").on("click", function() {
-            api.dispatchAction({
-              type: "treeExpandAndCollapse",
-              seriesId: seriesModel.id,
-              dataIndex
-            });
+      }
+      function clearStorage(storage) {
+        var willDeleteEls2 = createStorage();
+        storage && each(storage, function(store, storageName) {
+          var delEls = willDeleteEls2[storageName];
+          each(store, function(el) {
+            el && (delEls.push(el), inner(el).willDelete = true);
           });
         });
+        return willDeleteEls2;
       }
-      this._data = data;
-    };
-    TreeView2.prototype._updateViewCoordSys = function(seriesModel, api) {
-      var data = seriesModel.getData();
-      var points = [];
-      data.each(function(idx) {
-        var layout = data.getItemLayout(idx);
-        if (layout && !isNaN(layout.x) && !isNaN(layout.y)) {
-          points.push([+layout.x, +layout.y]);
-        }
-      });
-      var min = [];
-      var max = [];
-      fromPoints(points, min, max);
-      var oldMin = this._min;
-      var oldMax = this._max;
-      if (max[0] - min[0] === 0) {
-        min[0] = oldMin ? oldMin[0] : min[0] - 1;
-        max[0] = oldMax ? oldMax[0] : max[0] + 1;
-      }
-      if (max[1] - min[1] === 0) {
-        min[1] = oldMin ? oldMin[1] : min[1] - 1;
-        max[1] = oldMax ? oldMax[1] : max[1] + 1;
+      function renderFinally() {
+        each(willDeleteEls, function(els) {
+          each(els, function(el) {
+            el.parent && el.parent.remove(el);
+          });
+        });
+        each(willInvisibleEls, function(el) {
+          el.invisible = true;
+          el.dirty();
+        });
       }
-      var viewCoordSys = seriesModel.coordinateSystem = new View();
-      viewCoordSys.zoomLimit = seriesModel.get("scaleLimit");
-      viewCoordSys.setBoundingRect(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-      viewCoordSys.setCenter(seriesModel.get("center"), api);
-      viewCoordSys.setZoom(seriesModel.get("zoom"));
-      this.group.attr({
-        x: viewCoordSys.x,
-        y: viewCoordSys.y,
-        scaleX: viewCoordSys.scaleX,
-        scaleY: viewCoordSys.scaleY
+    };
+    TreemapView2.prototype._doAnimation = function(containerGroup, renderResult, seriesModel, reRoot) {
+      var durationOption = seriesModel.get("animationDurationUpdate");
+      var easingOption = seriesModel.get("animationEasing");
+      var duration = (isFunction(durationOption) ? 0 : durationOption) || 0;
+      var easing = (isFunction(easingOption) ? null : easingOption) || "cubicOut";
+      var animationWrap = createWrap();
+      each(renderResult.willDeleteEls, function(store, storageName) {
+        each(store, function(el, rawIndex) {
+          if (el.invisible) {
+            return;
+          }
+          var parent = el.parent;
+          var target;
+          var innerStore = inner(parent);
+          if (reRoot && reRoot.direction === "drillDown") {
+            target = parent === reRoot.rootNodeGroup ? {
+              shape: {
+                x: 0,
+                y: 0,
+                width: innerStore.nodeWidth,
+                height: innerStore.nodeHeight
+              },
+              style: {
+                opacity: 0
+              }
+            } : {
+              style: {
+                opacity: 0
+              }
+            };
+          } else {
+            var targetX = 0;
+            var targetY = 0;
+            if (!innerStore.willDelete) {
+              targetX = innerStore.nodeWidth / 2;
+              targetY = innerStore.nodeHeight / 2;
+            }
+            target = storageName === "nodeGroup" ? {
+              x: targetX,
+              y: targetY,
+              style: {
+                opacity: 0
+              }
+            } : {
+              shape: {
+                x: targetX,
+                y: targetY,
+                width: 0,
+                height: 0
+              },
+              style: {
+                opacity: 0
+              }
+            };
+          }
+          target && animationWrap.add(el, target, duration, 0, easing);
+        });
       });
-      this._min = min;
-      this._max = max;
+      each(this._storage, function(store, storageName) {
+        each(store, function(el, rawIndex) {
+          var last = renderResult.lastsForAnimation[storageName][rawIndex];
+          var target = {};
+          if (!last) {
+            return;
+          }
+          if (el instanceof Group$1) {
+            if (last.oldX != null) {
+              target.x = el.x;
+              target.y = el.y;
+              el.x = last.oldX;
+              el.y = last.oldY;
+            }
+          } else {
+            if (last.oldShape) {
+              target.shape = extend({}, el.shape);
+              el.setShape(last.oldShape);
+            }
+            if (last.fadein) {
+              el.setStyle("opacity", 0);
+              target.style = {
+                opacity: 1
+              };
+            } else if (el.style.opacity !== 1) {
+              target.style = {
+                opacity: 1
+              };
+            }
+          }
+          animationWrap.add(el, target, duration, 0, easing);
+        });
+      }, this);
+      this._state = "animating";
+      animationWrap.finished(bind(function() {
+        this._state = "ready";
+        renderResult.renderFinally();
+      }, this)).start();
     };
-    TreeView2.prototype._updateController = function(seriesModel, ecModel, api) {
-      var _this = this;
+    TreemapView2.prototype._resetController = function(api) {
       var controller = this._controller;
       var controllerHost = this._controllerHost;
-      var group = this.group;
+      if (!controllerHost) {
+        this._controllerHost = {
+          target: this.group
+        };
+        controllerHost = this._controllerHost;
+      }
+      if (!controller) {
+        controller = this._controller = new RoamController(api.getZr());
+        controller.enable(this.seriesModel.get("roam"));
+        controllerHost.zoomLimit = this.seriesModel.get("scaleLimit");
+        controllerHost.zoom = this.seriesModel.get("zoom");
+        controller.on("pan", bind(this._onPan, this));
+        controller.on("zoom", bind(this._onZoom, this));
+      }
+      var rect = new BoundingRect(0, 0, api.getWidth(), api.getHeight());
       controller.setPointerChecker(function(e, x, y) {
-        var rect = group.getBoundingRect();
-        rect.applyTransform(group.transform);
-        return rect.contain(x, y) && !onIrrelevantElement(e, api, seriesModel);
+        return rect.contain(x, y);
       });
-      controller.enable(seriesModel.get("roam"));
-      controllerHost.zoomLimit = seriesModel.get("scaleLimit");
-      controllerHost.zoom = seriesModel.coordinateSystem.getZoom();
-      controller.off("pan").off("zoom").on("pan", function(e) {
-        updateViewOnPan(controllerHost, e.dx, e.dy);
-        api.dispatchAction({
-          seriesId: seriesModel.id,
-          type: "treeRoam",
-          dx: e.dx,
-          dy: e.dy
+    };
+    TreemapView2.prototype._clearController = function() {
+      var controller = this._controller;
+      this._controllerHost = null;
+      if (controller) {
+        controller.dispose();
+        controller = null;
+      }
+    };
+    TreemapView2.prototype._onPan = function(e) {
+      if (this._state !== "animating" && (Math.abs(e.dx) > DRAG_THRESHOLD || Math.abs(e.dy) > DRAG_THRESHOLD)) {
+        var root = this.seriesModel.getData().tree.root;
+        if (!root) {
+          return;
+        }
+        var rootLayout = root.getLayout();
+        if (!rootLayout) {
+          return;
+        }
+        this.api.dispatchAction({
+          type: "treemapMove",
+          from: this.uid,
+          seriesId: this.seriesModel.id,
+          rootRect: {
+            x: rootLayout.x + e.dx,
+            y: rootLayout.y + e.dy,
+            width: rootLayout.width,
+            height: rootLayout.height
+          }
         });
-      }).on("zoom", function(e) {
-        updateViewOnZoom(controllerHost, e.scale, e.originX, e.originY);
-        api.dispatchAction({
-          seriesId: seriesModel.id,
-          type: "treeRoam",
-          zoom: e.scale,
-          originX: e.originX,
-          originY: e.originY
+      }
+    };
+    TreemapView2.prototype._onZoom = function(e) {
+      var mouseX = e.originX;
+      var mouseY = e.originY;
+      var zoomDelta = e.scale;
+      if (this._state !== "animating") {
+        var root = this.seriesModel.getData().tree.root;
+        if (!root) {
+          return;
+        }
+        var rootLayout = root.getLayout();
+        if (!rootLayout) {
+          return;
+        }
+        var rect = new BoundingRect(rootLayout.x, rootLayout.y, rootLayout.width, rootLayout.height);
+        var zoomLimit = null;
+        var _controllerHost = this._controllerHost;
+        zoomLimit = _controllerHost.zoomLimit;
+        var newZoom = _controllerHost.zoom = _controllerHost.zoom || 1;
+        newZoom *= zoomDelta;
+        if (zoomLimit) {
+          var zoomMin = zoomLimit.min || 0;
+          var zoomMax = zoomLimit.max || Infinity;
+          newZoom = Math.max(Math.min(zoomMax, newZoom), zoomMin);
+        }
+        var zoomScale = newZoom / _controllerHost.zoom;
+        _controllerHost.zoom = newZoom;
+        var layoutInfo = this.seriesModel.layoutInfo;
+        mouseX -= layoutInfo.x;
+        mouseY -= layoutInfo.y;
+        var m = create();
+        translate(m, m, [-mouseX, -mouseY]);
+        scale(m, m, [zoomScale, zoomScale]);
+        translate(m, m, [mouseX, mouseY]);
+        rect.applyTransform(m);
+        this.api.dispatchAction({
+          type: "treemapRender",
+          from: this.uid,
+          seriesId: this.seriesModel.id,
+          rootRect: {
+            x: rect.x,
+            y: rect.y,
+            width: rect.width,
+            height: rect.height
+          }
         });
-        _this._updateNodeAndLinkScale(seriesModel);
-        api.updateLabelLayout();
-      });
+      }
     };
-    TreeView2.prototype._updateNodeAndLinkScale = function(seriesModel) {
-      var data = seriesModel.getData();
-      var nodeScale = this._getNodeGlobalScale(seriesModel);
-      data.eachItemGraphicEl(function(el, idx) {
-        el.setSymbolScale(nodeScale);
-      });
+    TreemapView2.prototype._initEvents = function(containerGroup) {
+      var _this = this;
+      containerGroup.on("click", function(e) {
+        if (_this._state !== "ready") {
+          return;
+        }
+        var nodeClick = _this.seriesModel.get("nodeClick", true);
+        if (!nodeClick) {
+          return;
+        }
+        var targetInfo = _this.findTarget(e.offsetX, e.offsetY);
+        if (!targetInfo) {
+          return;
+        }
+        var node = targetInfo.node;
+        if (node.getLayout().isLeafRoot) {
+          _this._rootToNode(targetInfo);
+        } else {
+          if (nodeClick === "zoomToNode") {
+            _this._zoomToNode(targetInfo);
+          } else if (nodeClick === "link") {
+            var itemModel = node.hostTree.data.getItemModel(node.dataIndex);
+            var link = itemModel.get("link", true);
+            var linkTarget = itemModel.get("target", true) || "blank";
+            link && windowOpen(link, linkTarget);
+          }
+        }
+      }, this);
     };
-    TreeView2.prototype._getNodeGlobalScale = function(seriesModel) {
-      var coordSys = seriesModel.coordinateSystem;
-      if (coordSys.type !== "view") {
-        return 1;
+    TreemapView2.prototype._renderBreadcrumb = function(seriesModel, api, targetInfo) {
+      var _this = this;
+      if (!targetInfo) {
+        targetInfo = seriesModel.get("leafDepth", true) != null ? {
+          node: seriesModel.getViewRoot()
+        } : this.findTarget(api.getWidth() / 2, api.getHeight() / 2);
+        if (!targetInfo) {
+          targetInfo = {
+            node: seriesModel.getData().tree.root
+          };
+        }
       }
-      var nodeScaleRatio = this._nodeScaleRatio;
-      var groupZoom = coordSys.scaleX || 1;
-      var roamZoom = coordSys.getZoom();
-      var nodeScale = (roamZoom - 1) * nodeScaleRatio + 1;
-      return nodeScale / groupZoom;
+      (this._breadcrumb || (this._breadcrumb = new Breadcrumb(this.group))).render(seriesModel, api, targetInfo.node, function(node) {
+        if (_this._state !== "animating") {
+          aboveViewRoot(seriesModel.getViewRoot(), node) ? _this._rootToNode({
+            node
+          }) : _this._zoomToNode({
+            node
+          });
+        }
+      });
     };
-    TreeView2.prototype.dispose = function() {
-      this._controller && this._controller.dispose();
-      this._controllerHost = null;
+    TreemapView2.prototype.remove = function() {
+      this._clearController();
+      this._containerGroup && this._containerGroup.removeAll();
+      this._storage = createStorage();
+      this._state = "ready";
+      this._breadcrumb && this._breadcrumb.remove();
     };
-    TreeView2.prototype.remove = function() {
-      this._mainGroup.removeAll();
-      this._data = null;
+    TreemapView2.prototype.dispose = function() {
+      this._clearController();
     };
-    TreeView2.type = "tree";
-    return TreeView2;
+    TreemapView2.prototype._zoomToNode = function(targetInfo) {
+      this.api.dispatchAction({
+        type: "treemapZoomToNode",
+        from: this.uid,
+        seriesId: this.seriesModel.id,
+        targetNode: targetInfo.node
+      });
+    };
+    TreemapView2.prototype._rootToNode = function(targetInfo) {
+      this.api.dispatchAction({
+        type: "treemapRootToNode",
+        from: this.uid,
+        seriesId: this.seriesModel.id,
+        targetNode: targetInfo.node
+      });
+    };
+    TreemapView2.prototype.findTarget = function(x, y) {
+      var targetInfo;
+      var viewRoot = this.seriesModel.getViewRoot();
+      viewRoot.eachNode({
+        attr: "viewChildren",
+        order: "preorder"
+      }, function(node) {
+        var bgEl = this._storage.background[node.getRawIndex()];
+        if (bgEl) {
+          var point = bgEl.transformCoordToLocal(x, y);
+          var shape = bgEl.shape;
+          if (shape.x <= point[0] && point[0] <= shape.x + shape.width && shape.y <= point[1] && point[1] <= shape.y + shape.height) {
+            targetInfo = {
+              node,
+              offsetX: point[0],
+              offsetY: point[1]
+            };
+          } else {
+            return false;
+          }
+        }
+      }, this);
+      return targetInfo;
+    };
+    TreemapView2.type = "treemap";
+    return TreemapView2;
   })(ChartView)
 );
-function symbolNeedsDraw(data, dataIndex) {
-  var layout = data.getItemLayout(dataIndex);
-  return layout && !isNaN(layout.x) && !isNaN(layout.y);
+function createStorage() {
+  return {
+    nodeGroup: [],
+    background: [],
+    content: []
+  };
 }
-function updateNode(data, dataIndex, symbolEl, group, seriesModel) {
-  var isInit = !symbolEl;
-  var node = data.tree.getNodeByDataIndex(dataIndex);
-  var itemModel = node.getModel();
-  var visualColor = node.getVisual("style").fill;
-  var symbolInnerColor = node.isExpand === false && node.children.length !== 0 ? visualColor : "#fff";
-  var virtualRoot = data.tree.root;
-  var source = node.parentNode === virtualRoot ? node : node.parentNode || node;
-  var sourceSymbolEl = data.getItemGraphicEl(source.dataIndex);
-  var sourceLayout = source.getLayout();
-  var sourceOldLayout = sourceSymbolEl ? {
-    x: sourceSymbolEl.__oldX,
-    y: sourceSymbolEl.__oldY,
-    rawX: sourceSymbolEl.__radialOldRawX,
-    rawY: sourceSymbolEl.__radialOldRawY
-  } : sourceLayout;
-  var targetLayout = node.getLayout();
-  if (isInit) {
-    symbolEl = new Symbol$1(data, dataIndex, null, {
-      symbolInnerColor,
-      useNameLabel: true
-    });
-    symbolEl.x = sourceOldLayout.x;
-    symbolEl.y = sourceOldLayout.y;
+function renderNode(seriesModel, thisStorage, oldStorage, reRoot, lastsForAnimation, willInvisibleEls, thisNode, oldNode, parentGroup, depth) {
+  if (!thisNode) {
+    return;
+  }
+  var thisLayout = thisNode.getLayout();
+  var data = seriesModel.getData();
+  var nodeModel = thisNode.getModel();
+  data.setItemGraphicEl(thisNode.dataIndex, null);
+  if (!thisLayout || !thisLayout.isInView) {
+    return;
+  }
+  var thisWidth = thisLayout.width;
+  var thisHeight = thisLayout.height;
+  var borderWidth = thisLayout.borderWidth;
+  var thisInvisible = thisLayout.invisible;
+  var thisRawIndex = thisNode.getRawIndex();
+  var oldRawIndex = oldNode && oldNode.getRawIndex();
+  var thisViewChildren = thisNode.viewChildren;
+  var upperHeight = thisLayout.upperHeight;
+  var isParent = thisViewChildren && thisViewChildren.length;
+  var itemStyleNormalModel = nodeModel.getModel("itemStyle");
+  var itemStyleEmphasisModel = nodeModel.getModel(["emphasis", "itemStyle"]);
+  var itemStyleBlurModel = nodeModel.getModel(["blur", "itemStyle"]);
+  var itemStyleSelectModel = nodeModel.getModel(["select", "itemStyle"]);
+  var borderRadius = itemStyleNormalModel.get("borderRadius") || 0;
+  var group = giveGraphic("nodeGroup", Group);
+  if (!group) {
+    return;
+  }
+  parentGroup.add(group);
+  group.x = thisLayout.x || 0;
+  group.y = thisLayout.y || 0;
+  group.markRedraw();
+  inner(group).nodeWidth = thisWidth;
+  inner(group).nodeHeight = thisHeight;
+  if (thisLayout.isAboveViewRoot) {
+    return group;
+  }
+  var bg = giveGraphic("background", Rect, depth, Z2_BG);
+  bg && renderBackground(group, bg, isParent && thisLayout.upperLabelHeight);
+  var emphasisModel = nodeModel.getModel("emphasis");
+  var focus = emphasisModel.get("focus");
+  var blurScope = emphasisModel.get("blurScope");
+  var isDisabled = emphasisModel.get("disabled");
+  var focusOrIndices = focus === "ancestor" ? thisNode.getAncestorsIndices() : focus === "descendant" ? thisNode.getDescendantIndices() : focus;
+  if (isParent) {
+    if (isHighDownDispatcher(group)) {
+      setAsHighDownDispatcher(group, false);
+    }
+    if (bg) {
+      setAsHighDownDispatcher(bg, !isDisabled);
+      data.setItemGraphicEl(thisNode.dataIndex, bg);
+      enableHoverFocus(bg, focusOrIndices, blurScope);
+    }
   } else {
-    symbolEl.updateData(data, dataIndex, null, {
-      symbolInnerColor,
-      useNameLabel: true
-    });
+    var content = giveGraphic("content", Rect, depth, Z2_CONTENT);
+    content && renderContent(group, content);
+    bg.disableMorphing = true;
+    if (bg && isHighDownDispatcher(bg)) {
+      setAsHighDownDispatcher(bg, false);
+    }
+    setAsHighDownDispatcher(group, !isDisabled);
+    data.setItemGraphicEl(thisNode.dataIndex, group);
+    var cursorStyle = nodeModel.getShallow("cursor");
+    cursorStyle && content.attr("cursor", cursorStyle);
+    enableHoverFocus(group, focusOrIndices, blurScope);
   }
-  symbolEl.__radialOldRawX = symbolEl.__radialRawX;
-  symbolEl.__radialOldRawY = symbolEl.__radialRawY;
-  symbolEl.__radialRawX = targetLayout.rawX;
-  symbolEl.__radialRawY = targetLayout.rawY;
-  group.add(symbolEl);
-  data.setItemGraphicEl(dataIndex, symbolEl);
-  symbolEl.__oldX = symbolEl.x;
-  symbolEl.__oldY = symbolEl.y;
-  updateProps(symbolEl, {
-    x: targetLayout.x,
-    y: targetLayout.y
-  }, seriesModel);
-  var symbolPath = symbolEl.getSymbolPath();
-  if (seriesModel.get("layout") === "radial") {
-    var realRoot = virtualRoot.children[0];
-    var rootLayout = realRoot.getLayout();
-    var length_1 = realRoot.children.length;
-    var rad = void 0;
-    var isLeft = void 0;
-    if (targetLayout.x === rootLayout.x && node.isExpand === true && realRoot.children.length) {
-      var center = {
-        x: (realRoot.children[0].getLayout().x + realRoot.children[length_1 - 1].getLayout().x) / 2,
-        y: (realRoot.children[0].getLayout().y + realRoot.children[length_1 - 1].getLayout().y) / 2
-      };
-      rad = Math.atan2(center.y - rootLayout.y, center.x - rootLayout.x);
-      if (rad < 0) {
-        rad = Math.PI * 2 + rad;
-      }
-      isLeft = center.x < rootLayout.x;
-      if (isLeft) {
-        rad = rad - Math.PI;
-      }
+  return group;
+  function renderBackground(group2, bg2, useUpperLabel) {
+    var ecData = getECData(bg2);
+    ecData.dataIndex = thisNode.dataIndex;
+    ecData.seriesIndex = seriesModel.seriesIndex;
+    bg2.setShape({
+      x: 0,
+      y: 0,
+      width: thisWidth,
+      height: thisHeight,
+      r: borderRadius
+    });
+    if (thisInvisible) {
+      processInvisible(bg2);
     } else {
-      rad = Math.atan2(targetLayout.y - rootLayout.y, targetLayout.x - rootLayout.x);
-      if (rad < 0) {
-        rad = Math.PI * 2 + rad;
-      }
-      if (node.children.length === 0 || node.children.length !== 0 && node.isExpand === false) {
-        isLeft = targetLayout.x < rootLayout.x;
-        if (isLeft) {
-          rad = rad - Math.PI;
-        }
+      bg2.invisible = false;
+      var style = thisNode.getVisual("style");
+      var visualBorderColor = style.stroke;
+      var normalStyle = getItemStyleNormal(itemStyleNormalModel);
+      normalStyle.fill = visualBorderColor;
+      var emphasisStyle = getStateItemStyle(itemStyleEmphasisModel);
+      emphasisStyle.fill = itemStyleEmphasisModel.get("borderColor");
+      var blurStyle = getStateItemStyle(itemStyleBlurModel);
+      blurStyle.fill = itemStyleBlurModel.get("borderColor");
+      var selectStyle = getStateItemStyle(itemStyleSelectModel);
+      selectStyle.fill = itemStyleSelectModel.get("borderColor");
+      if (useUpperLabel) {
+        var upperLabelWidth = thisWidth - 2 * borderWidth;
+        prepareText(
+          // PENDING: convert ZRColor to ColorString for text.
+          bg2,
+          visualBorderColor,
+          style.opacity,
+          {
+            x: borderWidth,
+            y: 0,
+            width: upperLabelWidth,
+            height: upperHeight
+          }
+        );
       } else {
-        isLeft = targetLayout.x > rootLayout.x;
-        if (!isLeft) {
-          rad = rad - Math.PI;
-        }
+        bg2.removeTextContent();
       }
+      bg2.setStyle(normalStyle);
+      bg2.ensureState("emphasis").style = emphasisStyle;
+      bg2.ensureState("blur").style = blurStyle;
+      bg2.ensureState("select").style = selectStyle;
+      setDefaultStateProxy(bg2);
     }
-    var textPosition = isLeft ? "left" : "right";
-    var normalLabelModel = itemModel.getModel("label");
-    var rotate = normalLabelModel.get("rotate");
-    var labelRotateRadian = rotate * (Math.PI / 180);
-    var textContent = symbolPath.getTextContent();
-    if (textContent) {
-      symbolPath.setTextConfig({
-        position: normalLabelModel.get("position") || textPosition,
-        rotation: rotate == null ? -rad : labelRotateRadian,
-        origin: "center"
-      });
-      textContent.setStyle("verticalAlign", "middle");
+    group2.add(bg2);
+  }
+  function renderContent(group2, content2) {
+    var ecData = getECData(content2);
+    ecData.dataIndex = thisNode.dataIndex;
+    ecData.seriesIndex = seriesModel.seriesIndex;
+    var contentWidth = Math.max(thisWidth - 2 * borderWidth, 0);
+    var contentHeight = Math.max(thisHeight - 2 * borderWidth, 0);
+    content2.culling = true;
+    content2.setShape({
+      x: borderWidth,
+      y: borderWidth,
+      width: contentWidth,
+      height: contentHeight,
+      r: borderRadius
+    });
+    if (thisInvisible) {
+      processInvisible(content2);
+    } else {
+      content2.invisible = false;
+      var nodeStyle = thisNode.getVisual("style");
+      var visualColor = nodeStyle.fill;
+      var normalStyle = getItemStyleNormal(itemStyleNormalModel);
+      normalStyle.fill = visualColor;
+      normalStyle.decal = nodeStyle.decal;
+      var emphasisStyle = getStateItemStyle(itemStyleEmphasisModel);
+      var blurStyle = getStateItemStyle(itemStyleBlurModel);
+      var selectStyle = getStateItemStyle(itemStyleSelectModel);
+      prepareText(content2, visualColor, nodeStyle.opacity, null);
+      content2.setStyle(normalStyle);
+      content2.ensureState("emphasis").style = emphasisStyle;
+      content2.ensureState("blur").style = blurStyle;
+      content2.ensureState("select").style = selectStyle;
+      setDefaultStateProxy(content2);
     }
+    group2.add(content2);
   }
-  var focus = itemModel.get(["emphasis", "focus"]);
-  var focusDataIndices = focus === "relative" ? concatArray(node.getAncestorsIndices(), node.getDescendantIndices()) : focus === "ancestor" ? node.getAncestorsIndices() : focus === "descendant" ? node.getDescendantIndices() : null;
-  if (focusDataIndices) {
-    getECData(symbolEl).focus = focusDataIndices;
+  function processInvisible(element) {
+    !element.invisible && willInvisibleEls.push(element);
   }
-  drawEdge(seriesModel, node, virtualRoot, symbolEl, sourceOldLayout, sourceLayout, targetLayout, group);
-  if (symbolEl.__edge) {
-    symbolEl.onHoverStateChange = function(toState) {
-      if (toState !== "blur") {
-        var parentEl = node.parentNode && data.getItemGraphicEl(node.parentNode.dataIndex);
-        if (!(parentEl && parentEl.hoverState === HOVER_STATE_BLUR)) {
-          setStatesFlag(symbolEl.__edge, toState);
-        }
+  function prepareText(rectEl, visualColor, visualOpacity, upperLabelRect) {
+    var normalLabelModel = nodeModel.getModel(upperLabelRect ? PATH_UPPERLABEL_NORMAL : PATH_LABEL_NOAMAL);
+    var defaultText = convertOptionIdName(nodeModel.get("name"), null);
+    var isShow = normalLabelModel.getShallow("show");
+    setLabelStyle(rectEl, getLabelStatesModels(nodeModel, upperLabelRect ? PATH_UPPERLABEL_NORMAL : PATH_LABEL_NOAMAL), {
+      defaultText: isShow ? defaultText : null,
+      inheritColor: visualColor,
+      defaultOpacity: visualOpacity,
+      labelFetcher: seriesModel,
+      labelDataIndex: thisNode.dataIndex
+    });
+    var textEl = rectEl.getTextContent();
+    if (!textEl) {
+      return;
+    }
+    var textStyle = textEl.style;
+    var textPadding = normalizeCssArray(textStyle.padding || 0);
+    if (upperLabelRect) {
+      rectEl.setTextConfig({
+        layoutRect: upperLabelRect
+      });
+      textEl.disableLabelLayout = true;
+    }
+    textEl.beforeUpdate = function() {
+      var width = Math.max((upperLabelRect ? upperLabelRect.width : rectEl.shape.width) - textPadding[1] - textPadding[3], 0);
+      var height = Math.max((upperLabelRect ? upperLabelRect.height : rectEl.shape.height) - textPadding[0] - textPadding[2], 0);
+      if (textStyle.width !== width || textStyle.height !== height) {
+        textEl.setStyle({
+          width,
+          height
+        });
       }
     };
+    textStyle.truncateMinChar = 2;
+    textStyle.lineOverflow = "truncate";
+    addDrillDownIcon(textStyle, upperLabelRect, thisLayout);
+    var textEmphasisState = textEl.getState("emphasis");
+    addDrillDownIcon(textEmphasisState ? textEmphasisState.style : null, upperLabelRect, thisLayout);
   }
-}
-function drawEdge(seriesModel, node, virtualRoot, symbolEl, sourceOldLayout, sourceLayout, targetLayout, group) {
-  var itemModel = node.getModel();
-  var edgeShape = seriesModel.get("edgeShape");
-  var layout = seriesModel.get("layout");
-  var orient = seriesModel.getOrient();
-  var curvature = seriesModel.get(["lineStyle", "curveness"]);
-  var edgeForkPosition = seriesModel.get("edgeForkPosition");
-  var lineStyle = itemModel.getModel("lineStyle").getLineStyle();
-  var edge = symbolEl.__edge;
-  if (edgeShape === "curve") {
-    if (node.parentNode && node.parentNode !== virtualRoot) {
-      if (!edge) {
-        edge = symbolEl.__edge = new BezierCurve({
-          shape: getEdgeShape(layout, orient, curvature, sourceOldLayout, sourceOldLayout)
-        });
-      }
-      updateProps(edge, {
-        shape: getEdgeShape(layout, orient, curvature, sourceLayout, targetLayout)
-      }, seriesModel);
+  function addDrillDownIcon(style, upperLabelRect, thisLayout2) {
+    var text = style ? style.text : null;
+    if (!upperLabelRect && thisLayout2.isLeafRoot && text != null) {
+      var iconChar = seriesModel.get("drillDownIcon", true);
+      style.text = iconChar ? iconChar + " " + text : text;
     }
-  } else if (edgeShape === "polyline") {
-    if (layout === "orthogonal") {
-      if (node !== virtualRoot && node.children && node.children.length !== 0 && node.isExpand === true) {
-        var children = node.children;
-        var childPoints = [];
-        for (var i = 0; i < children.length; i++) {
-          var childLayout = children[i].getLayout();
-          childPoints.push([childLayout.x, childLayout.y]);
-        }
-        if (!edge) {
-          edge = symbolEl.__edge = new TreePath({
-            shape: {
-              parentPoint: [targetLayout.x, targetLayout.y],
-              childPoints: [[targetLayout.x, targetLayout.y]],
-              orient,
-              forkPosition: edgeForkPosition
-            }
-          });
-        }
-        updateProps(edge, {
-          shape: {
-            parentPoint: [targetLayout.x, targetLayout.y],
-            childPoints
-          }
-        }, seriesModel);
-      }
-    } else {
-      if (process.env.NODE_ENV !== "production") {
-        throw new Error("The polyline edgeShape can only be used in orthogonal layout");
+  }
+  function giveGraphic(storageName, Ctor, depth2, z) {
+    var element = oldRawIndex != null && oldStorage[storageName][oldRawIndex];
+    var lasts = lastsForAnimation[storageName];
+    if (element) {
+      oldStorage[storageName][oldRawIndex] = null;
+      prepareAnimationWhenHasOld(lasts, element);
+    } else if (!thisInvisible) {
+      element = new Ctor();
+      if (element instanceof Displayable) {
+        element.z2 = calculateZ2(depth2, z);
       }
+      prepareAnimationWhenNoOld(lasts, element);
     }
+    return thisStorage[storageName][thisRawIndex] = element;
   }
-  if (edge && !(edgeShape === "polyline" && !node.isExpand)) {
-    edge.useStyle(defaults({
-      strokeNoScale: true,
-      fill: null
-    }, lineStyle));
-    setStatesStylesFromModel(edge, itemModel, "lineStyle");
-    setDefaultStateProxy(edge);
-    group.add(edge);
-  }
-}
-function removeNodeEdge(node, data, group, seriesModel, removeAnimationOpt) {
-  var virtualRoot = data.tree.root;
-  var _a = getSourceNode(virtualRoot, node), source = _a.source, sourceLayout = _a.sourceLayout;
-  var symbolEl = data.getItemGraphicEl(node.dataIndex);
-  if (!symbolEl) {
-    return;
-  }
-  var sourceSymbolEl = data.getItemGraphicEl(source.dataIndex);
-  var sourceEdge = sourceSymbolEl.__edge;
-  var edge = symbolEl.__edge || (source.isExpand === false || source.children.length === 1 ? sourceEdge : void 0);
-  var edgeShape = seriesModel.get("edgeShape");
-  var layoutOpt = seriesModel.get("layout");
-  var orient = seriesModel.get("orient");
-  var curvature = seriesModel.get(["lineStyle", "curveness"]);
-  if (edge) {
-    if (edgeShape === "curve") {
-      removeElement(edge, {
-        shape: getEdgeShape(layoutOpt, orient, curvature, sourceLayout, sourceLayout),
-        style: {
-          opacity: 0
-        }
-      }, seriesModel, {
-        cb: function() {
-          group.remove(edge);
-        },
-        removeOpt: removeAnimationOpt
-      });
-    } else if (edgeShape === "polyline" && seriesModel.get("layout") === "orthogonal") {
-      removeElement(edge, {
-        shape: {
-          parentPoint: [sourceLayout.x, sourceLayout.y],
-          childPoints: [[sourceLayout.x, sourceLayout.y]]
-        },
-        style: {
-          opacity: 0
-        }
-      }, seriesModel, {
-        cb: function() {
-          group.remove(edge);
-        },
-        removeOpt: removeAnimationOpt
-      });
+  function prepareAnimationWhenHasOld(lasts, element) {
+    var lastCfg = lasts[thisRawIndex] = {};
+    if (element instanceof Group) {
+      lastCfg.oldX = element.x;
+      lastCfg.oldY = element.y;
+    } else {
+      lastCfg.oldShape = extend({}, element.shape);
     }
   }
-}
-function getSourceNode(virtualRoot, node) {
-  var source = node.parentNode === virtualRoot ? node : node.parentNode || node;
-  var sourceLayout;
-  while (sourceLayout = source.getLayout(), sourceLayout == null) {
-    source = source.parentNode === virtualRoot ? source : source.parentNode || source;
-  }
-  return {
-    source,
-    sourceLayout
-  };
-}
-function removeNode(data, dataIndex, symbolEl, group, seriesModel) {
-  var node = data.tree.getNodeByDataIndex(dataIndex);
-  var virtualRoot = data.tree.root;
-  var sourceLayout = getSourceNode(virtualRoot, node).sourceLayout;
-  var removeAnimationOpt = {
-    duration: seriesModel.get("animationDurationUpdate"),
-    easing: seriesModel.get("animationEasingUpdate")
-  };
-  removeElement(symbolEl, {
-    x: sourceLayout.x + 1,
-    y: sourceLayout.y + 1
-  }, seriesModel, {
-    cb: function() {
-      group.remove(symbolEl);
-      data.setItemGraphicEl(dataIndex, null);
-    },
-    removeOpt: removeAnimationOpt
-  });
-  symbolEl.fadeOut(null, data.hostModel, {
-    fadeLabel: true,
-    animation: removeAnimationOpt
-  });
-  node.children.forEach(function(childNode) {
-    removeNodeEdge(childNode, data, group, seriesModel, removeAnimationOpt);
-  });
-  removeNodeEdge(node, data, group, seriesModel, removeAnimationOpt);
-}
-function getEdgeShape(layoutOpt, orient, curvature, sourceLayout, targetLayout) {
-  var cpx1;
-  var cpy1;
-  var cpx2;
-  var cpy2;
-  var x1;
-  var x2;
-  var y1;
-  var y2;
-  if (layoutOpt === "radial") {
-    x1 = sourceLayout.rawX;
-    y1 = sourceLayout.rawY;
-    x2 = targetLayout.rawX;
-    y2 = targetLayout.rawY;
-    var radialCoor1 = radialCoordinate(x1, y1);
-    var radialCoor2 = radialCoordinate(x1, y1 + (y2 - y1) * curvature);
-    var radialCoor3 = radialCoordinate(x2, y2 + (y1 - y2) * curvature);
-    var radialCoor4 = radialCoordinate(x2, y2);
-    return {
-      x1: radialCoor1.x || 0,
-      y1: radialCoor1.y || 0,
-      x2: radialCoor4.x || 0,
-      y2: radialCoor4.y || 0,
-      cpx1: radialCoor2.x || 0,
-      cpy1: radialCoor2.y || 0,
-      cpx2: radialCoor3.x || 0,
-      cpy2: radialCoor3.y || 0
-    };
-  } else {
-    x1 = sourceLayout.x;
-    y1 = sourceLayout.y;
-    x2 = targetLayout.x;
-    y2 = targetLayout.y;
-    if (orient === "LR" || orient === "RL") {
-      cpx1 = x1 + (x2 - x1) * curvature;
-      cpy1 = y1;
-      cpx2 = x2 + (x1 - x2) * curvature;
-      cpy2 = y2;
-    }
-    if (orient === "TB" || orient === "BT") {
-      cpx1 = x1;
-      cpy1 = y1 + (y2 - y1) * curvature;
-      cpx2 = x2;
-      cpy2 = y2 + (y1 - y2) * curvature;
+  function prepareAnimationWhenNoOld(lasts, element) {
+    var lastCfg = lasts[thisRawIndex] = {};
+    var parentNode = thisNode.parentNode;
+    var isGroup = element instanceof Group$1;
+    if (parentNode && (!reRoot || reRoot.direction === "drillDown")) {
+      var parentOldX = 0;
+      var parentOldY = 0;
+      var parentOldBg = lastsForAnimation.background[parentNode.getRawIndex()];
+      if (!reRoot && parentOldBg && parentOldBg.oldShape) {
+        parentOldX = parentOldBg.oldShape.width;
+        parentOldY = parentOldBg.oldShape.height;
+      }
+      if (isGroup) {
+        lastCfg.oldX = 0;
+        lastCfg.oldY = parentOldY;
+      } else {
+        lastCfg.oldShape = {
+          x: parentOldX,
+          y: parentOldY,
+          width: 0,
+          height: 0
+        };
+      }
     }
+    lastCfg.fadein = !isGroup;
   }
-  return {
-    x1,
-    y1,
-    x2,
-    y2,
-    cpx1,
-    cpy1,
-    cpx2,
-    cpy2
-  };
+}
+function calculateZ2(depth, z2InLevel) {
+  return depth * Z2_BASE + z2InLevel;
 }
 export {
-  TreeView as default
+  TreemapView as default
 };