tvcharts 0.8.55 → 0.8.56

package/dist/echarts.js

@@ -25584,6 +25584,9 @@ ECharts.internalField = function() {
         markStatusToUpdate(ecIns);
       }
     }).on("mousedown", function(e2) {
+      if (e2.event.zrByTouch) {
+        return;
+      }
       const el = e2.target;
       const dispatcher = findEventDispatcher(el, isHighDownDispatcher);
       handleGlobalMouseDownForHighDown(dispatcher, e2, ecIns._api);
@@ -25601,6 +25604,11 @@ ECharts.internalField = function() {
           isFromClick: true
         });
       }
+      if (!e2.event.zrByTouch) {
+        return;
+      }
+      const mobileDispatcher = findEventDispatcher(el, isHighDownDispatcher);
+      handleGlobalMouseDownForHighDown(mobileDispatcher, e2, ecIns._api);
     }).on("globalout", function() {
       if (ecIns.mousemoveComponentGroupId) {
         ecIns.mousemoveComponentGroupId = "";
@@ -41935,6 +41943,9 @@ var RoamController = class extends Eventful_default {
       this._startX = x;
       this._startY = y;
       this._dragging = true;
+      if (this.kineticScroll) {
+        this.kineticScroll = null;
+      }
     }
   }
   _mousemoveHandler(e2) {
@@ -41966,7 +41977,8 @@ var RoamController = class extends Eventful_default {
       oldY,
       newX: x,
       newY: y,
-      isAvailableBehavior: null
+      isAvailableBehavior: null,
+      isTouch: e2.event.zrByTouch
     });
   }
   _mouseupHandler(e2) {
@@ -41979,6 +41991,7 @@ var RoamController = class extends Eventful_default {
       const dy = y - oldY;
       if (this._dragging && (dx || dy)) {
         trigger(this, "dragEnd", "moveOnMouseMove", e2, {isAvailableBehavior: null});
+        this._startKineticScroll();
       }
       this._dragging = false;
     }
@@ -42019,15 +42032,36 @@ var RoamController = class extends Eventful_default {
     if (isTaken(this._zr, "globalPan")) {
       return;
     }
-    const scale4 = e2.pinchScale > 1 ? 1.1 : 1 / 1.1;
-    checkPointerAndTrigger(this, "zoom", null, e2, {
+    const scale4 = e2.pinchScale;
+    checkPointerAndTrigger(this, "zoom", "zoomOnMouseWheel", e2, {
       scale: scale4,
       originX: e2.pinchX,
       originY: e2.pinchY,
       isAvailableBehavior: null,
-      inSitu: e2.event.ctrlKey
+      inSitu: true
     });
   }
+  _kineticScroll() {
+    if (!this.kineticScroll) {
+      return;
+    }
+    const now = Date.now();
+    if (!this.kineticScroll.finished(now)) {
+      const newPos = this.kineticScroll.getPosition(now);
+      trigger(this, "kineticScroll", "moveOnMouseMove", null, {
+        isAvailableBehavior: null,
+        lastBarRightSideDiffBarCount: Math.round(newPos / this.minScrollUnit) * this.minScrollUnit
+      });
+      requestAnimationFrame_default(() => this._kineticScroll());
+    }
+  }
+  _startKineticScroll() {
+    if (!this.kineticScroll) {
+      return;
+    }
+    this.kineticScroll.start(this.startPositionX, Date.now());
+    this._kineticScroll();
+  }
 };
 function checkPointerAndTrigger(controller, eventName, behaviorToCheck, e2, contollerEvent) {
   if (controller.pointerChecker && controller.pointerChecker(e2, contollerEvent.originX, contollerEvent.originY)) {
@@ -76103,7 +76137,8 @@ var MarkLabelView2 = class extends Component_default2 {
           markerGroupMap.set(item.name, el);
           this.group.add(el);
         }
-        if (item.countDown && item.countDown.show && item.countDown.value > 0) {
+        const showCountDown = item.countDown && item.countDown.show && item.countDown.value > 0;
+        if (showCountDown) {
           const key = seriesName + item.name;
           if (!timerMap.get(key)) {
             const countDownTextEl = el.childAt(3);
@@ -76111,7 +76146,7 @@ var MarkLabelView2 = class extends Component_default2 {
           }
         }
         inner21(el).yAxisIndex = yAxisModel.index;
-        inner21(el).isSort = item.showName;
+        inner21(el).isSort = item.showName || showCountDown;
       });
       markerGroupMapBySeries.set(seriesName, markerGroupMap);
     });
@@ -76433,7 +76468,7 @@ function createLabel({x, y, labelData, markerModel, gridRect, position: position
   group.add(textEl);
   group.add(textNameEl);
   if (countDown) {
-    const show = countDown.show && !!countDown.value;
+    const show = countDown.show && countDown.value > 0;
     const offsetY = showName && show ? textRect.height + paddings[0] + paddings[2] - 1 : 0;
     const fill = textStyle.fill === "#ffffff" ? "rgba(255,255,255,0.8)" : "rgba(0,0,0,0.8)";
     const countDownEl = new Text_default({
@@ -77647,6 +77682,122 @@ InsideZoomModel.defaultOption = inheritDefaultOption(DataZoomModel_default.defau
 });
 var InsideZoomModel_default = InsideZoomModel;
 
+// src/component/helper/kineticAnimation.ts
+var Constants;
+(function(Constants2) {
+  Constants2[Constants2["MaxStartDelay"] = 50] = "MaxStartDelay";
+  Constants2[Constants2["EpsilonDistance"] = 1] = "EpsilonDistance";
+})(Constants || (Constants = {}));
+function ensureNotNull(value) {
+  if (value === null) {
+    throw new Error("Value is null");
+  }
+  return value;
+}
+function distanceBetweenPoints(pos1, pos2) {
+  return pos1.position - pos2.position;
+}
+function speedPxPerMSec(pos1, pos2, maxSpeed) {
+  const speed = (pos1.position - pos2.position) / (pos1.time - pos2.time);
+  return Math.sign(speed) * Math.min(Math.abs(speed), maxSpeed);
+}
+function durationMSec(speed, dumpingCoeff) {
+  const lnDumpingCoeff = Math.log(dumpingCoeff);
+  return Math.log(1 * lnDumpingCoeff / -speed) / lnDumpingCoeff;
+}
+var KineticScrollConstants;
+(function(KineticScrollConstants2) {
+  KineticScrollConstants2[KineticScrollConstants2["MinScrollSpeed"] = 0.2] = "MinScrollSpeed";
+  KineticScrollConstants2[KineticScrollConstants2["MaxScrollSpeed"] = 7] = "MaxScrollSpeed";
+  KineticScrollConstants2[KineticScrollConstants2["DumpingCoeff"] = 0.997] = "DumpingCoeff";
+  KineticScrollConstants2[KineticScrollConstants2["ScrollMinMove"] = 15] = "ScrollMinMove";
+})(KineticScrollConstants || (KineticScrollConstants = {}));
+var KineticAnimation = class {
+  constructor(minSpeed, maxSpeed, dumpingCoeff, minMove) {
+    this._position1 = null;
+    this._position2 = null;
+    this._position3 = null;
+    this._position4 = null;
+    this._animationStartPosition = null;
+    this._durationMsecs = 0;
+    this._speedPxPerMsec = 0;
+    this._minSpeed = minSpeed;
+    this._maxSpeed = maxSpeed;
+    this._dumpingCoeff = dumpingCoeff;
+    this._minMove = minMove;
+  }
+  addPosition(position2, time) {
+    if (this._position1 !== null) {
+      if (this._position1.time === time) {
+        this._position1.position = position2;
+        return;
+      }
+      if (Math.abs(this._position1.position - position2) < this._minMove) {
+        return;
+      }
+    }
+    this._position4 = this._position3;
+    this._position3 = this._position2;
+    this._position2 = this._position1;
+    this._position1 = {time, position: position2};
+  }
+  start(position2, time) {
+    if (this._position1 === null || this._position2 === null) {
+      return;
+    }
+    if (time - this._position1.time > 50) {
+      return;
+    }
+    let totalDistance = 0;
+    const speed1 = speedPxPerMSec(this._position1, this._position2, this._maxSpeed);
+    const distance1 = distanceBetweenPoints(this._position1, this._position2);
+    const speedItems = [speed1];
+    const distanceItems = [distance1];
+    totalDistance += distance1;
+    if (this._position3 !== null) {
+      const speed2 = speedPxPerMSec(this._position2, this._position3, this._maxSpeed);
+      if (Math.sign(speed2) === Math.sign(speed1)) {
+        const distance2 = distanceBetweenPoints(this._position2, this._position3);
+        speedItems.push(speed2);
+        distanceItems.push(distance2);
+        totalDistance += distance2;
+        if (this._position4 !== null) {
+          const speed3 = speedPxPerMSec(this._position3, this._position4, this._maxSpeed);
+          if (Math.sign(speed3) === Math.sign(speed1)) {
+            const distance3 = distanceBetweenPoints(this._position3, this._position4);
+            speedItems.push(speed3);
+            distanceItems.push(distance3);
+            totalDistance += distance3;
+          }
+        }
+      }
+    }
+    let resultSpeed = 0;
+    for (let i = 0; i < speedItems.length; ++i) {
+      resultSpeed += distanceItems[i] / totalDistance * speedItems[i];
+    }
+    if (Math.abs(resultSpeed) < this._minSpeed) {
+      return;
+    }
+    this._animationStartPosition = {position: position2, time};
+    this._speedPxPerMsec = resultSpeed;
+    this._durationMsecs = durationMSec(Math.abs(resultSpeed), this._dumpingCoeff);
+  }
+  getPosition(time) {
+    const startPosition = ensureNotNull(this._animationStartPosition);
+    const durationMsecs = time - startPosition.time;
+    return startPosition.position + this._speedPxPerMsec * (Math.pow(this._dumpingCoeff, durationMsecs) - 1) / Math.log(this._dumpingCoeff);
+  }
+  finished(time) {
+    return this._animationStartPosition === null || this._progressDuration(time) === this._durationMsecs;
+  }
+  _progressDuration(time) {
+    const startPosition = ensureNotNull(this._animationStartPosition);
+    const progress = time - startPosition.time;
+    return Math.min(progress, this._durationMsecs);
+  }
+};
+
 // src/component/dataZoom/roams.ts
 var inner22 = makeInner();
 function setViewInfoToCoordSysRecord(api2, dataZoomModel, getRange) {
@@ -77712,49 +77863,74 @@ function createCoordSysRecord(api2, coordSysModel) {
         const method = (dzInfo.getRange || {})[eventName];
         const range = method && method(dzInfo.dzReferCoordSysInfo, coordSysRecord.model.mainType, coordSysRecord.controller, event);
         const enabled = !dzInfo.model.get("disabled", true) && range;
-        if (enabled) {
-          const axisProxy = dzInfo.model.findRepresentativeAxisProxy();
-          const axisModal = axisProxy.getAxisModel();
-          const useValueRange = dzInfo.model.get("useValueRange");
-          const isDistanceMode = axisModal.axis.getIsDistanceMode();
-          if (isDistanceMode) {
-            const isDragging = controller.isDragging();
-            dzInfo.model.setDistanceRange(range);
-            dzInfo.model.isDragging = isDragging;
-            batch.push({
-              dataZoomId: dzInfo.model.id,
-              uid: dzInfo.model.uid,
-              barSpace: range[0],
-              lastBarRightSideDiffBarCount: range[1],
-              scale: 2 + event.scale * -1,
-              event,
-              isDragging
-            });
-          } else if (useValueRange) {
-            dzInfo.model.setRawRange({
-              startValue: range[0],
-              endValue: range[1]
-            });
-            batch.push({
-              dataZoomId: dzInfo.model.id,
-              uid: dzInfo.model.uid,
-              startValue: range[0],
-              endValue: range[1],
-              event
-            });
-          } else {
-            batch.push({
-              dataZoomId: dzInfo.model.id,
-              start: range[0],
-              end: range[1],
-              event
-            });
+        if (!enabled) {
+          return;
+        }
+        const axisProxy = dzInfo.model.findRepresentativeAxisProxy();
+        const axisModal = axisProxy.getAxisModel();
+        const useValueRange = dzInfo.model.get("useValueRange");
+        const isDistanceMode = axisModal.axis.getIsDistanceMode();
+        if (isDistanceMode) {
+          const isDragging = controller.isDragging();
+          dzInfo.model.setDistanceRange(range);
+          dzInfo.model.isDragging = isDragging;
+          const barSpace = range[0];
+          const lastBarRightSideDiffBarCount = range[1];
+          const now = Date.now();
+          if (!controller.kineticScroll && eventName === "pan" && event.isTouch) {
+            controller.kineticScroll = new KineticAnimation(KineticScrollConstants.MinScrollSpeed / barSpace, KineticScrollConstants.MaxScrollSpeed / barSpace, KineticScrollConstants.DumpingCoeff, KineticScrollConstants.ScrollMinMove / barSpace);
+            controller.minScrollUnit = 1 / barSpace;
+            controller.kineticScroll.addPosition(lastBarRightSideDiffBarCount, now);
+          } else if (controller.kineticScroll) {
+            controller.kineticScroll.addPosition(lastBarRightSideDiffBarCount, now);
+            controller.startPositionX = lastBarRightSideDiffBarCount;
           }
+          batch.push({
+            dataZoomId: dzInfo.model.id,
+            uid: dzInfo.model.uid,
+            barSpace: range[0],
+            lastBarRightSideDiffBarCount: range[1],
+            scale: 2 + event.scale * -1,
+            event,
+            isDragging
+          });
+        } else if (useValueRange) {
+          dzInfo.model.setRawRange({
+            startValue: range[0],
+            endValue: range[1]
+          });
+          batch.push({
+            dataZoomId: dzInfo.model.id,
+            uid: dzInfo.model.uid,
+            startValue: range[0],
+            endValue: range[1],
+            event
+          });
+        } else {
+          batch.push({
+            dataZoomId: dzInfo.model.id,
+            start: range[0],
+            end: range[1],
+            event
+          });
         }
       });
       batch.length && coordSysRecord.dispatchAction(batch);
     });
   });
+  controller.on("kineticScroll", (event) => {
+    coordSysRecord.dataZoomInfoMap.each(function(dzInfo) {
+      const axisProxy = dzInfo.model.findRepresentativeAxisProxy();
+      const axisModal = axisProxy.getAxisModel();
+      const isDistanceMode = axisModal.axis.getIsDistanceMode();
+      if (isDistanceMode) {
+        coordSysRecord.dispatchAction([{
+          dataZoomId: dzInfo.model.id,
+          lastBarRightSideDiffBarCount: event.lastBarRightSideDiffBarCount
+        }]);
+      }
+    });
+  });
   return coordSysRecord;
 }
 function dispatchAction2(api2, batch) {