@visactor/vchart-extension 2.1.5 → 2.1.6-alpha.1

package/build/index.js

@@ -6451,18 +6451,21 @@
       }
     }
 
-    function getScaledStroke(context, width, dpr) {
+    function getScaledStrokeWithMatrix(matrix, width, dpr) {
       let strokeWidth = width;
       const {
           a: a,
           b: b,
           c: c,
           d: d
-        } = context.currentMatrix,
+        } = matrix,
         scaleX = Math.sign(a) * Math.sqrt(a * a + b * b),
         scaleY = Math.sign(d) * Math.sqrt(c * c + d * d);
       return scaleX + scaleY === 0 ? 0 : (strokeWidth = strokeWidth / Math.abs(scaleX + scaleY) * 2 * dpr, strokeWidth);
     }
+    function getScaledStroke(context, width, dpr) {
+      return getScaledStrokeWithMatrix(context.currentMatrix, width, dpr);
+    }
     function createColor(context, c, params, offsetX = 0, offsetY = 0) {
       var _a, _b, _c, _d;
       if (!c || !0 === c) return "black";
@@ -7164,7 +7167,7 @@
     }
     class StateTransitionOrchestrator {
       analyzeTransition(targetAttrs, hasAnimation, options = {}) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         const plan = {
           targetAttrs: Object.assign({}, targetAttrs),
           animateAttrs: {},
@@ -7173,10 +7176,17 @@
         if (!hasAnimation) return plan;
         const noWorkAnimateAttr = Object.assign(Object.assign({}, null !== (_a = options.noWorkAnimateAttr) && void 0 !== _a ? _a : {}), normalizeNoAnimateAttrConfig(null === (_b = options.animateConfig) || void 0 === _b ? void 0 : _b.noAnimateAttrs)),
           isClear = !0 === options.isClear,
-          readDefaultAttribute = options.getDefaultAttribute,
+          getDefaultAttribute = options.getDefaultAttribute,
+          readDefaultAttribute = getDefaultAttribute,
+          readStateTransitionDefaultAttribute = null !== (_c = options.getStateTransitionDefaultAttribute) && void 0 !== _c ? _c : getDefaultAttribute,
           shouldSkipDefaultAttribute = options.shouldSkipDefaultAttribute,
-          assignTransitionAttr = (key, value) => {
-            if (noWorkAnimateAttr[key]) plan.noAnimateAttrs[key] = value;else if (isClear && void 0 === value) {
+          stateTransitionTargetAttrs = null !== (_d = options.stateTransitionTargetAttrs) && void 0 !== _d ? _d : targetAttrs,
+          assignTransitionAttr = (key, value, isRemovedStateAttr = !1) => {
+            if (noWorkAnimateAttr[key]) plan.noAnimateAttrs[key] = value;else if (isRemovedStateAttr && void 0 === value) {
+              const defaultValue = null == readStateTransitionDefaultAttribute ? void 0 : readStateTransitionDefaultAttribute(key, stateTransitionTargetAttrs);
+              if (void 0 === defaultValue && (null == shouldSkipDefaultAttribute ? void 0 : shouldSkipDefaultAttribute(key, stateTransitionTargetAttrs))) return;
+              plan.animateAttrs[key] = defaultValue;
+            } else if (isClear && void 0 === value) {
               if (null == shouldSkipDefaultAttribute ? void 0 : shouldSkipDefaultAttribute(key, targetAttrs)) return;
               plan.animateAttrs[key] = readDefaultAttribute(key);
             } else plan.animateAttrs[key] = value;
@@ -7188,7 +7198,7 @@
         const extraAnimateAttrs = options.extraAnimateAttrs;
         if (extraAnimateAttrs) for (const key in extraAnimateAttrs) {
           const hasTargetAttr = Object.prototype.hasOwnProperty.call(targetAttrs, key);
-          !Object.prototype.hasOwnProperty.call(extraAnimateAttrs, key) || hasTargetAttr && void 0 !== targetAttrs[key] || assignTransitionAttr(key, extraAnimateAttrs[key]);
+          !Object.prototype.hasOwnProperty.call(extraAnimateAttrs, key) || hasTargetAttr && void 0 !== targetAttrs[key] || assignTransitionAttr(key, extraAnimateAttrs[key], !0);
         }
         return plan;
       }
@@ -7220,9 +7230,11 @@
           noWorkAnimateAttr: graphic.getNoWorkAnimateAttr(),
           isClear: !0,
           getDefaultAttribute: graphic.getDefaultAttribute.bind(graphic),
+          getStateTransitionDefaultAttribute: options.getStateTransitionDefaultAttribute,
           shouldSkipDefaultAttribute: null !== (_a = options.shouldSkipDefaultAttribute) && void 0 !== _a ? _a : graphic.shouldSkipStateTransitionDefaultAttribute.bind(graphic),
           animateConfig: options.animateConfig,
-          extraAnimateAttrs: options.extraAnimateAttrs
+          extraAnimateAttrs: options.extraAnimateAttrs,
+          stateTransitionTargetAttrs: options.stateTransitionTargetAttrs
         });
         return this.applyTransition(graphic, plan, hasAnimation, options);
       }
@@ -7497,21 +7509,20 @@
         }), snapshot) : snapshot;
       }
       buildRemovedStateAnimationAttrs(targetStateAttrs, previousResolvedStatePatch) {
-        const extraAttrs = {};
-        if (!previousResolvedStatePatch) return extraAttrs;
+        if (!previousResolvedStatePatch) return;
         const snapshot = this.buildStaticAttributeSnapshot(),
-          staticTargetAttrs = snapshot;
+          extraAttrs = {};
         return Object.keys(previousResolvedStatePatch).forEach(key => {
           const hasTargetAttr = Object.prototype.hasOwnProperty.call(targetStateAttrs, key);
           if (hasTargetAttr && void 0 !== targetStateAttrs[key]) return;
           const assignFallbackAttr = value => {
-            void 0 === value && this.shouldSkipStateTransitionDefaultAttribute(key, staticTargetAttrs) || (extraAttrs[key] = void 0 === value ? value : cloneAttributeValue(value));
+            extraAttrs[key] = void 0 === value ? value : cloneAttributeValue(value);
           };
-          if (hasTargetAttr) assignFallbackAttr(this.getStateTransitionDefaultAttribute(key, staticTargetAttrs));else if (Object.prototype.hasOwnProperty.call(snapshot, key)) {
-            const snapshotValue = snapshot[key];
-            assignFallbackAttr(void 0 === snapshotValue ? this.getStateTransitionDefaultAttribute(key, staticTargetAttrs) : snapshotValue);
-          } else assignFallbackAttr(this.getStateTransitionDefaultAttribute(key, staticTargetAttrs));
-        }), extraAttrs;
+          hasTargetAttr ? assignFallbackAttr(targetStateAttrs[key]) : Object.prototype.hasOwnProperty.call(snapshot, key) ? assignFallbackAttr(snapshot[key]) : assignFallbackAttr(void 0);
+        }), {
+          extraAttrs: extraAttrs,
+          stateTransitionTargetAttrs: snapshot
+        };
       }
       syncObjectToSnapshot(target, snapshot, excludedKeys) {
         const delta = new Map();
@@ -8227,29 +8238,37 @@
             resolvedStateAttrs: resolvedStateAttrs
           } = this.resolveGraphicStateTransition(states, !0),
           patchChanged = !this.sameStatePatches(previousResolvedStatePatch, resolvedStateAttrs);
-        patchChanged && !this.beforeStateUpdate(resolvedStateAttrs, previousStates, transition.states, hasAnimation, !1) || (this.currentStates = transition.states, this.effectiveStates = [...effectiveStates], this.resolvedStatePatch = resolvedStateAttrs, this.sharedStateDirty = !1, this.syncSharedStateActiveRegistrations(), patchChanged && (hasAnimation && animateSameStatePatchChange ? (this._syncFinalAttributeFromStaticTruth(), this.applyStateAttrs(resolvedStateAttrs, transition.states, hasAnimation, !1, void 0, this.buildRemovedStateAnimationAttrs(resolvedStateAttrs, previousResolvedStatePatch))) : (this.stopStateAnimates(), this.attributeMayContainTransientAttrs ? this._restoreAttributeFromStaticTruth({
+        if ((!patchChanged || this.beforeStateUpdate(resolvedStateAttrs, previousStates, transition.states, hasAnimation, !1)) && (this.currentStates = transition.states, this.effectiveStates = [...effectiveStates], this.resolvedStatePatch = resolvedStateAttrs, this.sharedStateDirty = !1, this.syncSharedStateActiveRegistrations(), patchChanged)) if (hasAnimation && animateSameStatePatchChange) {
+          this._syncFinalAttributeFromStaticTruth();
+          const removedStateAnimationAttrs = this.buildRemovedStateAnimationAttrs(resolvedStateAttrs, previousResolvedStatePatch);
+          this.applyStateAttrs(resolvedStateAttrs, transition.states, hasAnimation, !1, void 0, null == removedStateAnimationAttrs ? void 0 : removedStateAnimationAttrs.extraAttrs, null == removedStateAnimationAttrs ? void 0 : removedStateAnimationAttrs.stateTransitionTargetAttrs);
+        } else this.stopStateAnimates(), this.attributeMayContainTransientAttrs ? this._restoreAttributeFromStaticTruth({
           type: AttributeUpdateType.STATE
         }) : this.restoreAttributeFromStatePatchDelta(previousResolvedStatePatch, this.resolvedStatePatch, {
           type: AttributeUpdateType.STATE
-        }), this.emitStateUpdateEvent())));
+        }), this.emitStateUpdateEvent();
       }
       resolveStateAnimateConfig(animateConfig) {
         var _a, _b, _c;
         return null !== (_c = null !== (_a = null != animateConfig ? animateConfig : this.stateAnimateConfig) && void 0 !== _a ? _a : null === (_b = this.context) || void 0 === _b ? void 0 : _b.stateAnimateConfig) && void 0 !== _c ? _c : DefaultStateAnimateConfig;
       }
-      applyStateAttrs(attrs, stateNames, hasAnimation, isClear, animateConfig, extraAnimateAttrs) {
+      applyStateAttrs(attrs, stateNames, hasAnimation, isClear, animateConfig, extraAnimateAttrs, stateTransitionTargetAttrs) {
         const resolvedAnimateConfig = hasAnimation ? this.resolveStateAnimateConfig(animateConfig) : void 0,
           transitionOptions = resolvedAnimateConfig ? {
             animateConfig: resolvedAnimateConfig,
             extraAnimateAttrs: extraAnimateAttrs,
-            shouldSkipDefaultAttribute: this.shouldSkipStateTransitionDefaultAttribute.bind(this)
+            getStateTransitionDefaultAttribute: this.getStateTransitionDefaultAttribute.bind(this),
+            shouldSkipDefaultAttribute: this.shouldSkipStateTransitionDefaultAttribute.bind(this),
+            stateTransitionTargetAttrs: stateTransitionTargetAttrs
           } : void 0;
         if (isClear) return void this.getStateTransitionOrchestrator().applyClearTransition(this, attrs, hasAnimation, transitionOptions);
         const plan = this.getStateTransitionOrchestrator().analyzeTransition(attrs, hasAnimation, {
           noWorkAnimateAttr: this.getNoWorkAnimateAttr(),
           animateConfig: resolvedAnimateConfig,
           extraAnimateAttrs: extraAnimateAttrs,
-          shouldSkipDefaultAttribute: this.shouldSkipStateTransitionDefaultAttribute.bind(this)
+          getStateTransitionDefaultAttribute: this.getStateTransitionDefaultAttribute.bind(this),
+          shouldSkipDefaultAttribute: this.shouldSkipStateTransitionDefaultAttribute.bind(this),
+          stateTransitionTargetAttrs: stateTransitionTargetAttrs
         });
         this.getStateTransitionOrchestrator().applyTransition(this, plan, hasAnimation, transitionOptions);
       }
@@ -8276,11 +8295,15 @@
           transition = this.resolveClearStatesTransition();
         if (!transition.changed && 0 === previousStates.length) return this.currentStates = [], this.effectiveStates = [], this.resolvedStatePatch = void 0, this.sharedStateDirty = !1, void this.clearSharedStateActiveRegistrations();
         const resolvedStateAttrs = hasAnimation || this.hasCustomEvent("beforeStateUpdate") ? cloneAttributeValue(null !== (_b = this.baseAttributes) && void 0 !== _b ? _b : {}) : null !== (_c = this.baseAttributes) && void 0 !== _c ? _c : {};
-        transition.changed && !this.beforeStateUpdate(resolvedStateAttrs, previousStates, transition.states, hasAnimation, !0) || (this.currentStates = transition.states, this.effectiveStates = [], this.resolvedStatePatch = void 0, this.sharedStateDirty = !1, this.clearSharedStateActiveRegistrations(), hasAnimation ? (this._syncFinalAttributeFromStaticTruth(), this.applyStateAttrs(resolvedStateAttrs, transition.states, hasAnimation, !0, void 0, this.buildRemovedStateAnimationAttrs(resolvedStateAttrs, previousResolvedStatePatch))) : (this.stopStateAnimates(), this.attributeMayContainTransientAttrs ? this._restoreAttributeFromStaticTruth({
+        if (!transition.changed || this.beforeStateUpdate(resolvedStateAttrs, previousStates, transition.states, hasAnimation, !0)) if (this.currentStates = transition.states, this.effectiveStates = [], this.resolvedStatePatch = void 0, this.sharedStateDirty = !1, this.clearSharedStateActiveRegistrations(), hasAnimation) {
+          this._syncFinalAttributeFromStaticTruth();
+          const removedStateAnimationAttrs = this.buildRemovedStateAnimationAttrs(resolvedStateAttrs, previousResolvedStatePatch);
+          this.applyStateAttrs(resolvedStateAttrs, transition.states, hasAnimation, !0, void 0, null == removedStateAnimationAttrs ? void 0 : removedStateAnimationAttrs.extraAttrs, null == removedStateAnimationAttrs ? void 0 : removedStateAnimationAttrs.stateTransitionTargetAttrs);
+        } else this.stopStateAnimates(), this.attributeMayContainTransientAttrs ? this._restoreAttributeFromStaticTruth({
           type: AttributeUpdateType.STATE
         }) : this.restoreAttributeFromStatePatchDelta(previousResolvedStatePatch, void 0, {
           type: AttributeUpdateType.STATE
-        }), this.emitStateUpdateEvent()));
+        }), this.emitStateUpdateEvent();
       }
       removeState(stateName, hasAnimation) {
         const transition = this.resolveRemoveStateTransition(stateName);
@@ -8321,11 +8344,15 @@
             effectiveStates: effectiveStates,
             resolvedStateAttrs: resolvedStateAttrs
           } = this.resolveGraphicStateTransition(states);
-        !transition.changed && this.sameStateNames(previousStates, transition.states) || this.beforeStateUpdate(resolvedStateAttrs, previousStates, transition.states, hasAnimation, !1) && (this.currentStates = transition.states, this.effectiveStates = [...effectiveStates], this.resolvedStatePatch = resolvedStateAttrs, this.sharedStateDirty = !1, this.syncSharedStateActiveRegistrations(), hasAnimation ? (this._syncFinalAttributeFromStaticTruth(), this.applyStateAttrs(resolvedStateAttrs, transition.states, hasAnimation, !1, void 0, this.buildRemovedStateAnimationAttrs(resolvedStateAttrs, previousResolvedStatePatch))) : (this.stopStateAnimates(), this.attributeMayContainTransientAttrs ? this._restoreAttributeFromStaticTruth({
+        if ((transition.changed || !this.sameStateNames(previousStates, transition.states)) && this.beforeStateUpdate(resolvedStateAttrs, previousStates, transition.states, hasAnimation, !1)) if (this.currentStates = transition.states, this.effectiveStates = [...effectiveStates], this.resolvedStatePatch = resolvedStateAttrs, this.sharedStateDirty = !1, this.syncSharedStateActiveRegistrations(), hasAnimation) {
+          this._syncFinalAttributeFromStaticTruth();
+          const removedStateAnimationAttrs = this.buildRemovedStateAnimationAttrs(resolvedStateAttrs, previousResolvedStatePatch);
+          this.applyStateAttrs(resolvedStateAttrs, transition.states, hasAnimation, !1, void 0, null == removedStateAnimationAttrs ? void 0 : removedStateAnimationAttrs.extraAttrs, null == removedStateAnimationAttrs ? void 0 : removedStateAnimationAttrs.stateTransitionTargetAttrs);
+        } else this.stopStateAnimates(), this.attributeMayContainTransientAttrs ? this._restoreAttributeFromStaticTruth({
           type: AttributeUpdateType.STATE
         }) : this.restoreAttributeFromStatePatchDelta(previousResolvedStatePatch, this.resolvedStatePatch, {
           type: AttributeUpdateType.STATE
-        }), this.emitStateUpdateEvent()));
+        }), this.emitStateUpdateEvent();
       }
       invalidateResolver() {
         var _a, _b;
@@ -10316,7 +10343,7 @@
     }
 
     var _a;
-    const factoryRegistryKey = Symbol.for("@visactor/vchart/factory-registry@2.1.5"),
+    const factoryRegistryKey = Symbol.for("@visactor/vchart/factory-registry@2.1.4"),
       globalFactoryRegistry = globalThis;
     const factoryRegistry = null !== (_a = globalFactoryRegistry[factoryRegistryKey]) && void 0 !== _a ? _a : globalFactoryRegistry[factoryRegistryKey] = {
       charts: {},
@@ -10843,7 +10870,132 @@
       cap: 1
     }, NOWORK_ANIMATE_ATTR);
 
-    const POLYGON_UPDATE_TAG_KEY = ["points", "cornerRadius", ...GRAPHIC_UPDATE_TAG_KEY];
+    function getPolygonWinding(points) {
+      let signedArea = 0;
+      for (let i = 0; i < points.length; i++) {
+        const current = points[i],
+          next = points[(i + 1) % points.length];
+        signedArea += current.x * next.y - next.x * current.y;
+      }
+      return signedArea > 0 ? 1 : -1;
+    }
+    function offsetPolygonPoints(points, distance, closePath = !0) {
+      var _a;
+      const n = null !== (_a = null == points ? void 0 : points.length) && void 0 !== _a ? _a : 0;
+      if (n < 2 || closePath && n < 3 || !distance) return points;
+      const sign = getPolygonWinding(points),
+        edgeCount = closePath ? n : n - 1,
+        lines = [];
+      for (let i = 0; i < edgeCount; i++) {
+        const cur = points[i],
+          next = points[(i + 1) % n],
+          dx = next.x - cur.x,
+          dy = next.y - cur.y,
+          len = Math.sqrt(dx * dx + dy * dy);
+        if (!len) {
+          lines.push(null);
+          continue;
+        }
+        const offsetX = sign * dy * distance / len,
+          offsetY = -sign * dx * distance / len;
+        lines.push({
+          x: cur.x + offsetX,
+          y: cur.y + offsetY,
+          dx: dx,
+          dy: dy,
+          len: len,
+          offsetX: offsetX,
+          offsetY: offsetY
+        });
+      }
+      const prevLines = new Array(n);
+      let prevLine = null;
+      if (closePath) for (let i = edgeCount - 1; i >= 0; i--) if (lines[i]) {
+        prevLine = lines[i];
+        break;
+      }
+      for (let i = 0; i < n; i++) prevLines[i] = prevLine, i < edgeCount && lines[i] && (prevLine = lines[i]);
+      const nextLines = new Array(n);
+      let nextLine = null;
+      if (closePath) for (let count = 0; count < edgeCount; count++) {
+        const line = lines[(n - 1 + count) % edgeCount];
+        if (line) {
+          nextLine = line;
+          break;
+        }
+      }
+      for (let i = n - 1; i >= 0; i--) i < edgeCount && lines[i] && (nextLine = lines[i]), nextLines[i] = nextLine;
+      const offsetPointByLine = (point, line) => ({
+          x: point.x + line.offsetX,
+          y: point.y + line.offsetY
+        }),
+        result = [];
+      for (let i = 0; i < n; i++) {
+        const prev = prevLines[i],
+          cur = nextLines[i],
+          line = prev || cur;
+        if (!line) {
+          result.push(points[i]);
+          continue;
+        }
+        if (!prev || !cur) {
+          result.push(offsetPointByLine(points[i], line));
+          continue;
+        }
+        const denominator = prev.dx * cur.dy - prev.dy * cur.dx;
+        if (Math.abs(denominator) <= 1e-12 * prev.len * cur.len) {
+          result.push(offsetPointByLine(points[i], cur));
+          continue;
+        }
+        const t = ((cur.x - prev.x) * cur.dy - (cur.y - prev.y) * cur.dx) / denominator,
+          point = {
+            x: prev.x + prev.dx * t,
+            y: prev.y + prev.dy * t
+          };
+        result.push(Number.isFinite(point.x) && Number.isFinite(point.y) ? point : offsetPointByLine(points[i], cur));
+      }
+      return result;
+    }
+
+    const getBoundsScaleMatrix = polygon => {
+      var _a;
+      const globalMatrix = polygon.globalTransMatrix,
+        viewBoxMatrix = null === (_a = polygon.stage) || void 0 === _a ? void 0 : _a.window.getViewBoxTransform();
+      return viewBoxMatrix ? {
+        a: viewBoxMatrix.a * globalMatrix.a + viewBoxMatrix.c * globalMatrix.b,
+        b: viewBoxMatrix.b * globalMatrix.a + viewBoxMatrix.d * globalMatrix.b,
+        c: viewBoxMatrix.a * globalMatrix.c + viewBoxMatrix.c * globalMatrix.d,
+        d: viewBoxMatrix.b * globalMatrix.c + viewBoxMatrix.d * globalMatrix.d
+      } : globalMatrix;
+    };
+    const getPolygonBoundsScale = polygon => getScaledStrokeWithMatrix(getBoundsScaleMatrix(polygon), 1, 1);
+    const updateBoundsOfPolygonOuterBorder = (attribute, polygonTheme, aabbBounds, polygon) => {
+      const {
+        outerBorder: outerBorder,
+        points = polygonTheme.points,
+        closePath = polygonTheme.closePath,
+        shadowBlur = polygonTheme.shadowBlur,
+        keepStrokeScale = polygonTheme.keepStrokeScale
+      } = attribute;
+      if (outerBorder && !1 !== outerBorder.visible) {
+        const defaultOuterBorder = polygonTheme.outerBorder,
+          {
+            distance = defaultOuterBorder.distance,
+            lineWidth = defaultOuterBorder.lineWidth,
+            lineJoin = defaultOuterBorder.lineJoin,
+            strokeBoundsBuffer = defaultOuterBorder.strokeBoundsBuffer
+          } = outerBorder,
+          boundsScale = getPolygonBoundsScale(polygon);
+        let scaledDistance = distance;
+        keepStrokeScale || (scaledDistance *= boundsScale), offsetPolygonPoints(points, scaledDistance, closePath).forEach(point => {
+          aabbBounds.add(point.x, point.y);
+        });
+        boundStroke(aabbBounds, (shadowBlur * boundsScale + lineWidth * (keepStrokeScale ? 1 : boundsScale)) / 2, "miter" === lineJoin, strokeBoundsBuffer);
+      }
+      return aabbBounds;
+    };
+
+    const POLYGON_UPDATE_TAG_KEY = ["points", "cornerRadius", "outerBorder", "keepStrokeScale", ...GRAPHIC_UPDATE_TAG_KEY];
     class Polygon extends Graphic {
       constructor(params) {
         super(params), this.type = "polygon", this.numberType = POLYGON_NUMBER_TYPE;
@@ -10860,6 +11012,16 @@
       getGraphicTheme() {
         return getTheme(this).polygon;
       }
+      tryUpdateAABBBounds() {
+        const {
+          outerBorder: outerBorder
+        } = this.attribute;
+        if (outerBorder && !1 !== outerBorder.visible) {
+          const boundsScale = getPolygonBoundsScale(this);
+          boundsScale !== this._outerBorderBoundsScale && (this._outerBorderBoundsScale = boundsScale, this.addUpdateBoundTag());
+        } else this._outerBorderBoundsScale = void 0;
+        return super.tryUpdateAABBBounds();
+      }
       updateAABBBounds(attribute, polygonTheme, aabbBounds) {
         this.updatePathProxyAABBBounds(aabbBounds) || this.updatePolygonAABBBoundsImprecise(attribute, polygonTheme, aabbBounds), application.graphicService.updateTempAABBBounds(aabbBounds), this.widthWithoutTransform = aabbBounds.x2 - aabbBounds.x1, this.heightWithoutTransform = aabbBounds.y2 - aabbBounds.y1;
         const {
@@ -10873,7 +11035,7 @@
         } = attribute;
         return points.forEach(p => {
           aabbBounds.add(p.x, p.y);
-        }), aabbBounds;
+        }), updateBoundsOfPolygonOuterBorder(attribute, polygonTheme, aabbBounds, this), aabbBounds;
       }
       _interpolate(key, ratio, lastStepVal, nextStepVal, nextAttributes) {
         "points" === key && (nextAttributes.points = pointsInterpolation(lastStepVal, nextStepVal, ratio));
@@ -13118,7 +13280,8 @@
     const DrawContribution = Symbol.for("DrawContribution");
 
     const DrawItemInterceptor = Symbol.for("DrawItemInterceptor");
-    const tempDirtyBounds = new vutils.AABBBounds(),
+    const INTERACTIVE_POST_MATRIX = "_interactivePostMatrix",
+      tempDirtyBounds = new vutils.AABBBounds(),
       tempBackupDirtyBounds = new vutils.AABBBounds();
     class ShadowRootDrawItemInterceptorContribution {
       constructor() {
@@ -13182,12 +13345,23 @@
       beforeDrawItem(graphic, renderService, drawContext, drawContribution, params) {
         return !this.processing && (graphic.baseGraphic ? this.beforeDrawInteractive(graphic, renderService, drawContext, drawContribution, params) : this.beforeSetInteractive(graphic, renderService, drawContext, drawContribution, params));
       }
+      resolveInteractivePostMatrix(graphic, interactiveGraphic) {
+        const parent = graphic.parent;
+        if (!parent) return graphic.attribute.postMatrix;
+        let matrix = interactiveGraphic[INTERACTIVE_POST_MATRIX];
+        matrix || (matrix = new vutils.Matrix(), interactiveGraphic[INTERACTIVE_POST_MATRIX] = matrix);
+        const ancestorMatrix = parent.globalTransMatrix;
+        matrix.setValue(ancestorMatrix.a, ancestorMatrix.b, ancestorMatrix.c, ancestorMatrix.d, ancestorMatrix.e, ancestorMatrix.f);
+        const ownPostMatrix = graphic.attribute.postMatrix;
+        return ownPostMatrix && matrix.multiply(ownPostMatrix.a, ownPostMatrix.b, ownPostMatrix.c, ownPostMatrix.d, ownPostMatrix.e, ownPostMatrix.f), matrix;
+      }
       beforeSetInteractive(graphic, renderService, drawContext, drawContribution, params) {
         let interactiveGraphic = graphic.interactiveGraphic;
         if (graphic.attribute.globalZIndex) {
           interactiveGraphic || (interactiveGraphic = graphic.clone(), graphic.interactiveGraphic = interactiveGraphic, interactiveGraphic.baseGraphic = graphic), interactiveGraphic.setAttributes({
             globalZIndex: 0,
-            zIndex: graphic.attribute.globalZIndex
+            zIndex: graphic.attribute.globalZIndex,
+            postMatrix: this.resolveInteractivePostMatrix(graphic, interactiveGraphic)
           }, !1, {
             skipUpdateCallback: !0
           }), drawContext.stage.tryInitInteractiveLayer();