@visactor/vchart 1.13.10-alpha.1 → 1.13.10

package/build/index.js

@@ -12662,6 +12662,60 @@
       }
     }
 
+    class ManualTickHandler {
+      constructor() {
+        this.time = 0;
+      }
+      static Avaliable() {
+        return !0;
+      }
+      avaliable() {
+        return ManualTickHandler.Avaliable();
+      }
+      tick(interval, cb) {
+        this.time = Math.max(0, interval + this.time), cb(this, {
+          once: !0
+        });
+      }
+      tickTo(t, cb) {
+        this.time = Math.max(0, t), cb(this, {
+          once: !0
+        });
+      }
+      release() {
+        this.timerId > 0 && (this.timerId = -1);
+      }
+      getTime() {
+        return this.time;
+      }
+    }
+
+    class ManualTicker extends DefaultTicker {
+      set mode(m) {
+        this.setupTickHandler();
+      }
+      get mode() {
+        return this._mode;
+      }
+      initHandler() {
+        return this.mode = "manual", null;
+      }
+      setupTickHandler() {
+        const handler = new ManualTickHandler();
+        return this._mode = "manual", this.tickerHandler && this.tickerHandler.release(), this.tickerHandler = handler, !0;
+      }
+      tickAt(time) {
+        this.tickerHandler.tick(time - Math.max(this.lastFrameTime, 0), handler => {
+          this.handleTick(handler, {
+            once: !0
+          });
+        });
+      }
+      ifCanStop() {
+        return !1;
+      }
+    }
+
     class Easing {
       constructor() {}
       static linear(t) {
@@ -13371,6 +13425,186 @@
         } else out.text = this.toText.substr(0, count);
       }
     }
+    class StreamLight extends ACustomAnimate {
+      constructor(from, to, duration, easing, params) {
+        super(from, to, duration, easing, params);
+      }
+      getEndProps() {
+        return {};
+      }
+      onStart() {
+        this.target && ("rect" === this.target.type ? this.onStartRect() : "line" === this.target.type ? this.onStartLineOrArea("line") : "area" === this.target.type && this.onStartLineOrArea("area"));
+      }
+      onStartLineOrArea(type) {
+        var _a;
+        const root = this.target.attachShadow(),
+          line = application.graphicService.creator[type](Object.assign({}, null === (_a = this.params) || void 0 === _a ? void 0 : _a.attribute));
+        this[type] = line, line.pathProxy = new CustomPath2D(), root.add(line);
+      }
+      onStartRect() {
+        var _a, _b, _c;
+        const root = this.target.attachShadow(),
+          isHorizontal = null === (_b = null === (_a = this.params) || void 0 === _a ? void 0 : _a.isHorizontal) || void 0 === _b || _b,
+          sizeAttr = isHorizontal ? "height" : "width",
+          otherSizeAttr = isHorizontal ? "width" : "height",
+          size = this.target.AABBBounds[sizeAttr](),
+          y = isHorizontal ? 0 : this.target.AABBBounds.y1,
+          rect = application.graphicService.creator.rect(Object.assign(Object.assign({
+            [sizeAttr]: size,
+            fill: "#bcdeff",
+            shadowBlur: 30,
+            shadowColor: "#bcdeff"
+          }, null === (_c = this.params) || void 0 === _c ? void 0 : _c.attribute), {
+            x: 0,
+            y: y,
+            [otherSizeAttr]: 0
+          }));
+        this.rect = rect, root.add(rect);
+      }
+      onBind() {}
+      onEnd() {
+        this.target.detachShadow();
+      }
+      onUpdate(end, ratio, out) {
+        return this.rect ? this.onUpdateRect(end, ratio, out) : this.line || this.area ? this.onUpdateLineOrArea(end, ratio, out) : void 0;
+      }
+      onUpdateRect(end, ratio, out) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+        const isHorizontal = null === (_b = null === (_a = this.params) || void 0 === _a ? void 0 : _a.isHorizontal) || void 0 === _b || _b,
+          parentAttr = this.target.attribute;
+        if (isHorizontal) {
+          const parentWidth = null !== (_d = null !== (_c = parentAttr.width) && void 0 !== _c ? _c : Math.abs(parentAttr.x1 - parentAttr.x)) && void 0 !== _d ? _d : 250,
+            streamLength = null !== (_f = null === (_e = this.params) || void 0 === _e ? void 0 : _e.streamLength) && void 0 !== _f ? _f : parentWidth,
+            maxLength = null !== (_j = null === (_h = null === (_g = this.params) || void 0 === _g ? void 0 : _g.attribute) || void 0 === _h ? void 0 : _h.width) && void 0 !== _j ? _j : 60,
+            startX = -maxLength,
+            currentX = startX + (streamLength - startX) * ratio,
+            x = Math.max(currentX, 0),
+            w = Math.min(Math.min(currentX + maxLength, maxLength), streamLength - currentX),
+            width = w + x > parentWidth ? Math.max(parentWidth - x, 0) : w;
+          this.rect.setAttributes({
+            x: x,
+            width: width,
+            dx: Math.min(parentAttr.x1 - parentAttr.x, 0)
+          }, !1, {
+            type: AttributeUpdateType.ANIMATE_PLAY,
+            animationState: {
+              ratio: ratio,
+              end: end
+            }
+          });
+        } else {
+          const parentHeight = null !== (_l = null !== (_k = parentAttr.height) && void 0 !== _k ? _k : Math.abs(parentAttr.y1 - parentAttr.y)) && void 0 !== _l ? _l : 250,
+            streamLength = null !== (_o = null === (_m = this.params) || void 0 === _m ? void 0 : _m.streamLength) && void 0 !== _o ? _o : parentHeight,
+            maxLength = null !== (_r = null === (_q = null === (_p = this.params) || void 0 === _p ? void 0 : _p.attribute) || void 0 === _q ? void 0 : _q.height) && void 0 !== _r ? _r : 60,
+            currentY = parentHeight - (streamLength + maxLength) * ratio;
+          let y = Math.min(currentY, parentHeight);
+          const h = Math.min(parentHeight - currentY, maxLength);
+          let height;
+          y <= 0 ? (height = Math.max(y + h, 0), y = 0) : height = h, this.rect.setAttributes({
+            y: y,
+            height: height,
+            dy: Math.min(parentAttr.y1 - parentAttr.y, 0)
+          }, !1, {
+            type: AttributeUpdateType.ANIMATE_PLAY,
+            animationState: {
+              ratio: ratio,
+              end: end
+            }
+          });
+        }
+      }
+      onUpdateLineOrArea(end, ratio, out) {
+        const target = this.line || this.area;
+        if (!target) return;
+        const customPath = target.pathProxy,
+          targetLine = this.target;
+        targetLine.cache || targetLine.cacheArea ? this._onUpdateLineOrAreaWithCache(customPath, targetLine, end, ratio, out) : this._onUpdateLineWithoutCache(customPath, targetLine, end, ratio, out);
+        const targetAttrs = targetLine.attribute;
+        target.setAttributes(Object.assign({
+          stroke: targetAttrs.stroke
+        }, target.attribute)), target.addUpdateBoundTag();
+      }
+      _onUpdateLineOrAreaWithCache(customPath, g, end, ratio, out) {
+        var _a, _b;
+        if (customPath.clear(), "line" === g.type) {
+          let cache = g.cache;
+          Array.isArray(cache) || (cache = [cache]);
+          const totalLen = cache.reduce((l, c) => l + c.getLength(), 0),
+            curves = [];
+          return cache.forEach(c => {
+            c.curves.forEach(ci => curves.push(ci));
+          }), this._updateCurves(customPath, curves, totalLen, ratio);
+        }
+        if ("area" === g.type && (null === (_b = null === (_a = g.cacheArea) || void 0 === _a ? void 0 : _a.top) || void 0 === _b ? void 0 : _b.curves)) {
+          const cache = g.cacheArea,
+            totalLen = cache.top.curves.reduce((a, b) => a + b.getLength(), 0);
+          return this._updateCurves(customPath, cache.top.curves, totalLen, ratio);
+        }
+      }
+      _updateCurves(customPath, curves, totalLen, ratio) {
+        var _a, _b;
+        const startLen = totalLen * ratio,
+          endLen = Math.min(null !== (_b = startLen + (null === (_a = this.params) || void 0 === _a ? void 0 : _a.streamLength)) && void 0 !== _b ? _b : 10, totalLen);
+        let lastLen = 0,
+          start = !1;
+        for (let i = 0; i < curves.length; i++) if (!1 !== curves[i].defined) {
+          const curveItem = curves[i],
+            len = curveItem.getLength(),
+            startPercent = 1 - (lastLen + len - startLen) / len;
+          let curveForStart,
+            endPercent = 1 - (lastLen + len - endLen) / len;
+          if (lastLen < startLen && lastLen + len > startLen) if (start = !0, curveItem.p2 && curveItem.p3) {
+            const [_, curve2] = divideCubic(curveItem, startPercent);
+            customPath.moveTo(curve2.p0.x, curve2.p0.y), curveForStart = curve2;
+          } else {
+            const p = curveItem.getPointAt(startPercent);
+            customPath.moveTo(p.x, p.y);
+          }
+          if (lastLen < endLen && lastLen + len > endLen) {
+            if (curveItem.p2 && curveItem.p3) {
+              curveForStart && (endPercent = (endLen - startLen) / curveForStart.getLength());
+              const [curve1] = divideCubic(curveForStart || curveItem, endPercent);
+              customPath.bezierCurveTo(curve1.p1.x, curve1.p1.y, curve1.p2.x, curve1.p2.y, curve1.p3.x, curve1.p3.y);
+            } else {
+              const p = curveItem.getPointAt(endPercent);
+              customPath.lineTo(p.x, p.y);
+            }
+            break;
+          }
+          if (start) if (curveItem.p2 && curveItem.p3) {
+            const curve = curveForStart || curveItem;
+            customPath.bezierCurveTo(curve.p1.x, curve.p1.y, curve.p2.x, curve.p2.y, curve.p3.x, curve.p3.y);
+          } else customPath.lineTo(curveItem.p1.x, curveItem.p1.y);
+          lastLen += len;
+        }
+      }
+      _onUpdateLineWithoutCache(customPath, line, end, ratio, out) {
+        var _a, _b;
+        const {
+          points: points,
+          curveType: curveType
+        } = line.attribute;
+        if (!points || points.length < 2 || "linear" !== curveType) return;
+        let totalLen = 0;
+        for (let i = 1; i < points.length; i++) totalLen += PointService.distancePP(points[i], points[i - 1]);
+        const startLen = totalLen * ratio,
+          endLen = Math.min(null !== (_b = startLen + (null === (_a = this.params) || void 0 === _a ? void 0 : _a.streamLength)) && void 0 !== _b ? _b : 10, totalLen),
+          nextPoints = [];
+        let lastLen = 0;
+        for (let i = 1; i < points.length; i++) {
+          const len = PointService.distancePP(points[i], points[i - 1]);
+          if (lastLen < startLen && lastLen + len > startLen && nextPoints.push(PointService.pointAtPP(points[i - 1], points[i], 1 - (lastLen + len - startLen) / len)), lastLen < endLen && lastLen + len > endLen) {
+            nextPoints.push(PointService.pointAtPP(points[i - 1], points[i], 1 - (lastLen + len - endLen) / len));
+            break;
+          }
+          nextPoints.length && nextPoints.push(points[i]), lastLen += len;
+        }
+        if (nextPoints.length && !(nextPoints.length < 2)) {
+          customPath.clear(), customPath.moveTo(nextPoints[0].x, nextPoints[0].y);
+          for (let i = 1; i < nextPoints.length; i++) customPath.lineTo(nextPoints[i].x, nextPoints[i].y);
+        }
+      }
+    }
     class TagPointsUpdate extends ACustomAnimate {
       constructor(from, to, duration, easing, params) {
         var _a, _b;
@@ -48443,9 +48677,9 @@ C0.3-1.4,0.3-1.4,0.3-1.4z;`;
                     var _a, _b;
                     const groupValues = stackCache.nodes[group];
                     let value;
-                    if (s.bandField) {
+                    if (s.bandWidthField) {
                         value =
-                            (_b = (_a = groupValues.values.find(v => isValid$1(v[s.bandField]))) === null || _a === void 0 ? void 0 : _a[s.bandField]) !== null && _b !== void 0 ? _b : groupValues.total;
+                            (_b = (_a = groupValues.values.find(v => isValid$1(v[s.bandWidthField]))) === null || _a === void 0 ? void 0 : _a[s.bandWidthField]) !== null && _b !== void 0 ? _b : groupValues.total;
                     }
                     else {
                         value = groupValues.total;
@@ -49333,6 +49567,7 @@ C0.3-1.4,0.3-1.4,0.3-1.4z;`;
         if (prev === next) return !0;
         if (typeof prev != typeof next) return !1;
         if (isString$1(prev)) return !1;
+        if (isArray$1(prev)) return prev.length === next.length && prev.every((prevEntry, index) => isColorAttrEqual(prevEntry, next[index]));
         if (prev.gradient !== next.gradient) return !1;
         const prevKeys = Object.keys(prev),
           nextKeys = Object.keys(next);
@@ -49930,7 +50165,7 @@ C0.3-1.4,0.3-1.4,0.3-1.4z;`;
           if (element) {
             const hasActiveElement = this._marks && this._marks.includes(element.mark);
             "view" !== this._resetType || hasActiveElement ? "self" === this._resetType && hasActiveElement && this.resetAll() : this.resetAll();
-          }
+          } else "view" === this._resetType && this.resetAll();
         }, this.options = Object.assign({}, ElementHighlight.defaultOptions, options), this._marks = view.getMarksBySelector(this.options.selector), this._stateMarks = groupMarksByState(this._marks, [this.options.highlightState, this.options.blurState]);
       }
       getStartState() {
@@ -55912,26 +56147,29 @@ C0.3-1.4,0.3-1.4,0.3-1.4z;`;
         points: getCenterPoints(element, options)
       }
     });
-    const changePointsX = (element, options, animationParameters) => element.getGraphicAttribute("points", !1).map(point => {
+    const changePointsX = (element, options, animationParameters) => {
       var _a;
-      if (options && "negative" === options.orient) {
-        let groupRight = animationParameters.width;
-        return animationParameters.group && (groupRight = null !== (_a = animationParameters.groupWidth) && void 0 !== _a ? _a : animationParameters.group.getBounds().width(), animationParameters.groupWidth = groupRight), Object.assign(Object.assign({}, point), {
-          x: groupRight,
+      return (null !== (_a = element.getGraphicAttribute("points", !1)) && void 0 !== _a ? _a : []).map(point => {
+        var _a;
+        if (options && "negative" === options.orient) {
+          let groupRight = animationParameters.width;
+          return animationParameters.group && (groupRight = null !== (_a = animationParameters.groupWidth) && void 0 !== _a ? _a : animationParameters.group.getBounds().width(), animationParameters.groupWidth = groupRight), Object.assign(Object.assign({}, point), {
+            x: groupRight,
+            y: point.y,
+            x1: groupRight,
+            y1: point.y1,
+            defined: !1 !== point.defined
+          });
+        }
+        return Object.assign(Object.assign({}, point), {
+          x: 0,
           y: point.y,
-          x1: groupRight,
+          x1: 0,
           y1: point.y1,
           defined: !1 !== point.defined
         });
-      }
-      return Object.assign(Object.assign({}, point), {
-        x: 0,
-        y: point.y,
-        x1: 0,
-        y1: point.y1,
-        defined: !1 !== point.defined
       });
-    });
+    };
     const growPointsXIn = (element, options, animationParameters) => ({
       from: {
         points: changePointsX(element, options, animationParameters)
@@ -55948,26 +56186,29 @@ C0.3-1.4,0.3-1.4,0.3-1.4z;`;
         points: changePointsX(element, options, animationParameters)
       }
     });
-    const changePointsY = (element, options, animationParameters) => element.getGraphicAttribute("points", !1).map(point => {
+    const changePointsY = (element, options, animationParameters) => {
       var _a;
-      if (options && "negative" === options.orient) {
-        let groupBottom = animationParameters.height;
-        return animationParameters.group && (groupBottom = null !== (_a = animationParameters.groupHeight) && void 0 !== _a ? _a : animationParameters.group.getBounds().height(), animationParameters.groupHeight = groupBottom), Object.assign(Object.assign({}, point), {
+      return (null !== (_a = element.getGraphicAttribute("points", !1)) && void 0 !== _a ? _a : []).map(point => {
+        var _a;
+        if (options && "negative" === options.orient) {
+          let groupBottom = animationParameters.height;
+          return animationParameters.group && (groupBottom = null !== (_a = animationParameters.groupHeight) && void 0 !== _a ? _a : animationParameters.group.getBounds().height(), animationParameters.groupHeight = groupBottom), Object.assign(Object.assign({}, point), {
+            x: point.x,
+            y: groupBottom,
+            x1: point.x1,
+            y1: groupBottom,
+            defined: !1 !== point.defined
+          });
+        }
+        return Object.assign(Object.assign({}, point), {
           x: point.x,
-          y: groupBottom,
+          y: 0,
           x1: point.x1,
-          y1: groupBottom,
+          y1: 0,
           defined: !1 !== point.defined
         });
-      }
-      return Object.assign(Object.assign({}, point), {
-        x: point.x,
-        y: 0,
-        x1: point.x1,
-        y1: 0,
-        defined: !1 !== point.defined
       });
-    });
+    };
     const growPointsYIn = (element, options, animationParameters) => ({
       from: {
         points: changePointsY(element, options, animationParameters)
@@ -63882,7 +64123,7 @@ C0.3-1.4,0.3-1.4,0.3-1.4z;`;
     };
     registerVChartCore();
 
-    const version = "1.13.10-alpha.1";
+    const version = "1.13.10";
 
     const addVChartProperty = (data, op) => {
         const context = op.beforeCall();
@@ -90018,8 +90259,8 @@ C0.3-1.4,0.3-1.4,0.3-1.4z;`;
             this.type = exports.SeriesTypeEnum.mosaic;
             this.transformerConstructor = BarSeriesSpecTransformer;
         }
-        get bandField() {
-            return this._bandField;
+        get bandWidthField() {
+            return this._bandWidthField;
         }
         getStack() {
             return true;
@@ -90049,8 +90290,8 @@ C0.3-1.4,0.3-1.4,0.3-1.4z;`;
                 this.setFieldX(MOSAIC_CAT_END_PERCENT);
                 this.setFieldX2(MOSAIC_CAT_START_PERCENT);
             }
-            if (this._spec.bandField) {
-                this._bandField = this._spec.bandField;
+            if (this._spec.bandWidthField) {
+                this._bandWidthField = this._spec.bandWidthField;
             }
         }
         parseLabelStyle(labelStyle, labelSpec) {
@@ -94277,18 +94518,17 @@ C0.3-1.4,0.3-1.4,0.3-1.4z;`;
             if (!this._needInitEventOfTooltip) {
                 return;
             }
-            const container = (_b = (_a = this.tooltipHandler).getTooltipContainer) === null || _b === void 0 ? void 0 : _b.call(_a);
-            const element = container === null || container === void 0 ? void 0 : container.firstChild;
-            if (element) {
-                element.addEventListener('pointerenter', () => {
+            const container = (_b = (_a = this.tooltipHandler).getRootDom) === null || _b === void 0 ? void 0 : _b.call(_a);
+            if (container) {
+                container.addEventListener('pointerenter', () => {
                     var _a;
                     if (!this._enterable) {
                         return;
                     }
                     this._isEnterTooltip = true;
-                    const rect = (_a = element.getBoundingClientRect) === null || _a === void 0 ? void 0 : _a.call(element);
+                    const rect = (_a = container.getBoundingClientRect) === null || _a === void 0 ? void 0 : _a.call(container);
                     if (rect) {
-                        this._cacheEnterableRect = { x: rect.x, y: rect.y, width: rect.width, height: rect.height };
+                        this._cacheEnterableRect = { width: rect.width, height: rect.height };
                     }
                     if (this._outTimer) {
                         clearTimeout(this._outTimer);
@@ -94299,14 +94539,14 @@ C0.3-1.4,0.3-1.4,0.3-1.4z;`;
                         this._showTimer = null;
                     }
                 });
-                element.addEventListener('pointerleave', () => {
+                container.addEventListener('pointerleave', () => {
                     var _a, _b, _c;
                     if (!this._enterable) {
                         return;
                     }
                     this._isEnterTooltip = false;
                     if (this._cacheEnterableRect) {
-                        const newRect = (_a = element.getBoundingClientRect) === null || _a === void 0 ? void 0 : _a.call(element);
+                        const newRect = (_a = container.getBoundingClientRect) === null || _a === void 0 ? void 0 : _a.call(container);
                         if (newRect &&
                             Object.keys(this._cacheEnterableRect).every(k => this._cacheEnterableRect[k] === newRect[k])) {
                             this._cacheEnterableRect = null;
@@ -102720,6 +102960,9 @@ C0.3-1.4,0.3-1.4,0.3-1.4z;`;
                 this._rootDom.style.visibility = _value ? 'visible' : 'hidden';
             }
         }
+        getRootDom() {
+            return this._rootDom;
+        }
         constructor() {
             super(DomTooltipHandler.type);
             this.type = TooltipHandlerType.dom;
@@ -103653,7 +103896,7 @@ C0.3-1.4,0.3-1.4,0.3-1.4z;`;
                 'barMinHeight',
                 'stackCornerRadius',
                 'bar',
-                'bandField'
+                'bandWidthField'
             ]);
         }
         transformSpec(spec) {
@@ -104216,6 +104459,7 @@ C0.3-1.4,0.3-1.4,0.3-1.4z;`;
     exports.MOSAIC_CAT_START_PERCENT = MOSAIC_CAT_START_PERCENT;
     exports.MOSAIC_VALUE_END_PERCENT = MOSAIC_VALUE_END_PERCENT;
     exports.MOSAIC_VALUE_START_PERCENT = MOSAIC_VALUE_START_PERCENT;
+    exports.ManualTicker = ManualTicker;
     exports.MapChart = MapChart;
     exports.MapLabelComponent = MapLabelComponent;
     exports.MapSeries = MapSeries;
@@ -104276,6 +104520,7 @@ C0.3-1.4,0.3-1.4,0.3-1.4z;`;
     exports.ScatterSeries = ScatterSeries;
     exports.ScrollBar = ScrollBar;
     exports.SequenceChart = SequenceChart;
+    exports.StreamLight = StreamLight;
     exports.SunburstChart = SunburstChart;
     exports.SunburstSeries = SunburstSeries;
     exports.SymbolMark = SymbolMark;