@visactor/vrender-components 0.16.9 → 0.16.10-alpha.1

package/dist/index.js

@@ -24320,6 +24320,49 @@
       }
   }
 
+  function rotate(x, y, deg, originX, originY) {
+      return {
+          x: (x - originX) * Math.cos(deg) + (y - originY) * Math.sin(deg) + originX,
+          y: (x - originX) * Math.sin(deg) + (originY - y) * Math.cos(deg) + originY
+      };
+  }
+  function genNormalBounds(item) {
+      const bounds = item.AABBBounds;
+      return {
+          x1: bounds.x1,
+          x2: bounds.x2,
+          y1: bounds.y1,
+          y2: bounds.y2,
+          centerX: item.attribute.x,
+          centerY: item.attribute.y,
+          angle: item.attribute.angle
+      };
+  }
+  function genRotateBounds(items) {
+      items.forEach(item => {
+          if (item.rotatedBounds || !item.attribute.angle) {
+              return;
+          }
+          const bounds = genNormalBounds(item);
+          const rotatedCenter = rotate(bounds.centerX, bounds.centerY, bounds.angle, item.attribute.x, item.attribute.y);
+          const deltaX = rotatedCenter.x - bounds.centerX;
+          const deltaY = rotatedCenter.y - bounds.centerY;
+          bounds.x1 += deltaX;
+          bounds.x2 += deltaX;
+          bounds.y1 += deltaY;
+          bounds.y2 += deltaY;
+          bounds.centerX += deltaX;
+          bounds.centerY += deltaY;
+          item.rotatedBounds = bounds;
+      });
+  }
+  function itemIntersect(item1, item2) {
+      return (vutils.isRectIntersect(item1.AABBBounds, item2.AABBBounds, false) &&
+          (item1.rotatedBounds && item2.rotatedBounds
+              ? vutils.isRotateAABBIntersect(item1.rotatedBounds, item2.rotatedBounds, true)
+              : true));
+  }
+
   const methods = {
       parity: function (items) {
           return items.filter((item, i) => (i % 2 ? item.setAttribute('opacity', 0) : 1));
@@ -24327,7 +24370,7 @@
       greedy: function (items, sep) {
           let a;
           return items.filter((b, i) => {
-              if (!i || !intersect(a.AABBBounds, b.AABBBounds, sep)) {
+              if (!i || !intersect(a, b, sep)) {
                   a = b;
                   return 1;
               }
@@ -24335,12 +24378,18 @@
           });
       }
   };
-  function intersect(a, b, sep) {
-      return sep > Math.max(b.x1 - a.x2, a.x1 - b.x2, b.y1 - a.y2, a.y1 - b.y2);
+  function intersect(textA, textB, sep) {
+      const a = textA.AABBBounds;
+      const b = textB.AABBBounds;
+      return (sep > Math.max(b.x1 - a.x2, a.x1 - b.x2, b.y1 - a.y2, a.y1 - b.y2) &&
+          (textA.rotatedBounds && textB.rotatedBounds
+              ? sep >
+                  Math.max(textB.rotatedBounds.x1 - textA.rotatedBounds.x2, textA.rotatedBounds.x1 - textB.rotatedBounds.x2, textB.rotatedBounds.y1 - textA.rotatedBounds.y2, textA.rotatedBounds.y1 - textB.rotatedBounds.y2)
+              : true));
   }
   function hasOverlap(items, pad) {
-      for (let i = 1, n = items.length, a = items[0].AABBBounds, b; i < n; a = b, ++i) {
-          if (intersect(a, (b = items[i].AABBBounds), pad)) {
+      for (let i = 1, n = items.length, a = items[0], b; i < n; a = b, ++i) {
+          if (intersect(a, (b = items[i]), pad)) {
               return true;
           }
       }
@@ -24363,6 +24412,7 @@
       }
       let items;
       items = reset(source);
+      genRotateBounds(items);
       const { method = 'parity', separation: sep = 0 } = config;
       const reduce = vutils.isFunction(method) ? method : methods[method] || methods.parity;
       if (items.length >= 3 && hasOverlap(items, sep)) {
@@ -24372,6 +24422,7 @@
           if (items.length < 3 && !vutils.last(source).attribute.opacity) {
               if (items.length > 1) {
                   vutils.last(items).setAttribute('opacity', 0);
+                  vutils.last(source).setAttribute('opacity', 1);
               }
           }
       }
@@ -24412,9 +24463,6 @@
       }
       return false;
   }
-  function itemIntersect(item1, item2) {
-      return vutils.isRotateAABBIntersect(item1.rotatedBounds, item2.rotatedBounds, true);
-  }
   function tryRotate(orient, items) {
       if (orient === 'bottom' || orient === 'top') {
           rotateXAxis(orient, items);
@@ -24424,39 +24472,6 @@
       }
       genRotateBounds(items);
   }
-  function rotate(x, y, deg, originX, originY) {
-      return {
-          x: (x - originX) * Math.cos(deg) + (y - originY) * Math.sin(deg) + originX,
-          y: (x - originX) * Math.sin(deg) + (originY - y) * Math.cos(deg) + originY
-      };
-  }
-  function genNormalBounds(item) {
-      const bounds = item.AABBBounds;
-      return {
-          x1: bounds.x1,
-          x2: bounds.x2,
-          y1: bounds.y1,
-          y2: bounds.y2,
-          centerX: item.attribute.x,
-          centerY: item.attribute.y,
-          angle: item.attribute.angle
-      };
-  }
-  function genRotateBounds(items) {
-      items.forEach(item => {
-          const bounds = genNormalBounds(item);
-          const rotatedCenter = rotate(bounds.centerX, bounds.centerY, bounds.angle, item.attribute.x, item.attribute.y);
-          const deltaX = rotatedCenter.x - bounds.centerX;
-          const deltaY = rotatedCenter.y - bounds.centerY;
-          bounds.x1 += deltaX;
-          bounds.x2 += deltaX;
-          bounds.y1 += deltaY;
-          bounds.y2 += deltaY;
-          bounds.centerX += deltaX;
-          bounds.centerY += deltaY;
-          item.rotatedBounds = bounds;
-      });
-  }
   function clampAngle(angle = 0) {
       if (angle < 0) {
           while (angle < 0) {
@@ -24847,16 +24862,15 @@
       beforeLabelsOverlap(labelShapes, labelData, labelContainer, layer, layerCount) {
           const { flush = false } = this.attribute.label || {};
           if (flush && labelShapes.length) {
-              const { orient, start, end } = this.attribute;
+              const { orient, start: axisStart, end: axisEnd } = this.attribute;
               const isX = orient === 'bottom' || orient === 'top';
               const first = labelShapes[0];
               const last = vutils.last(labelShapes);
               const isInverse = isX ? first.attribute.x > last.attribute.x : first.attribute.y < last.attribute.y;
               if (isX) {
-                  const width = Math.abs(start.x - end.x);
                   if (isInverse) {
-                      const start = width;
-                      const end = 0;
+                      const start = axisEnd.x;
+                      const end = axisStart.x;
                       const startBound = first.AABBBounds.x2;
                       const endBound = last.AABBBounds.x1;
                       if (startBound > start) {
@@ -24873,8 +24887,8 @@
                       }
                   }
                   else {
-                      const start = 0;
-                      const end = width;
+                      const start = axisStart.x;
+                      const end = axisEnd.x;
                       const startBound = first.AABBBounds.x1;
                       const endBound = last.AABBBounds.x2;
                       if (startBound < start) {
@@ -24892,12 +24906,11 @@
                   }
               }
               else {
-                  const height = Math.abs(start.y - end.y);
                   if (isInverse) {
                       const startBound = first.AABBBounds.y1;
                       const endBound = last.AABBBounds.y2;
-                      const start = 0;
-                      const end = height;
+                      const start = axisStart.y;
+                      const end = axisEnd.y;
                       if (startBound < start) {
                           first.setAttributes({
                               y: start,
@@ -24912,8 +24925,8 @@
                       }
                   }
                   else {
-                      const start = height;
-                      const end = 0;
+                      const start = axisEnd.y;
+                      const end = axisStart.y;
                       const startBound = first.AABBBounds.y2;
                       const endBound = last.AABBBounds.y1;
                       if (startBound > start) {
@@ -31246,7 +31259,7 @@
       }
   };
 
-  const version = "0.16.9";
+  const version = "0.16.10-alpha.1";
 
   exports.AbstractComponent = AbstractComponent;
   exports.ArcInfo = ArcInfo;