@visactor/vrender-core 0.17.8 → 0.17.10

package/dist/index.js

@@ -2139,6 +2139,15 @@
             }
         }
     }
+    function genSegContext(curveType, direction, points) {
+        const curveDirection = direction !== null && direction !== void 0 ? direction : (vutils.abs(points[points.length - 1].x - points[0].x) > vutils.abs(points[points.length - 1].y - points[0].y)
+            ? exports.Direction.ROW
+            : exports.Direction.COLUMN);
+        if (curveType === 'monotoneY') {
+            return new ReflectSegContext(curveType, curveDirection);
+        }
+        return new SegContext(curveType, curveDirection);
+    }
 
     class Linear {
         constructor(context, startPoint) {
@@ -2188,9 +2197,7 @@
         if (points.length < 2 - Number(!!startPoint)) {
             return null;
         }
-        const segContext = new SegContext('linear', direction !== null && direction !== void 0 ? direction : (vutils.abs(points[points.length - 1].x - points[0].x) > vutils.abs(points[points.length - 1].y - points[0].y)
-            ? exports.Direction.ROW
-            : exports.Direction.COLUMN));
+        const segContext = genSegContext('linear', direction, points);
         const linear = new Linear(segContext, startPoint);
         genLinearTypeSegments(linear, points);
         return segContext;
@@ -2267,9 +2274,7 @@
         if (points.length < 3 - Number(!!startPoint)) {
             return genLinearSegments(points, params);
         }
-        const segContext = new SegContext('basis', direction !== null && direction !== void 0 ? direction : (vutils.abs(points[points.length - 1].x - points[0].x) > vutils.abs(points[points.length - 1].y - points[0].y)
-            ? exports.Direction.ROW
-            : exports.Direction.COLUMN));
+        const segContext = genSegContext('basis', direction, points);
         const basis = new Basis(segContext, startPoint);
         genBasisTypeSegments(basis, points);
         return segContext;
@@ -2370,7 +2375,7 @@
             return super.point({ y: p.x, x: p.y, defined: p.defined });
         }
     }
-    function genMonotpneXTypeSegments(path, points) {
+    function genMonotoneXTypeSegments(path, points) {
         return genCurveSegments(path, points, 2);
     }
     function genMonotoneXSegments(points, params = {}) {
@@ -2381,14 +2386,12 @@
         if (points.length < 3 - Number(!!startPoint)) {
             return genLinearSegments(points, params);
         }
-        const segContext = new SegContext('monotoneX', direction !== null && direction !== void 0 ? direction : (vutils.abs(points[points.length - 1].x - points[0].x) > vutils.abs(points[points.length - 1].y - points[0].y)
-            ? exports.Direction.ROW
-            : exports.Direction.COLUMN));
+        const segContext = genSegContext('monotoneX', direction, points);
         const monotoneX = new MonotoneX(segContext, startPoint);
-        genMonotpneXTypeSegments(monotoneX, points);
+        genMonotoneXTypeSegments(monotoneX, points);
         return segContext;
     }
-    function genMonotpneYTypeSegments(path, points) {
+    function genMonotoneYTypeSegments(path, points) {
         return genCurveSegments(path, points, 2);
     }
     function genMonotoneYSegments(points, params = {}) {
@@ -2399,11 +2402,9 @@
         if (points.length < 3 - Number(!!startPoint)) {
             return genLinearSegments(points, params);
         }
-        const segContext = new ReflectSegContext('monotoneY', direction !== null && direction !== void 0 ? direction : (vutils.abs(points[points.length - 1].x - points[0].x) > vutils.abs(points[points.length - 1].y - points[0].y)
-            ? exports.Direction.ROW
-            : exports.Direction.COLUMN));
+        const segContext = genSegContext('monotoneY', direction, points);
         const monotoneY = new MonotoneY(segContext, startPoint);
-        genMonotpneYTypeSegments(monotoneY, points);
+        genMonotoneYTypeSegments(monotoneY, points);
         return segContext;
     }
 
@@ -2484,54 +2485,17 @@
         return genCurveSegments(path, points, 1);
     }
 
-    class LinearClosed {
-        constructor(context, startPoint) {
-            this.context = context;
-            startPoint && (this.startPoint = startPoint);
-        }
-        areaStart() {
-            this._line = 0;
-        }
-        areaEnd() {
-            this._line = NaN;
-        }
-        lineStart() {
-            this._point = 0;
-            this.startPoint && this.point(this.startPoint);
-        }
+    class LinearClosed extends Linear {
         lineEnd() {
             this.context.closePath();
         }
-        point(p) {
-            const x = p.x;
-            const y = p.y;
-            switch (this._point) {
-                case 0:
-                    this._point = 1;
-                    this._line
-                        ? this.context.lineTo(x, y, this._lastDefined !== false && p.defined !== false, p)
-                        : this.context.moveTo(x, y, p);
-                    break;
-                case 1:
-                    this._point = 2;
-                default:
-                    this.context.lineTo(x, y, this._lastDefined !== false && p.defined !== false, p);
-                    break;
-            }
-            this._lastDefined = p.defined;
-        }
-        tryUpdateLength() {
-            return this.context.tryUpdateLength();
-        }
     }
     function genLinearClosedSegments(points, params = {}) {
         const { direction, startPoint } = params;
         if (points.length < 2 - Number(!!startPoint)) {
             return null;
         }
-        const segContext = new SegContext('linear', direction !== null && direction !== void 0 ? direction : (vutils.abs(points[points.length - 1].x - points[0].x) > vutils.abs(points[points.length - 1].y - points[0].y)
-            ? exports.Direction.ROW
-            : exports.Direction.COLUMN));
+        const segContext = genSegContext('linear', direction, points);
         const linear = new LinearClosed(segContext, startPoint);
         genLinearClosedTypeSegments(linear, points);
         return segContext;
@@ -3174,7 +3138,7 @@
     const DefaultDebugAttribute = {
         _debug_bounds: false
     };
-    const DefaultAttribute = Object.assign(Object.assign(Object.assign({ strokeSeg: null, pickable: true, childrenPickable: true, visible: true, zIndex: 0, layout: null, boundsPadding: 0, pickMode: 'accurate', customPickShape: null, boundsMode: 'accurate', keepDirIn3d: true, shadowRootIdx: 1, globalZIndex: 1, globalCompositeOperation: '', overflow: 'hidden' }, DefaultDebugAttribute), DefaultStyle), DefaultTransform);
+    const DefaultAttribute = Object.assign(Object.assign(Object.assign({ strokeSeg: null, pickable: true, childrenPickable: true, fillPickable: true, strokePickable: true, visible: true, zIndex: 0, layout: null, boundsPadding: 0, pickMode: 'accurate', customPickShape: null, boundsMode: 'accurate', keepDirIn3d: true, shadowRootIdx: 1, globalZIndex: 1, globalCompositeOperation: '', overflow: 'hidden' }, DefaultDebugAttribute), DefaultStyle), DefaultTransform);
     function addAttributeToPrototype(obj, c, keys) {
         keys.forEach(key => {
             c.prototype[key] = obj[key];
@@ -13124,8 +13088,17 @@
             return ConicalCanvas.ctx;
         }
     }
-    class ColorInterpolate {
+    class ColorInterpolate extends vutils.LRU {
+        static getInstance() {
+            if (!ColorInterpolate._instance) {
+                ColorInterpolate._instance = new ColorInterpolate();
+            }
+            return ColorInterpolate._instance;
+        }
         constructor(stops = [], precision = 100) {
+            super();
+            this.cacheParams = { CLEAN_THRESHOLD: 100, L_TIME: 1e3 };
+            this.dataMap = new Map();
             const canvas = ConicalCanvas.GetCanvas();
             const conicalCtx = ConicalCanvas.GetCtx();
             canvas.width = precision;
@@ -13149,25 +13122,21 @@
             const rgba = this.rgbaSet.slice(4 * offset, 4 * offset + 4);
             return `rgba(${rgba[0]}, ${rgba[1]}, ${rgba[2]}, ${rgba[3] / 255})`;
         }
-        static GetOrCreate(stops = [], precision = 100) {
-            let str = '';
+        GetOrCreate(x, y, w, h, stops = [], precision = 100) {
+            let str = `${x}${y}${w}${h}`;
             stops.forEach(item => (str += item.join()));
             str += precision;
-            let colorInter = ColorInterpolate.dataMap.get(str);
+            let colorInter = this.dataMap.get(str);
             if (!colorInter) {
-                colorInter = new ColorInterpolate(stops, precision);
-                ColorInterpolate.dataMap.set(str, colorInter);
+                const data = new ColorInterpolate(stops, precision);
+                colorInter = { data, timestamp: [] };
+                this.addLimitedTimestamp(colorInter, Date.now(), {});
+                this.dataMap.set(str, colorInter);
             }
-            return colorInter;
-        }
-        static SetColorInterpolateInstance(stops, ins) {
-            ColorInterpolate.dataMap.set(stops, ins);
-        }
-        static GetColorInterpolateInstance(stops) {
-            return ColorInterpolate.dataMap.get(stops);
+            this.clearCache(this.dataMap, this.cacheParams);
+            return colorInter.data;
         }
     }
-    ColorInterpolate.dataMap = new Map();
     class ConicalPatternStore {
         static GetSize(minSize) {
             for (let i = 0; i < ConicalPatternStore.ImageSize.length; i++) {
@@ -13258,7 +13227,7 @@
         const r = Math.sqrt(Math.max(Math.max(Math.pow(x, 2) + Math.pow(y, 2), Math.pow(width - x, 2) + Math.pow(y, 2)), Math.max(Math.pow(width - x, 2) + Math.pow(height - y, 2), Math.pow(x, 2) + Math.pow(height - y, 2))));
         const stepNum = deltaDeg + 1;
         const step = deltaAngle / Math.max(1, stepNum - 1);
-        const colorInter = ColorInterpolate.GetOrCreate(stops, stepNum);
+        const colorInter = ColorInterpolate.getInstance().GetOrCreate(x, y, width, height, stops, stepNum);
         const lineWidth = (2 * Math.PI * r) / 360;
         conicalCanvas.width = width;
         conicalCanvas.height = height;
@@ -18867,6 +18836,7 @@
         __param(0, named(InteractiveSubRenderContribution)),
         __metadata("design:paramtypes", [Object])
     ], exports.DefaultBaseInteractiveRenderContribution);
+
     class DefaultBaseTextureRenderContribution {
         constructor() {
             this.time = exports.BaseRenderContributionTime.afterFillStroke;
@@ -18985,6 +18955,9 @@
             if (!texture) {
                 return;
             }
+            this.drawTexture(texture, graphic, context, x, y, graphicAttribute, textureColor, textureSize, texturePadding);
+        }
+        drawTexture(texture, graphic, context, x, y, graphicAttribute, textureColor, textureSize, texturePadding) {
             let pattern = this.textureMap.get(texture);
             if (!pattern) {
                 switch (texture) {
@@ -19586,6 +19559,25 @@
     const defaultSymbolTextureRenderContribution = defaultBaseTextureRenderContribution;
     const defaultSymbolBackgroundRenderContribution = defaultBaseBackgroundRenderContribution;
 
+    class DefaultAreaTextureRenderContribution extends DefaultBaseTextureRenderContribution {
+        constructor() {
+            super(...arguments);
+            this.time = exports.BaseRenderContributionTime.afterFillStroke;
+        }
+        drawShape(graphic, context, x, y, doFill, doStroke, fVisible, sVisible, graphicAttribute, drawContext, fillCb, strokeCb, options) {
+            var _a, _b, _c, _d;
+            if (!this.textureMap) {
+                this.initTextureMap(context, graphic.stage);
+            }
+            const { attribute = graphic.attribute } = options || {};
+            const { texture = (_a = graphic.attribute.texture) !== null && _a !== void 0 ? _a : getAttributeFromDefaultAttrList(graphicAttribute, 'texture'), textureColor = (_b = graphic.attribute.textureColor) !== null && _b !== void 0 ? _b : getAttributeFromDefaultAttrList(graphicAttribute, 'textureColor'), textureSize = (_c = graphic.attribute.textureSize) !== null && _c !== void 0 ? _c : getAttributeFromDefaultAttrList(graphicAttribute, 'textureSize'), texturePadding = (_d = graphic.attribute.texturePadding) !== null && _d !== void 0 ? _d : getAttributeFromDefaultAttrList(graphicAttribute, 'texturePadding') } = attribute;
+            if (!texture) {
+                return;
+            }
+            this.drawTexture(texture, graphic, context, x, y, graphicAttribute, textureColor, textureSize, texturePadding);
+        }
+    }
+
     exports.DefaultCanvasArcRender = class DefaultCanvasArcRender extends BaseRender {
         constructor(arcRenderContribitions) {
             super();
@@ -19865,6 +19857,31 @@
         __metadata("design:paramtypes", [Object])
     ], exports.DefaultCanvasCircleRender);
 
+    function drawSegItem(ctx, curve, endPercent, params) {
+        if (!curve.p1) {
+            return;
+        }
+        const { offsetX = 0, offsetY = 0, offsetZ = 0 } = params || {};
+        if (endPercent === 1) {
+            if (curve.p2 && curve.p3) {
+                ctx.bezierCurveTo(offsetX + curve.p1.x, offsetY + curve.p1.y, offsetX + curve.p2.x, offsetY + curve.p2.y, offsetX + curve.p3.x, offsetY + curve.p3.y, offsetZ);
+            }
+            else {
+                ctx.lineTo(offsetX + curve.p1.x, offsetY + curve.p1.y, offsetZ);
+            }
+        }
+        else {
+            if (curve.p2 && curve.p3) {
+                const [curve1] = divideCubic(curve, endPercent);
+                ctx.bezierCurveTo(offsetX + curve1.p1.x, offsetY + curve1.p1.y, offsetX + curve1.p2.x, offsetY + curve1.p2.y, offsetX + curve1.p3.x, offsetY + curve1.p3.y, offsetZ);
+            }
+            else {
+                const p = curve.getPointAt(endPercent);
+                ctx.lineTo(offsetX + p.x, offsetY + p.y, offsetZ);
+            }
+        }
+    }
+
     function drawSegments(path, segPath, percent, clipRangeByDimension, params) {
         var _a;
         const { offsetX = 0, offsetY = 0, offsetZ = 0, mode = 'none', drawConnect = false, zeroX = 0, zeroY = 0 } = params || {};
@@ -19930,7 +19947,7 @@
                     if (needMoveTo) {
                         path.moveTo(curve.p0.x + offsetX, curve.p0.y + offsetY, offsetZ);
                     }
-                    drawSegItem$1(path, curve, 1, params);
+                    drawSegItem(path, curve, 1, params);
                     needMoveTo = false;
                 });
             }
@@ -20009,7 +20026,7 @@
                 if (needMoveTo) {
                     path.moveTo(curve.p0.x + offsetX, curve.p0.y + offsetY, offsetZ);
                 }
-                drawSegItem$1(path, curve, vutils.min(_p, 1), params);
+                drawSegItem(path, curve, vutils.min(_p, 1), params);
                 needMoveTo = false;
             }
         }
@@ -20053,30 +20070,6 @@
             path.closePath();
         });
     }
-    function drawSegItem$1(ctx, curve, endPercent, params) {
-        if (!curve.p1) {
-            return;
-        }
-        const { offsetX = 0, offsetY = 0, offsetZ = 0 } = params || {};
-        if (endPercent === 1) {
-            if (curve.p2 && curve.p3) {
-                ctx.bezierCurveTo(offsetX + curve.p1.x, offsetY + curve.p1.y, offsetX + curve.p2.x, offsetY + curve.p2.y, offsetX + curve.p3.x, offsetY + curve.p3.y, offsetZ);
-            }
-            else {
-                ctx.lineTo(offsetX + curve.p1.x, offsetY + curve.p1.y, offsetZ);
-            }
-        }
-        else {
-            if (curve.p2 && curve.p3) {
-                const [curve1] = divideCubic(curve, endPercent);
-                ctx.bezierCurveTo(offsetX + curve1.p1.x, offsetY + curve1.p1.y, offsetX + curve1.p2.x, offsetY + curve1.p2.y, offsetX + curve1.p3.x, offsetY + curve1.p3.y, offsetZ);
-            }
-            else {
-                const p = curve.getPointAt(endPercent);
-                ctx.lineTo(offsetX + p.x, offsetY + p.y, offsetZ);
-            }
-        }
-    }
 
     exports.DefaultCanvasLineRender = class DefaultCanvasLineRender extends BaseRender {
         constructor() {
@@ -20189,10 +20182,10 @@
             const z = (_a = this.z) !== null && _a !== void 0 ? _a : 0;
             const { points } = line.attribute;
             const startP = points[0];
-            context.moveTo(startP.x, startP.y, z);
+            context.moveTo(startP.x + offsetX, startP.y + offsetY, z);
             for (let i = 1; i < points.length; i++) {
                 const p = points[i];
-                context.lineTo(p.x, p.y, z);
+                context.lineTo(p.x + offsetX, p.y + offsetY, z);
             }
             context.setShadowBlendStyle && context.setShadowBlendStyle(line, line.attribute, lineAttribute);
             const { x: originX = 0, x: originY = 0 } = line.attribute;
@@ -20619,84 +20612,7 @@
         }
         path.closePath();
     }
-    function drawSegItem(ctx, curve, endPercent, params) {
-        if (!curve.p1) {
-            return;
-        }
-        const { offsetX = 0, offsetY = 0, offsetZ = 0 } = params || {};
-        if (endPercent === 1) {
-            if (curve.p2 && curve.p3) {
-                ctx.bezierCurveTo(offsetX + curve.p1.x, offsetY + curve.p1.y, offsetX + curve.p2.x, offsetY + curve.p2.y, offsetX + curve.p3.x, offsetY + curve.p3.y, offsetZ);
-            }
-            else {
-                ctx.lineTo(offsetX + curve.p1.x, offsetY + curve.p1.y, offsetZ);
-            }
-        }
-        else {
-            if (curve.p2 && curve.p3) {
-                const [curve1] = divideCubic(curve, endPercent);
-                ctx.bezierCurveTo(offsetX + curve1.p1.x, offsetY + curve1.p1.y, offsetX + curve1.p2.x, offsetY + curve1.p2.y, offsetX + curve1.p3.x, offsetY + curve1.p3.y, offsetZ);
-            }
-            else {
-                const p = curve.getPointAt(endPercent);
-                ctx.lineTo(offsetX + p.x, offsetY + p.y, offsetZ);
-            }
-        }
-    }
 
-    class DefaultAreaTextureRenderContribution extends DefaultBaseTextureRenderContribution {
-        constructor() {
-            super(...arguments);
-            this.time = exports.BaseRenderContributionTime.afterFillStroke;
-        }
-        drawShape(graphic, context, x, y, doFill, doStroke, fVisible, sVisible, graphicAttribute, drawContext, fillCb, strokeCb, options) {
-            var _a, _b, _c, _d;
-            if (!this.textureMap) {
-                this.initTextureMap(context, graphic.stage);
-            }
-            const { attribute = graphic.attribute } = options || {};
-            const { texture = (_a = graphic.attribute.texture) !== null && _a !== void 0 ? _a : getAttributeFromDefaultAttrList(graphicAttribute, 'texture'), textureColor = (_b = graphic.attribute.textureColor) !== null && _b !== void 0 ? _b : getAttributeFromDefaultAttrList(graphicAttribute, 'textureColor'), textureSize = (_c = graphic.attribute.textureSize) !== null && _c !== void 0 ? _c : getAttributeFromDefaultAttrList(graphicAttribute, 'textureSize'), texturePadding = (_d = graphic.attribute.texturePadding) !== null && _d !== void 0 ? _d : getAttributeFromDefaultAttrList(graphicAttribute, 'texturePadding') } = attribute;
-            if (!texture) {
-                return;
-            }
-            let pattern = this.textureMap.get(texture);
-            if (!pattern) {
-                switch (texture) {
-                    case 'circle':
-                        pattern = this.createCirclePattern(textureSize, texturePadding, textureColor, context);
-                        break;
-                    case 'diamond':
-                        pattern = this.createDiamondPattern(textureSize, texturePadding, textureColor, context);
-                        break;
-                    case 'rect':
-                        pattern = this.createRectPattern(textureSize, texturePadding, textureColor, context);
-                        break;
-                    case 'vertical-line':
-                        pattern = this.createVerticalLinePattern(textureSize, texturePadding, textureColor, context);
-                        break;
-                    case 'horizontal-line':
-                        pattern = this.createHorizontalLinePattern(textureSize, texturePadding, textureColor, context);
-                        break;
-                    case 'bias-lr':
-                        pattern = this.createBiasLRLinePattern(textureSize, texturePadding, textureColor, context);
-                        break;
-                    case 'bias-rl':
-                        pattern = this.createBiasRLLinePattern(textureSize, texturePadding, textureColor, context);
-                        break;
-                    case 'grid':
-                        pattern = this.createGridPattern(textureSize, texturePadding, textureColor, context);
-                        break;
-                }
-            }
-            if (pattern) {
-                context.highPerformanceSave();
-                context.setCommonStyle(graphic, graphic.attribute, x, y, graphicAttribute);
-                context.fillStyle = pattern;
-                context.fill();
-                context.highPerformanceRestore();
-            }
-        }
-    }
     const defaultAreaTextureRenderContribution = new DefaultAreaTextureRenderContribution();
     const defaultAreaBackgroundRenderContribution = defaultBaseBackgroundRenderContribution;
 
@@ -20736,17 +20652,18 @@
             const z = (_a = this.z) !== null && _a !== void 0 ? _a : 0;
             const { points } = area.attribute;
             const startP = points[0];
-            context.moveTo(startP.x, startP.y, z);
+            context.moveTo(startP.x + offsetX, startP.y + offsetY, z);
             for (let i = 1; i < points.length; i++) {
                 const p = points[i];
-                context.lineTo(p.x, p.y, z);
+                context.lineTo(p.x + offsetX, p.y + offsetY, z);
             }
             for (let i = points.length - 1; i >= 0; i--) {
                 const p = points[i];
-                context.lineTo((_b = p.x1) !== null && _b !== void 0 ? _b : p.x, (_c = p.y1) !== null && _c !== void 0 ? _c : p.y, z);
+                context.lineTo(((_b = p.x1) !== null && _b !== void 0 ? _b : p.x) + offsetX, ((_c = p.y1) !== null && _c !== void 0 ? _c : p.y) + offsetY, z);
             }
             context.closePath();
             context.setShadowBlendStyle && context.setShadowBlendStyle(area, area.attribute, areaAttribute);
+            this.beforeRenderStep(area, context, offsetX, offsetY, !!fillOpacity, false, fill, false, areaAttribute, drawContext, fillCb, null, { attribute: area.attribute });
             const { x: originX = 0, x: originY = 0 } = area.attribute;
             if (fill !== false) {
                 if (fillCb) {
@@ -20757,28 +20674,34 @@
                     context.fill();
                 }
             }
+            this.afterRenderStep(area, context, offsetX, offsetY, !!fillOpacity, false, fill, false, areaAttribute, drawContext, fillCb, null, { attribute: area.attribute });
             if (stroke) {
                 const { stroke = areaAttribute && areaAttribute.stroke } = area.attribute;
                 if (vutils.isArray(stroke) && (stroke[0] || stroke[2]) && stroke[1] === false) {
                     context.beginPath();
                     if (stroke[0]) {
-                        context.moveTo(startP.x, startP.y, z);
+                        context.moveTo(startP.x + offsetX, startP.y + offsetY, z);
                         for (let i = 1; i < points.length; i++) {
                             const p = points[i];
-                            context.lineTo(p.x, p.y, z);
+                            context.lineTo(p.x + offsetX, p.y + offsetY, z);
                         }
                     }
                     else if (stroke[2]) {
                         const endP = points[points.length - 1];
-                        context.moveTo(endP.x, endP.y, z);
+                        context.moveTo(endP.x + offsetX, endP.y + offsetY, z);
                         for (let i = points.length - 2; i >= 0; i--) {
                             const p = points[i];
-                            context.lineTo((_d = p.x1) !== null && _d !== void 0 ? _d : p.x, (_e = p.y1) !== null && _e !== void 0 ? _e : p.y, z);
+                            context.lineTo(((_d = p.x1) !== null && _d !== void 0 ? _d : p.x) + offsetX, ((_e = p.y1) !== null && _e !== void 0 ? _e : p.y) + offsetY, z);
                         }
                     }
                 }
-                context.setStrokeStyle(area, area.attribute, originX - offsetX, originY - offsetY, areaAttribute);
-                context.stroke();
+                if (strokeCb) {
+                    strokeCb(context, area.attribute, areaAttribute);
+                }
+                else {
+                    context.setStrokeStyle(area, area.attribute, originX - offsetX, originY - offsetY, areaAttribute);
+                    context.stroke();
+                }
             }
         }
         drawShape(area, context, x, y, drawContext, params, fillCb, strokeCb) {
@@ -25202,6 +25125,7 @@
             if (this.supportInteractiveLayer && !this.interactiveLayer) {
                 this.interactiveLayer = this.createLayer();
                 this.interactiveLayer.name = '_builtin_interactive';
+                this.interactiveLayer.attribute.pickable = false;
                 this.nextFrameRenderLayerSet.add(this.interactiveLayer);
             }
         }
@@ -27300,6 +27224,7 @@
     exports.DefaultArcRenderContribution = DefaultArcRenderContribution;
     exports.DefaultAreaAllocate = DefaultAreaAllocate;
     exports.DefaultAreaAttribute = DefaultAreaAttribute;
+    exports.DefaultAreaTextureRenderContribution = DefaultAreaTextureRenderContribution;
     exports.DefaultAttribute = DefaultAttribute;
     exports.DefaultBaseBackgroundRenderContribution = DefaultBaseBackgroundRenderContribution;
     exports.DefaultBaseTextureRenderContribution = DefaultBaseTextureRenderContribution;
@@ -27569,9 +27494,9 @@
     exports.genLinearSegments = genLinearSegments;
     exports.genLinearTypeSegments = genLinearTypeSegments;
     exports.genMonotoneXSegments = genMonotoneXSegments;
+    exports.genMonotoneXTypeSegments = genMonotoneXTypeSegments;
     exports.genMonotoneYSegments = genMonotoneYSegments;
-    exports.genMonotpneXTypeSegments = genMonotpneXTypeSegments;
-    exports.genMonotpneYTypeSegments = genMonotpneYTypeSegments;
+    exports.genMonotoneYTypeSegments = genMonotoneYTypeSegments;
     exports.genNumberType = genNumberType;
     exports.genStepSegments = genStepSegments;
     exports.genStepTypeSegments = genStepTypeSegments;