@visactor/vrender-components 0.16.3-alpha.0 → 0.16.3

package/dist/index.js

@@ -19921,7 +19921,11 @@
     }, {
       key: "containsPoint",
       value: function containsPoint(graphic, point, params) {
-        return !!this.pickItem(graphic, point, null, params);
+        var _a;
+        return !!(null === (_a = this.pickItem(graphic, point, null, null != params ? params : {
+          pickContext: this.pickContext,
+          pickerService: this
+        })) || void 0 === _a ? void 0 : _a.graphic);
       }
     }, {
       key: "pickGroup",
@@ -21787,6 +21791,194 @@
       easing: 'linear'
   };
 
+  function polarToCartesian(point) {
+      if (!point.radius) {
+          return { x: 0, y: 0 };
+      }
+      return {
+          x: Math.cos(point.angle) * point.radius,
+          y: Math.sin(point.angle) * point.radius
+      };
+  }
+  function circlePoint(x0, y0, radius, radian) {
+      const offset = polarToCartesian({
+          radius,
+          angle: radian
+      });
+      return {
+          x: x0 + offset.x,
+          y: y0 + offset.y
+      };
+  }
+  function computeQuadrant(angle) {
+      angle = normalizeAngle(angle);
+      if (angle > 0 && angle <= Math.PI / 2) {
+          return 2;
+      }
+      else if (angle > Math.PI / 2 && angle <= Math.PI) {
+          return 3;
+      }
+      else if (angle > Math.PI && angle <= (3 * Math.PI) / 2) {
+          return 4;
+      }
+      return 1;
+  }
+  function normalizeAngle(angle) {
+      while (angle < 0) {
+          angle += Math.PI * 2;
+      }
+      while (angle >= Math.PI * 2) {
+          angle -= Math.PI * 2;
+      }
+      return angle;
+  }
+  function isQuadrantLeft(quadrant) {
+      return quadrant === 3 || quadrant === 4;
+  }
+  function isQuadrantRight(quadrant) {
+      return quadrant === 1 || quadrant === 2;
+  }
+  function lineCirclePoints(a, b, c, x0, y0, r) {
+      if ((a === 0 && b === 0) || r <= 0) {
+          return [];
+      }
+      if (a === 0) {
+          const y1 = -c / b;
+          const fy = (y1 - y0) ** 2;
+          const fd = r ** 2 - fy;
+          if (fd < 0) {
+              return [];
+          }
+          else if (fd === 0) {
+              return [{ x: x0, y: y1 }];
+          }
+          const x1 = Math.sqrt(fd) + x0;
+          const x2 = -Math.sqrt(fd) + x0;
+          return [
+              { x: x1, y: y1 },
+              { x: x2, y: y1 }
+          ];
+      }
+      else if (b === 0) {
+          const x1 = -c / a;
+          const fx = (x1 - x0) ** 2;
+          const fd = r ** 2 - fx;
+          if (fd < 0) {
+              return [];
+          }
+          else if (fd === 0) {
+              return [{ x: x1, y: y0 }];
+          }
+          const y1 = Math.sqrt(fd) + y0;
+          const y2 = -Math.sqrt(fd) + y0;
+          return [
+              { x: x1, y: y1 },
+              { x: x1, y: y2 }
+          ];
+      }
+      const fa = (b / a) ** 2 + 1;
+      const fb = 2 * ((c / a + x0) * (b / a) - y0);
+      const fc = (c / a + x0) ** 2 + y0 ** 2 - r ** 2;
+      const fd = fb ** 2 - 4 * fa * fc;
+      if (fd < 0) {
+          return [];
+      }
+      const y1 = (-fb + Math.sqrt(fd)) / (2 * fa);
+      const y2 = (-fb - Math.sqrt(fd)) / (2 * fa);
+      const x1 = -(b * y1 + c) / a;
+      const x2 = -(b * y2 + c) / a;
+      if (fd === 0) {
+          return [{ x: x1, y: y1 }];
+      }
+      return [
+          { x: x1, y: y1 },
+          { x: x2, y: y2 }
+      ];
+  }
+  function connectLineRadian(radius, length) {
+      if (length > radius * 2) {
+          return NaN;
+      }
+      return Math.asin(length / 2 / radius) * 2;
+  }
+  function checkBoundsOverlap(boundsA, boundsB) {
+      const { x1: ax1, y1: ay1, x2: ax2, y2: ay2 } = boundsA;
+      const { x1: bx1, y1: by1, x2: bx2, y2: by2 } = boundsB;
+      return !((ax1 <= bx1 && ax2 <= bx1) ||
+          (ax1 >= bx2 && ax2 >= bx2) ||
+          (ay1 <= by1 && ay2 <= by1) ||
+          (ay1 >= by2 && ay2 >= by2));
+  }
+  const labelingPoint = (textBounds, graphicBounds, position = 'top', offset = 0) => {
+      if (!textBounds) {
+          return;
+      }
+      const { x1, y1, x2, y2 } = textBounds;
+      const width = Math.abs(x2 - x1);
+      const height = Math.abs(y2 - y1);
+      const anchorX = (graphicBounds.x1 + graphicBounds.x2) / 2;
+      const anchorY = (graphicBounds.y1 + graphicBounds.y2) / 2;
+      let sx = 0;
+      let sy = 0;
+      let offsetX = 0;
+      let offsetY = 0;
+      if (graphicBounds) {
+          offsetX = Math.abs(graphicBounds.x1 - graphicBounds.x2) / 2;
+          offsetY = Math.abs(graphicBounds.y1 - graphicBounds.y2) / 2;
+      }
+      const angle = {
+          'top-right': -235,
+          'top-left': 235,
+          'bottom-right': 45,
+          'bottom-left': -45
+      };
+      switch (position) {
+          case 'top':
+              sy = -1;
+              break;
+          case 'bottom':
+              sy = 1;
+              break;
+          case 'left':
+              sx = -1;
+              break;
+          case 'right':
+              sx = 1;
+              break;
+          case 'bottom-left':
+          case 'bottom-right':
+          case 'top-left':
+          case 'top-right':
+              sx = Math.sin(angle[position] * (Math.PI / 180));
+              sy = Math.cos(angle[position] * (Math.PI / 180));
+              break;
+          case 'center':
+              sx = 0;
+              sy = 0;
+              break;
+      }
+      const x = anchorX + sx * (offset + offsetX) + Math.sign(sx) * (width / 2);
+      const y = anchorY + sy * (offset + offsetY) + Math.sign(sy) * (height / 2);
+      return { x, y };
+  };
+  const getPointsOfLineArea = (graphic) => {
+      if (!graphic || !graphic.attribute) {
+          return [];
+      }
+      const { points, segments } = graphic.attribute;
+      if (segments && segments.length) {
+          const res = [];
+          segments.forEach(seg => {
+              const segPoints = seg.points;
+              segPoints.forEach(point => {
+                  res.push(point);
+              });
+          });
+          return res;
+      }
+      return points;
+  };
+
   class LabelBase extends AbstractComponent {
       setBitmap(bitmap) {
           this._bitmap = bitmap;
@@ -21846,15 +22038,17 @@
               var _a, _b, _c;
               if (((_a = e.detail) === null || _a === void 0 ? void 0 : _a.type) === AttributeUpdateType.STATE) {
                   const currentStates = (_c = (_b = e.target) === null || _b === void 0 ? void 0 : _b.currentStates) !== null && _c !== void 0 ? _c : [];
-                  const label = this._graphicToText.get(e.target);
-                  if (label) {
-                      if (label.text) {
-                          label.text.useStates(currentStates);
-                      }
-                      if (label.labelLine) {
-                          label.labelLine.useStates(currentStates);
+                  const labels = this._isCollectionBase ? [...this._graphicToText.values()] : [this._graphicToText.get(e.target)];
+                  labels.forEach(label => {
+                      if (label) {
+                          if (label.text) {
+                              label.text.useStates(currentStates);
+                          }
+                          if (label.labelLine) {
+                              label.labelLine.useStates(currentStates);
+                          }
                       }
-                  }
+                  });
               }
           };
       }
@@ -21866,7 +22060,7 @@
       }
       render() {
           this._prepare();
-          if (vutils.isNil(this._idToGraphic)) {
+          if ((this._isCollectionBase && vutils.isNil(this._idToPoint)) || (!this._isCollectionBase && vutils.isNil(this._idToGraphic))) {
               return;
           }
           const { overlap, smartInvert, dataFilter, customLayoutFunc, customOverlapFunc } = this.attribute;
@@ -21876,13 +22070,13 @@
           }
           let labels;
           if (vutils.isFunction(customLayoutFunc)) {
-              labels = customLayoutFunc(data, (d) => this._idToGraphic.get(d.id));
+              labels = customLayoutFunc(data, this.getRelatedGrphic, this._isCollectionBase ? (d) => this._idToPoint.get(d.id) : null);
           }
           else {
               labels = this._layout(data);
           }
           if (vutils.isFunction(customOverlapFunc)) {
-              labels = customOverlapFunc(labels, (d) => this._idToGraphic.get(d.id));
+              labels = customOverlapFunc(labels, this.getRelatedGrphic, this._isCollectionBase ? (d) => this._idToPoint.get(d.id) : null);
           }
           else {
               if (overlap !== false) {
@@ -21937,7 +22131,7 @@
           return text;
       }
       _prepare() {
-          var _a;
+          var _a, _b, _c, _d;
           const currentBaseMarks = [];
           let baseMarks;
           if (vutils.isFunction(this.attribute.getBaseMarks)) {
@@ -21952,7 +22146,9 @@
               }
           });
           (_a = this._idToGraphic) === null || _a === void 0 ? void 0 : _a.clear();
+          (_b = this._idToPoint) === null || _b === void 0 ? void 0 : _b.clear();
           this._baseMarks = currentBaseMarks;
+          this._isCollectionBase = ((_c = currentBaseMarks === null || currentBaseMarks === void 0 ? void 0 : currentBaseMarks[0]) === null || _c === void 0 ? void 0 : _c.type) === 'line' || ((_d = currentBaseMarks === null || currentBaseMarks === void 0 ? void 0 : currentBaseMarks[0]) === null || _d === void 0 ? void 0 : _d.type) === 'area';
           if (!currentBaseMarks || currentBaseMarks.length === 0) {
               return;
           }
@@ -21960,30 +22156,59 @@
           if (!data || data.length === 0) {
               return;
           }
-          if (!this._idToGraphic) {
-              this._idToGraphic = new Map();
+          if (this._isCollectionBase) {
+              if (!this._idToPoint) {
+                  this._idToPoint = new Map();
+              }
+              const baseMark = currentBaseMarks[0];
+              const points = getPointsOfLineArea(baseMark);
+              if (points === null || points === void 0 ? void 0 : points.length) {
+                  for (let i = 0; i < points.length; i++) {
+                      const textData = data[i];
+                      if (textData && points[i]) {
+                          if (!vutils.isValid(textData.id)) {
+                              textData.id = `vrender-component-${this.name}-${i}`;
+                          }
+                          this._idToPoint.set(textData.id, points[i]);
+                      }
+                  }
+              }
           }
-          for (let i = 0; i < currentBaseMarks.length; i++) {
-              const textData = data[i];
-              const baseMark = currentBaseMarks[i];
-              if (textData && baseMark) {
-                  if (!vutils.isValid(textData.id)) {
-                      textData.id = `vrender-component-${this.name}-${i}`;
+          else {
+              if (!this._idToGraphic) {
+                  this._idToGraphic = new Map();
+              }
+              for (let i = 0; i < currentBaseMarks.length; i++) {
+                  const textData = data[i];
+                  const baseMark = currentBaseMarks[i];
+                  if (textData && baseMark) {
+                      if (!vutils.isValid(textData.id)) {
+                          textData.id = `vrender-component-${this.name}-${i}`;
+                      }
+                      this._idToGraphic.set(textData.id, baseMark);
                   }
-                  this._idToGraphic.set(textData.id, baseMark);
               }
           }
       }
+      getRelatedGrphic(item) {
+          return this._isCollectionBase ? this._baseMarks[0] : this._idToGraphic.get(item.id);
+      }
       _layout(data = []) {
           const { textStyle = {}, position, offset } = this.attribute;
           const labels = [];
           for (let i = 0; i < data.length; i++) {
               const textData = data[i];
-              const baseMark = this._idToGraphic.get(textData.id);
-              const labelAttribute = Object.assign(Object.assign({ fill: baseMark.attribute.fill }, textStyle), textData);
+              const baseMark = this.getRelatedGrphic(textData);
+              const labelAttribute = Object.assign(Object.assign({ fill: this._isCollectionBase
+                      ? vutils.isArray(baseMark.attribute.stroke)
+                          ? baseMark.attribute.stroke.find(entry => !!entry && entry !== true)
+                          : baseMark.attribute.stroke
+                      : baseMark.attribute.fill }, textStyle), textData);
               const text = this._createLabelText(labelAttribute);
               const textBounds = this.getGraphicBounds(text);
-              const graphicBounds = this.getGraphicBounds(baseMark, { x: textData.x, y: textData.y });
+              const graphicBounds = this._isCollectionBase
+                  ? this.getGraphicBounds(null, this._idToPoint.get(textData.id))
+                  : this.getGraphicBounds(baseMark, { x: textData.x, y: textData.y });
               const textLocation = this.labeling(textBounds, graphicBounds, vutils.isFunction(position) ? position(textData) : position, offset);
               if (textLocation) {
                   labelAttribute.x = textLocation.x;
@@ -22035,7 +22260,7 @@
                   continue;
               }
               const text = labels[i];
-              const baseMark = this._idToGraphic.get(text.attribute.id);
+              const baseMark = this.getRelatedGrphic(text.attribute);
               text.update();
               if (!vutils.isRectIntersect(baseMark.AABBBounds, { x1: 0, x2: bmpTool.width, y1: 0, y2: bmpTool.height }, true)) {
                   continue;
@@ -22054,7 +22279,9 @@
               }
               let hasPlace = false;
               for (let j = 0; j < strategy.length; j++) {
-                  hasPlace = place(bmpTool, bitmap, strategy[j], this.attribute, text, this.getGraphicBounds(baseMark, labels[i]), this.labeling);
+                  hasPlace = place(bmpTool, bitmap, strategy[j], this.attribute, text, this._isCollectionBase
+                      ? this.getGraphicBounds(null, this._idToPoint.get(labels[i].attribute.id))
+                      : this.getGraphicBounds(baseMark, labels[i].attribute), this.labeling);
                   if (hasPlace !== false) {
                       text.setAttributes({ x: hasPlace.x, y: hasPlace.y });
                       result.push(text);
@@ -22121,11 +22348,13 @@
           labels.forEach((text, index) => {
               var _a, _b, _c, _d, _e, _f, _g;
               const labelLine = this._labelLine(text);
-              const relatedGraphic = this._idToGraphic.get(text.attribute.id);
-              const state = (prevTextMap === null || prevTextMap === void 0 ? void 0 : prevTextMap.get(relatedGraphic)) ? 'update' : 'enter';
+              const relatedGraphic = this.getRelatedGrphic(text.attribute);
+              const textId = text.attribute.id;
+              const textKey = this._isCollectionBase ? textId : relatedGraphic;
+              const state = (prevTextMap === null || prevTextMap === void 0 ? void 0 : prevTextMap.get(textKey)) ? 'update' : 'enter';
               if (state === 'enter') {
                   texts.push(text);
-                  currentTextMap.set(relatedGraphic, labelLine ? { text, labelLine } : { text });
+                  currentTextMap.set(textKey, labelLine ? { text, labelLine } : { text });
                   if (relatedGraphic) {
                       const { from, to } = getAnimationAttributes(text.attribute, 'fadeIn');
                       this.add(text);
@@ -22134,7 +22363,7 @@
                           this.add(labelLine);
                       }
                       this._syncStateWithRelatedGraphic(relatedGraphic);
-                      relatedGraphic.once('animate-bind', () => {
+                      relatedGraphic.once('animate-bind', a => {
                           text.setAttributes(from);
                           const listener = this._afterRelatedGraphicAttributeUpdate(text, texts, index, relatedGraphic, {
                               mode,
@@ -22148,9 +22377,9 @@
                   }
               }
               else if (state === 'update') {
-                  const prevLabel = prevTextMap.get(relatedGraphic);
-                  prevTextMap.delete(relatedGraphic);
-                  currentTextMap.set(relatedGraphic, prevLabel);
+                  const prevLabel = prevTextMap.get(textKey);
+                  prevTextMap.delete(textKey);
+                  currentTextMap.set(textKey, prevLabel);
                   const prevText = prevLabel.text;
                   prevText.animate().to(text.attribute, duration, easing);
                   if (prevLabel.labelLine) {
@@ -22185,10 +22414,11 @@
           labels.forEach(text => {
               var _a;
               const labelLine = this._labelLine(text);
-              const relatedGraphic = this._idToGraphic.get(text.attribute.id);
+              const relatedGraphic = this.getRelatedGrphic(text.attribute);
               const state = (prevTextMap === null || prevTextMap === void 0 ? void 0 : prevTextMap.get(relatedGraphic)) ? 'update' : 'enter';
+              const textKey = this._isCollectionBase ? text.attribute.id : relatedGraphic;
               if (state === 'enter') {
-                  currentTextMap.set(relatedGraphic, labelLine ? { text, labelLine } : { text });
+                  currentTextMap.set(textKey, labelLine ? { text, labelLine } : { text });
                   this.add(text);
                   if (labelLine) {
                       this.add(labelLine);
@@ -22196,9 +22426,9 @@
                   this._syncStateWithRelatedGraphic(relatedGraphic);
               }
               else if (state === 'update') {
-                  const prevLabel = prevTextMap.get(relatedGraphic);
-                  prevTextMap.delete(relatedGraphic);
-                  currentTextMap.set(relatedGraphic, prevLabel);
+                  const prevLabel = prevTextMap.get(textKey);
+                  prevTextMap.delete(textKey);
+                  currentTextMap.set(textKey, prevLabel);
                   prevLabel.text.setAttributes(text.attribute);
                   if (prevLabel === null || prevLabel === void 0 ? void 0 : prevLabel.labelLine) {
                       prevLabel.labelLine.setAttributes({ points: (_a = text.attribute) === null || _a === void 0 ? void 0 : _a.points });
@@ -22220,7 +22450,7 @@
       }
       _afterRelatedGraphicAttributeUpdate(text, texts, index, relatedGraphic, { mode, duration, easing, to, delay }) {
           const listener = (event) => {
-              var _a;
+              var _a, _b;
               const { detail } = event;
               if (!detail) {
                   return {};
@@ -22259,7 +22489,15 @@
                       break;
                   case 'same-time':
                   default:
-                      if (detail.animationState.isFirstFrameOfStep) {
+                      if (this._isCollectionBase) {
+                          const point = this._idToPoint.get(text.attribute.id);
+                          if (point &&
+                              (!text.animates || !text.animates.has('label-animate')) &&
+                              this._baseMarks[0].containsPoint(point.x, point.y, IContainPointMode.LOCAL, (_b = this.stage) === null || _b === void 0 ? void 0 : _b.pickerService)) {
+                              text.animate({ onEnd }).wait(delay).to(to, duration, easing);
+                          }
+                      }
+                      else if (detail.animationState.isFirstFrameOfStep) {
                           text.animate({ onEnd }).wait(delay).to(to, duration, easing);
                       }
                       break;
@@ -22284,7 +22522,7 @@
               if (!label) {
                   continue;
               }
-              const baseMark = this._idToGraphic.get(label.attribute.id);
+              const baseMark = this.getRelatedGrphic(label.attribute);
               const backgroundColor = baseMark.attribute.fill;
               const foregroundColor = label.attribute.fill;
               const baseColor = backgroundColor;
@@ -22361,56 +22599,7 @@
           this.name = 'symbol-label';
       }
       labeling(textBounds, graphicBounds, position = 'top', offset = 0) {
-          if (!textBounds) {
-              return;
-          }
-          const { x1, y1, x2, y2 } = textBounds;
-          const width = Math.abs(x2 - x1);
-          const height = Math.abs(y2 - y1);
-          const anchorX = (graphicBounds.x1 + graphicBounds.x2) / 2;
-          const anchorY = (graphicBounds.y1 + graphicBounds.y2) / 2;
-          let sx = 0;
-          let sy = 0;
-          let offsetX = 0;
-          let offsetY = 0;
-          if (graphicBounds) {
-              offsetX = Math.abs(graphicBounds.x1 - graphicBounds.x2) / 2;
-              offsetY = Math.abs(graphicBounds.y1 - graphicBounds.y2) / 2;
-          }
-          const angle = {
-              'top-right': -235,
-              'top-left': 235,
-              'bottom-right': 45,
-              'bottom-left': -45
-          };
-          switch (position) {
-              case 'top':
-                  sy = -1;
-                  break;
-              case 'bottom':
-                  sy = 1;
-                  break;
-              case 'left':
-                  sx = -1;
-                  break;
-              case 'right':
-                  sx = 1;
-                  break;
-              case 'bottom-left':
-              case 'bottom-right':
-              case 'top-left':
-              case 'top-right':
-                  sx = Math.sin(angle[position] * (Math.PI / 180));
-                  sy = Math.cos(angle[position] * (Math.PI / 180));
-                  break;
-              case 'center':
-                  sx = 0;
-                  sy = 0;
-                  break;
-          }
-          const x = anchorX + sx * (offset + offsetX) + Math.sign(sx) * (width / 2);
-          const y = anchorY + sy * (offset + offsetY) + Math.sign(sy) * (height / 2);
-          return { x, y };
+          return labelingPoint(textBounds, graphicBounds, position, offset);
       }
   }
   SymbolLabel.defaultAttributes = {
@@ -22549,125 +22738,6 @@
       pickable: false
   };
 
-  function polarToCartesian(point) {
-      if (!point.radius) {
-          return { x: 0, y: 0 };
-      }
-      return {
-          x: Math.cos(point.angle) * point.radius,
-          y: Math.sin(point.angle) * point.radius
-      };
-  }
-  function circlePoint(x0, y0, radius, radian) {
-      const offset = polarToCartesian({
-          radius,
-          angle: radian
-      });
-      return {
-          x: x0 + offset.x,
-          y: y0 + offset.y
-      };
-  }
-  function computeQuadrant(angle) {
-      angle = normalizeAngle(angle);
-      if (angle > 0 && angle <= Math.PI / 2) {
-          return 2;
-      }
-      else if (angle > Math.PI / 2 && angle <= Math.PI) {
-          return 3;
-      }
-      else if (angle > Math.PI && angle <= (3 * Math.PI) / 2) {
-          return 4;
-      }
-      return 1;
-  }
-  function normalizeAngle(angle) {
-      while (angle < 0) {
-          angle += Math.PI * 2;
-      }
-      while (angle >= Math.PI * 2) {
-          angle -= Math.PI * 2;
-      }
-      return angle;
-  }
-  function isQuadrantLeft(quadrant) {
-      return quadrant === 3 || quadrant === 4;
-  }
-  function isQuadrantRight(quadrant) {
-      return quadrant === 1 || quadrant === 2;
-  }
-  function lineCirclePoints(a, b, c, x0, y0, r) {
-      if ((a === 0 && b === 0) || r <= 0) {
-          return [];
-      }
-      if (a === 0) {
-          const y1 = -c / b;
-          const fy = (y1 - y0) ** 2;
-          const fd = r ** 2 - fy;
-          if (fd < 0) {
-              return [];
-          }
-          else if (fd === 0) {
-              return [{ x: x0, y: y1 }];
-          }
-          const x1 = Math.sqrt(fd) + x0;
-          const x2 = -Math.sqrt(fd) + x0;
-          return [
-              { x: x1, y: y1 },
-              { x: x2, y: y1 }
-          ];
-      }
-      else if (b === 0) {
-          const x1 = -c / a;
-          const fx = (x1 - x0) ** 2;
-          const fd = r ** 2 - fx;
-          if (fd < 0) {
-              return [];
-          }
-          else if (fd === 0) {
-              return [{ x: x1, y: y0 }];
-          }
-          const y1 = Math.sqrt(fd) + y0;
-          const y2 = -Math.sqrt(fd) + y0;
-          return [
-              { x: x1, y: y1 },
-              { x: x1, y: y2 }
-          ];
-      }
-      const fa = (b / a) ** 2 + 1;
-      const fb = 2 * ((c / a + x0) * (b / a) - y0);
-      const fc = (c / a + x0) ** 2 + y0 ** 2 - r ** 2;
-      const fd = fb ** 2 - 4 * fa * fc;
-      if (fd < 0) {
-          return [];
-      }
-      const y1 = (-fb + Math.sqrt(fd)) / (2 * fa);
-      const y2 = (-fb - Math.sqrt(fd)) / (2 * fa);
-      const x1 = -(b * y1 + c) / a;
-      const x2 = -(b * y2 + c) / a;
-      if (fd === 0) {
-          return [{ x: x1, y: y1 }];
-      }
-      return [
-          { x: x1, y: y1 },
-          { x: x2, y: y2 }
-      ];
-  }
-  function connectLineRadian(radius, length) {
-      if (length > radius * 2) {
-          return NaN;
-      }
-      return Math.asin(length / 2 / radius) * 2;
-  }
-  function checkBoundsOverlap(boundsA, boundsB) {
-      const { x1: ax1, y1: ay1, x2: ax2, y2: ay2 } = boundsA;
-      const { x1: bx1, y1: by1, x2: bx2, y2: by2 } = boundsB;
-      return !((ax1 <= bx1 && ax2 <= bx1) ||
-          (ax1 >= bx2 && ax2 >= bx2) ||
-          (ay1 <= by1 && ay2 <= by1) ||
-          (ay1 >= by2 && ay2 >= by2));
-  }
-
   class ArcInfo {
       constructor(refDatum, center, outerCenter, quadrant, radian, middleAngle, innerRadius, outerRadius, circleCenter) {
           this.refDatum = refDatum;
@@ -23392,10 +23462,33 @@
       pickable: false
   };
 
+  class LineDataLabel extends LabelBase {
+      constructor(attributes) {
+          super(vutils.merge({}, LineDataLabel.defaultAttributes, attributes));
+          this.name = 'line-data-label';
+      }
+      labeling(textBounds, graphicBounds, position = 'top', offset = 0) {
+          return labelingPoint(textBounds, graphicBounds, position, offset);
+      }
+  }
+  LineDataLabel.defaultAttributes = {
+      textStyle: {
+          fontSize: 12,
+          fill: '#000',
+          textAlign: 'center',
+          textBaseline: 'middle',
+          boundsPadding: [-1, 0, -1, 0]
+      },
+      position: 'top',
+      offset: 5,
+      pickable: false
+  };
+
   const labelComponentMap = {
       rect: RectLabel,
       symbol: SymbolLabel,
-      arc: ArcLabel
+      arc: ArcLabel,
+      'line-data': LineDataLabel
   };
   class DataLabel extends AbstractComponent {
       constructor(attributes) {
@@ -30974,7 +31067,7 @@
       }
   };
 
-  const version = "0.16.3-alpha.0";
+  const version = "0.16.3";
 
   exports.AbstractComponent = AbstractComponent;
   exports.ArcInfo = ArcInfo;
@@ -31008,6 +31101,7 @@
   exports.LineAxis = LineAxis;
   exports.LineAxisGrid = LineAxisGrid;
   exports.LineCrosshair = LineCrosshair;
+  exports.LineDataLabel = LineDataLabel;
   exports.LineLabel = LineLabel;
   exports.LinkPath = LinkPath;
   exports.MarkArea = MarkArea;