@visactor/vseed 0.5.1 → 0.5.2

package/dist/umd/index.js

@@ -5799,48 +5799,6 @@ self.R = R;
                 const effect = effects[effects.length - 1] ?? EFFECT_NONE;
                 return effect !== EFFECT_NONE;
             };
-            const atmospherePoint = (effect)=>{
-                if (effect === EFFECT_NONE) return {};
-                if ('breath' === effect) return {
-                    channel: {
-                        scaleX: {
-                            from: 0.8,
-                            to: 1.2
-                        },
-                        scaleY: {
-                            from: 0.8,
-                            to: 1.2
-                        }
-                    }
-                };
-                if ('reveal' === effect) return {
-                    channel: {
-                        fillOpacity: {
-                            from: 0.6,
-                            to: 1
-                        },
-                        strokeOpacity: {
-                            from: 0.6,
-                            to: 1
-                        }
-                    }
-                };
-                return {
-                    channel: {
-                        outerBorder: {
-                            from: {
-                                distance: 0,
-                                strokeOpacity: 1
-                            },
-                            to: (...args)=>({
-                                    distance: 16,
-                                    strokeOpacity: 1e-8,
-                                    stroke: args[1]?.attribute?.fill
-                                })
-                        }
-                    }
-                };
-            };
             class Generator {
                 static GenAutoIncrementId() {
                     return Generator.auto_increment_id++;
@@ -9068,7 +9026,7 @@ self.R = R;
                 if (loopEffect === VScreenAnimationType.highLight && loop) {
                     const groupDuration = 0.7;
                     const stopDuration = 0.85;
-                    loopDuration = groupDuration * getGroupCountFromSpec(spec).groupCount + stopDuration;
+                    loopDuration = loop.duration ?? groupDuration * getGroupCountFromSpec(spec).groupCount + stopDuration;
                     result.push(...groupHighLightBar(startTime, loop, loopDuration, interval, atmosphereDuration, barMotion_isHorizontalBar(chartType), spec));
                 } else if (loop) result.push({
                     ...getLoopResult(loopEffect, chartType, spec),
@@ -9112,6 +9070,57 @@ self.R = R;
                     }
                 };
             };
+            const pointAtmosphere_EFFECT_NONE = VScreenAnimationType.none;
+            const atmospherePoint = (effect)=>{
+                if (effect === pointAtmosphere_EFFECT_NONE) return {};
+                if ('breath' === effect) return {
+                    channel: {
+                        scaleX: {
+                            from: 0.8,
+                            to: 2
+                        },
+                        scaleY: {
+                            from: 0.8,
+                            to: 2
+                        }
+                    }
+                };
+                if ('reveal' === effect) return {
+                    channel: {
+                        fillOpacity: {
+                            from: 0.6,
+                            to: 1
+                        },
+                        strokeOpacity: {
+                            from: 0.6,
+                            to: 1
+                        }
+                    }
+                };
+                return {
+                    channel: {
+                        outerBorder: {
+                            from: {
+                                distance: 0,
+                                strokeOpacity: 1
+                            },
+                            to: (...args)=>({
+                                    distance: 16,
+                                    strokeOpacity: 1e-8,
+                                    stroke: args[1]?.attribute?.fill
+                                })
+                        }
+                    },
+                    custom: (ratio, from, to, out, graphic)=>{
+                        graphic.attribute.strokeOpacity = ratio * (to.strokeOpacity - from.strokeOpacity) + from.strokeOpacity;
+                        graphic.attribute.outerBorder = {
+                            distance: ratio * (to.outerBorder.distance - from.outerBorder.distance) + from.outerBorder.distance,
+                            strokeOpacity: ratio * (to.outerBorder.strokeOpacity - from.outerBorder.strokeOpacity) + from.outerBorder.strokeOpacity,
+                            stroke: to.outerBorder.stroke
+                        };
+                    }
+                };
+            };
             const growthTopLine = ()=>({
                     type: 'growPointsYIn',
                     options: {
@@ -13536,20 +13545,45 @@ self.R = R;
                 if (hasNegativePart) return reverseStackCornerRadius(cornerRadius);
                 return 0;
             };
+            const createStackCornerRadius = (cornerRadius)=>(_, datum)=>{
+                    const stackRangeCornerRadius = getStackRangeCornerRadius(cornerRadius, datum);
+                    if (void 0 !== stackRangeCornerRadius) return stackRangeCornerRadius;
+                    const value = datum?.[datum?.[FoldMeasureId]];
+                    if (value > 0) return cornerRadius;
+                    if (value < 0) return reverseStackCornerRadius(cornerRadius);
+                    return 0;
+                };
+            const hasMoveInAnimation = (animation)=>{
+                if (!animation) return false;
+                if (Array.isArray(animation)) return animation.some(hasMoveInAnimation);
+                if ('object' != typeof animation) return false;
+                const animationRecord = animation;
+                return 'moveIn' === animationRecord.type || Object.values(animationRecord).some(hasMoveInAnimation);
+            };
+            const hasBarMoveInAnimation = (spec)=>[
+                    spec.animationAppear,
+                    spec.animationNormal,
+                    spec.animationEnter,
+                    spec.animationUpdate
+                ].some(hasMoveInAnimation);
             const stackCornerRadius_stackCornerRadius = (spec, context)=>{
                 const { advancedVSeed, vseed } = context;
                 const { chartType } = vseed;
                 const stackCornerRadius = advancedVSeed.config?.[chartType]?.stackCornerRadius;
                 if ('dualAxis' === chartType && 'bar' !== spec.type) return spec;
+                const stackCornerRadiusCallback = createStackCornerRadius(stackCornerRadius);
+                if (!hasBarMoveInAnimation(spec)) return {
+                    ...spec,
+                    stackCornerRadius: stackCornerRadiusCallback
+                };
                 return {
                     ...spec,
-                    stackCornerRadius: (_, datum)=>{
-                        const stackRangeCornerRadius = getStackRangeCornerRadius(stackCornerRadius, datum);
-                        if (void 0 !== stackRangeCornerRadius) return stackRangeCornerRadius;
-                        const value = datum?.[datum?.[FoldMeasureId]];
-                        if (value > 0) return stackCornerRadius;
-                        if (value < 0) return reverseStackCornerRadius(stackCornerRadius);
-                        return 0;
+                    bar: {
+                        ...spec.bar,
+                        style: {
+                            ...spec.bar?.style,
+                            cornerRadius: stackCornerRadiusCallback
+                        }
                     }
                 };
             };