@visactor/vseed 0.4.3 → 0.4.4

package/dist/umd/index.js

@@ -66,6 +66,7 @@
             funnelSpecPipeline: ()=>funnelSpecPipeline,
             isDimensionSelector: ()=>isDimensionSelector,
             zAnalysis: ()=>zAnalysis,
+            raceDonutAdvancedPipeline: ()=>raceDonutAdvancedPipeline,
             zDimensionTree: ()=>zDimensionTree,
             circlePackingSpecPipeline: ()=>circlePackingSpecPipeline,
             zLineStyle: ()=>zLineStyle,
@@ -103,7 +104,7 @@
             zAreaSelectors: ()=>zAreaSelectors,
             registerRose: ()=>registerRose,
             zPivotChartGridConfig: ()=>zPivotChartGridConfig,
-            zRose: ()=>zRose,
+            raceLineAdvancedPipeline: ()=>raceLineAdvancedPipeline,
             zCellSelector: ()=>zCellSelector,
             registerTable: ()=>registerTable,
             autoFormatter: ()=>autoFormatter,
@@ -114,6 +115,7 @@
             isVChart: ()=>isVChart,
             registerBar: ()=>registerBar,
             zPolynomialRegressionLine: ()=>zPolynomialRegressionLine,
+            zRose: ()=>zRose,
             zSunburstConfig: ()=>zSunburstConfig,
             zDimensionSelector: ()=>zDimensionSelector,
             zColor: ()=>zColor,
@@ -154,12 +156,13 @@
             zSelectors: ()=>zSelectors,
             FoldYMeasureId: ()=>FoldYMeasureId,
             findMeasureById: ()=>findMeasureById,
+            zRaceDonut: ()=>zRaceDonut,
             zBrushConfig: ()=>zBrushConfig,
             AngleEncoding: ()=>AngleEncoding,
             areaPercentAdvancedPipeline: ()=>areaPercentAdvancedPipeline,
-            zBackgroundColor: ()=>zBackgroundColor,
-            zAreaPercentConfig: ()=>zAreaPercentConfig,
             findTreeNodesBy: ()=>findTreeNodesBy,
+            zAreaPercentConfig: ()=>zAreaPercentConfig,
+            zBackgroundColor: ()=>zBackgroundColor,
             MeasureId: ()=>MeasureId,
             registerRadar: ()=>registerRadar,
             zLocale: ()=>zLocale,
@@ -190,6 +193,7 @@
             AXIS_LABEL_SPACE: ()=>8,
             FoldMeasureValue: ()=>FoldMeasureValue,
             zFunnel: ()=>zFunnel,
+            racePieSpecPipeline: ()=>racePieSpecPipeline,
             ANNOTATION_Z_INDEX: ()=>1000,
             Q3MeasureValue: ()=>"__Q3__",
             createFormatter: ()=>createFormatter,
@@ -197,15 +201,15 @@
             registerBoxPlot: ()=>registerBoxPlot,
             selectByPartial: ()=>selectByPartial,
             columnPercentSpecPipeline: ()=>columnPercentSpecPipeline,
-            zBarConfig: ()=>zBarConfig,
             areaAdvancedPipeline: ()=>areaAdvancedPipeline,
+            areaPercentSpecPipeline: ()=>areaPercentSpecPipeline,
             isRowWithFieldDynamicFilter: ()=>isRowWithFieldDynamicFilter,
             executeFilterCode: ()=>executeFilterCode,
-            areaPercentSpecPipeline: ()=>areaPercentSpecPipeline,
             barParallelSpecPipeline: ()=>barParallelSpecPipeline,
+            BAND_AXIS_INNER_OFFSET_IN_PIVOT: ()=>2,
             zBar: ()=>zBar,
             pieAdvancedPipeline: ()=>pieAdvancedPipeline,
-            BAND_AXIS_INNER_OFFSET_IN_PIVOT: ()=>2,
+            zBarConfig: ()=>zBarConfig,
             zDualMeasures: ()=>zDualMeasures,
             isTable: ()=>isTable,
             zBarMaxWidth: ()=>zBarMaxWidth,
@@ -290,7 +294,9 @@
             zTable: ()=>zTable,
             histogramSpecPipeline: ()=>histogramSpecPipeline,
             isValueDynamicFilter: ()=>isValueDynamicFilter,
+            racePieAdvancedPipeline: ()=>racePieAdvancedPipeline,
             registerCustomTheme: ()=>registerCustomTheme,
+            raceLineSpecPipeline: ()=>raceLineSpecPipeline,
             registerLine: ()=>registerLine,
             registerRoseParallel: ()=>registerRoseParallel,
             zAreaSelector: ()=>zAreaSelector,
@@ -310,10 +316,11 @@
             zDatasetReshapeInfo: ()=>zDatasetReshapeInfo,
             zLinearColor: ()=>zLinearColor,
             DUAL_AXIS_CHART_NON_COLUMN_Z_INDEX: ()=>1001,
-            zAreaStyle: ()=>zAreaStyle,
+            raceDonutSpecPipeline: ()=>raceDonutSpecPipeline,
             BinEndMeasureId: ()=>BinEndMeasureId,
-            zBoxGapInGroup: ()=>zBoxGapInGroup,
+            zAreaStyle: ()=>zAreaStyle,
             zAnnotationArea: ()=>zAnnotationArea,
+            zBoxGapInGroup: ()=>zBoxGapInGroup,
             DetailEncoding: ()=>DetailEncoding,
             isPivot: ()=>chatType_isPivot,
             raceScatterAdvancedPipeline: ()=>raceScatterAdvancedPipeline,
@@ -362,6 +369,7 @@
             donutAdvancedPipeline: ()=>donutAdvancedPipeline,
             zScatter: ()=>zScatter,
             zScatterConfig: ()=>zScatterConfig,
+            zRaceLine: ()=>zRaceLine,
             zTooltip: ()=>zTooltip,
             isBarLikeChart: ()=>isBarLikeChart,
             barParallelAdvancedPipeline: ()=>barParallelAdvancedPipeline,
@@ -375,7 +383,8 @@
             zBarPercentConfig: ()=>zBarPercentConfig,
             raceColumnAdvancedPipeline: ()=>raceColumnAdvancedPipeline,
             isPositionMeasure: ()=>isPositionMeasure,
-            zDimensionGroup: ()=>zDimensionGroup
+            zDimensionGroup: ()=>zDimensionGroup,
+            zRacePie: ()=>zRacePie
         });
         const execPipeline = (pipeline, context, initialValue = {})=>{
             const result = pipeline.reduce((prev, cur)=>cur(prev, context), initialValue);
@@ -8980,9 +8989,6 @@ self.R = R;
         };
         const raceBar_generateDimensionEncoding = (dimensions, encoding, isMultiMeasure)=>{
             encoding.player = chunk_QJLMYOTX_i(dimensions.filter((item)=>'player' === item.encoding).map((item)=>item.id));
-            if (0 === encoding.player.length) encoding.player = [
-                dimensions[0].id
-            ];
             encoding.y = chunk_QJLMYOTX_i(dimensions.filter((item)=>'yAxis' === item.encoding).map((item)=>item.id));
             if (0 === encoding.y.length) encoding.y = [
                 dimensions[1].id
@@ -9047,6 +9053,14 @@ self.R = R;
             markStyle_markStyle,
             annotation_annotation
         ];
+        const isPlayer = (playerPipe, defaultPipe)=>(spec, context)=>{
+                const { vseed, advancedVSeed } = context;
+                const { encoding } = advancedVSeed;
+                const hasPlayerEncoding = encoding.player && encoding.player.length > 0;
+                const isStandardChart = !isVTable(vseed) && !chatType_isPivotChart(vseed);
+                if (hasPlayerEncoding && isStandardChart) return playerPipe(spec, context);
+                return defaultPipe(spec, context);
+            };
         function chunk_HVPVHFDT_i(...e) {
             return chunk_WIMGWYZL_u(chunk_HVPVHFDT_p, e);
         }
@@ -9063,12 +9077,12 @@ self.R = R;
             }
             return Object.setPrototypeOf(r, Object.prototype), r;
         };
-        const playerYX = (spec, context)=>{
-            const { vseed, advancedVSeed } = context;
+        const playerBar = (spec, context)=>{
+            const { advancedVSeed } = context;
             const { dimensions = [], datasetReshapeInfo, chartType, encoding } = advancedVSeed;
             const baseConfig = advancedVSeed.config[chartType];
             const result = datasetYX(spec, context);
-            if (!baseConfig || !baseConfig.player || isVTable(vseed) || chatType_isPivotChart(vseed)) return result;
+            if (!baseConfig || !baseConfig.player) return result;
             const { player } = baseConfig;
             const id = datasetReshapeInfo[0].id;
             const { unfoldInfo, foldInfo } = datasetReshapeInfo[0];
@@ -9089,7 +9103,7 @@ self.R = R;
                 return {
                     data: {
                         id: id,
-                        values: sortedItems.slice(0, maxCount)
+                        values: false === maxCount ? sortedItems : sortedItems.slice(0, maxCount)
                     }
                 };
             });
@@ -9246,7 +9260,7 @@ self.R = R;
             barMaxWidth_barMaxWidth,
             colorAdapter(color_color, linearColor),
             background_backgroundColor,
-            playerYX,
+            isPlayer(playerBar, datasetYX),
             progressive,
             xLinear,
             yBand,
@@ -9304,9 +9318,6 @@ self.R = R;
         };
         const raceColumn_generateDimensionEncoding = (dimensions, encoding, isMultiMeasure)=>{
             encoding.player = chunk_QJLMYOTX_i(dimensions.filter((item)=>'player' === item.encoding).map((item)=>item.id));
-            if (0 === encoding.player.length) encoding.player = [
-                dimensions[0].id
-            ];
             encoding.x = chunk_QJLMYOTX_i(dimensions.filter((item)=>'xAxis' === item.encoding).map((item)=>item.id));
             if (0 === encoding.x.length) encoding.x = [
                 dimensions[1].id
@@ -9372,12 +9383,12 @@ self.R = R;
             annotation_annotation,
             regressionLine_regressionLine
         ];
-        const playerXY = (spec, context)=>{
-            const { vseed, advancedVSeed } = context;
+        const playerColumn = (spec, context)=>{
+            const { advancedVSeed } = context;
             const { dimensions = [], datasetReshapeInfo, chartType, encoding } = advancedVSeed;
             const baseConfig = advancedVSeed.config[chartType];
             const result = datasetXY(spec, context);
-            if (!baseConfig || !baseConfig.player || isVTable(vseed) || chatType_isPivotChart(vseed)) return result;
+            if (!baseConfig || !baseConfig.player) return result;
             const { player } = baseConfig;
             const id = datasetReshapeInfo[0].id;
             const { unfoldInfo, foldInfo } = datasetReshapeInfo[0];
@@ -9396,7 +9407,7 @@ self.R = R;
                 return {
                     data: {
                         id: id,
-                        values: sortedItems.slice(0, maxCount)
+                        values: false === maxCount ? sortedItems : sortedItems.slice(0, maxCount)
                     }
                 };
             });
@@ -9572,7 +9583,7 @@ self.R = R;
             barMaxWidth_barMaxWidth,
             colorAdapter(color_color, linearColor),
             background_backgroundColor,
-            playerXY,
+            isPlayer(playerColumn, datasetXY),
             progressive,
             xBand,
             yLinear,
@@ -9943,23 +9954,24 @@ self.R = R;
                 }
             };
         };
-        const playerYY = (spec, context)=>{
-            const { vseed, advancedVSeed } = context;
+        const playerScatter = (spec, context)=>{
+            const { advancedVSeed } = context;
             const { datasetReshapeInfo, dimensions = [], chartType, encoding } = advancedVSeed;
             const baseConfig = advancedVSeed.config[chartType];
             const result = datasetScatter(spec, context);
-            if (!baseConfig || !baseConfig.player || isVTable(vseed) || chatType_isPivotChart(vseed)) return result;
+            if (!baseConfig || !baseConfig.player) return result;
             const { player } = baseConfig;
             const id = datasetReshapeInfo[0].id;
             const { unfoldInfo } = datasetReshapeInfo[0];
             const { encodingPlayer } = unfoldInfo;
             const { autoPlay = true, interval = 1000, loop = false, position, railColor, trackColor, sliderHandleColor, sliderHandleBorderColor, startButtonColor, pauseButtonColor, backwardButtonColor, forwardButtonColor } = player;
+            const { maxCount } = player;
             const dataGroups = chunk_HVPVHFDT_i(advancedVSeed.dataset, (item)=>item[encodingPlayer]);
             if (result.data && 'values' in result.data) result.data.values = [];
             const specs = Object.values(dataGroups).map((items)=>({
                     data: {
                         id: id,
-                        values: items
+                        values: maxCount ? items.slice(0, maxCount) : items
                     }
                 }));
             const duration = interval;
@@ -10734,32 +10746,807 @@ self.R = R;
             initScatter,
             colorAdapter(color_color, linearColor),
             background_backgroundColor,
-            playerYY,
+            isPlayer(playerScatter, datasetScatter),
+            progressive,
+            xLinear,
+            yLinear,
+            brush_brush,
+            scatterSize,
+            labelScatter,
+            tooltipScatter,
+            colorAdapter(discreteLegend, colorLegend),
+            verticalCrosshairLine,
+            horizontalCrosshairLine,
+            colorPointStyleFill(pointStyle_pointStyle),
+            pointStateHover,
+            annotationPoint_annotationPoint,
+            annotationVerticalLine_annotationVerticalLine,
+            annotationHorizontalLine_annotationHorizontalLine,
+            annotationArea_annotationArea,
+            linearRegressionLine,
+            lowessRegressionLine,
+            polynomialRegressionLine,
+            logisticRegressionLine
+        ];
+        const raceScatterSpecPipeline = raceScatter;
+        const registerRaceScatter = ()=>{
+            Builder.registerAdvancedPipeline('raceScatter', raceScatterAdvancedPipeline);
+            Builder.registerSpecPipeline('raceScatter', raceScatterSpecPipeline);
+        };
+        const defaultEncodingForRaceLine = (advancedVSeed)=>{
+            const { measures = [], reshapeMeasures = [], dimensions = [] } = advancedVSeed;
+            const encoding = {};
+            raceLine_generateDefaultDimensionEncoding(dimensions, encoding, hasMultipleMeasureInSingleView(reshapeMeasures));
+            raceLine_generateDefaultMeasureEncoding(measures, encoding);
+            return {
+                ...advancedVSeed,
+                encoding
+            };
+        };
+        const encodingForRaceLine = (advancedVSeed)=>{
+            const { measures = [], reshapeMeasures = [], dimensions = [] } = advancedVSeed;
+            const hasDimensionEncoding = dimensions.some((item)=>item.encoding);
+            const hasMeasureEncoding = measures.some((item)=>item.encoding);
+            const encoding = {};
+            const hasMulti = hasMultipleMeasureInSingleView(reshapeMeasures);
+            if (hasDimensionEncoding) raceLine_generateDimensionEncoding(dimensions, encoding, hasMulti);
+            else raceLine_generateDefaultDimensionEncoding(dimensions, encoding, hasMulti);
+            if (hasMeasureEncoding) raceLine_generateMeasureEncoding(measures, encoding);
+            else raceLine_generateDefaultMeasureEncoding(measures, encoding);
+            return {
+                ...advancedVSeed,
+                encoding
+            };
+        };
+        const raceLine_generateDefaultDimensionEncoding = (dimensions, encoding, isMultiMeasure)=>{
+            const uniqueDimIds = chunk_QJLMYOTX_i(dimensions.map((d)=>d.id));
+            encoding.player = uniqueDimIds.slice(0, 1);
+            encoding.x = uniqueDimIds.slice(0, 1);
+            encoding.color = uniqueDimIds.slice(1, 2);
+            addDefaultColorEncoding(uniqueDimIds, encoding, isMultiMeasure);
+            encoding.detail = encoding.color;
+            encoding.tooltip = uniqueDimIds.filter((d)=>d !== MeasureId);
+            encoding.label = [];
+            encoding.row = [];
+            encoding.column = [];
+        };
+        const raceLine_generateDimensionEncoding = (dimensions, encoding, isMultiMeasure)=>{
+            const playerDims = dimensions.filter((item)=>'player' === item.encoding).map((item)=>item.id);
+            const xDims = dimensions.filter((item)=>'xAxis' === item.encoding).map((item)=>item.id);
+            const merged = chunk_QJLMYOTX_i([
+                ...playerDims,
+                ...xDims
+            ]);
+            if (playerDims.length > 0) {
+                encoding.player = merged;
+                encoding.x = merged;
+            } else {
+                encoding.player = [];
+                encoding.x = [
+                    dimensions[0].id
+                ];
+            }
+            addColorToEncoding(dimensions, encoding, isMultiMeasure);
+            encoding.detail = chunk_QJLMYOTX_i(dimensions.filter((item)=>'detail' === item.encoding).map((item)=>item.id));
+            if (0 === encoding.detail.length) encoding.detail = encoding.color;
+            encoding.tooltip = chunk_QJLMYOTX_i(dimensions.map((item)=>item.id));
+            encoding.tooltip = encoding.tooltip.filter((d)=>d !== MeasureId);
+            encoding.label = chunk_QJLMYOTX_i(dimensions.filter((item)=>'label' === item.encoding).map((item)=>item.id));
+            encoding.label = encoding.label.filter((d)=>d !== MeasureId);
+        };
+        const raceLine_generateDefaultMeasureEncoding = (measures, encoding)=>{
+            encoding.y = chunk_QJLMYOTX_i(measures.filter((item)=>'yAxis' === item.encoding || !item.encoding).map((item)=>item.id));
+        };
+        const raceLine_generateMeasureEncoding = (measures, encoding)=>{
+            encoding.y = chunk_QJLMYOTX_i(measures.filter((item)=>'yAxis' === item.encoding || !item.encoding).map((item)=>item.id));
+            const color = chunk_QJLMYOTX_i(measures.filter((item)=>'color' === item.encoding).map((item)=>item.id));
+            if (color.length > 0) encoding.color = color;
+            const label = chunk_QJLMYOTX_i(measures.filter((item)=>'label' === item.encoding).map((item)=>item.id));
+            encoding.label = chunk_QJLMYOTX_i([
+                ...encoding.label || [],
+                ...label
+            ]);
+            const tooltip = chunk_QJLMYOTX_i(measures.filter((item)=>'tooltip' === item.encoding).map((item)=>item.id));
+            encoding.tooltip = chunk_QJLMYOTX_i([
+                ...encoding.tooltip || [],
+                ...label,
+                ...tooltip,
+                ...color
+            ]);
+        };
+        const raceLineAdvancedPipeline = [
+            page_page_page,
+            initAdvancedVSeed_initAdvancedVSeed,
+            default_defaultMeasures_defaultMeasures,
+            defaultDimensions_defaultDimensions,
+            defaultMeasureId_defaultMeasureId,
+            encodingAdapter([
+                buildMeasures([
+                    'yAxis',
+                    'detail'
+                ]),
+                defaultEncodingForRaceLine
+            ], [
+                buildMeasures([
+                    'yAxis',
+                    'detail'
+                ]),
+                encodingForRaceLine,
+                pickDimensionsForReshape
+            ]),
+            pivotAdapter([
+                reshapeWithEncoding
+            ], [
+                pivotReshapeWithEncoding
+            ]),
+            sortXBandAxis,
+            sortLegend_sortLegend,
+            line_lineConfig,
+            theme_theme,
+            markStyle_markStyle,
+            annotation_annotation
+        ];
+        const playerLine = (spec, context)=>{
+            const { advancedVSeed } = context;
+            const { datasetReshapeInfo, chartType } = advancedVSeed;
+            const baseConfig = advancedVSeed.config[chartType];
+            const result = datasetXY(spec, context);
+            if (!baseConfig || !baseConfig.player) return result;
+            const { player } = baseConfig;
+            const id = datasetReshapeInfo[0].id;
+            const { unfoldInfo } = datasetReshapeInfo[0];
+            const { encodingX } = unfoldInfo;
+            const { maxCount = false, autoPlay = true, interval, loop = false, position, railColor, trackColor, sliderHandleColor, sliderHandleBorderColor, startButtonColor, pauseButtonColor, backwardButtonColor, forwardButtonColor } = player;
+            const uniqueXValues = Array.from(new Set(advancedVSeed.dataset.map((d)=>d[encodingX]))).sort((a, b)=>a > b ? 1 : -1);
+            const step = 1;
+            const specs = [];
+            result.data = [
+                {
+                    id: id,
+                    values: []
+                }
+            ];
+            if (false === maxCount) for(let currentSize = 2; currentSize <= uniqueXValues.length; currentSize += step){
+                const currentXValues = uniqueXValues.slice(0, currentSize);
+                const frameData = advancedVSeed.dataset.filter((d)=>currentXValues.includes(d[encodingX]));
+                specs.push({
+                    data: {
+                        id: id,
+                        values: frameData
+                    }
+                });
+            }
+            else if (uniqueXValues.length <= maxCount) {
+                const limitCount = uniqueXValues.length;
+                for(let currentSize = 2; currentSize <= limitCount; currentSize += step){
+                    const currentXValues = uniqueXValues.slice(0, currentSize);
+                    const frameData = advancedVSeed.dataset.filter((d)=>currentXValues.includes(d[encodingX]));
+                    specs.push({
+                        data: {
+                            id: id,
+                            values: frameData
+                        }
+                    });
+                }
+            } else {
+                const limitCount = maxCount;
+                for(let currentSize = 2; currentSize < limitCount; currentSize += step){
+                    const currentXValues = uniqueXValues.slice(0, currentSize);
+                    const frameData = advancedVSeed.dataset.filter((d)=>currentXValues.includes(d[encodingX]));
+                    specs.push({
+                        data: {
+                            id: id,
+                            values: frameData
+                        }
+                    });
+                }
+                for(let i = 0; i <= uniqueXValues.length - limitCount; i += step){
+                    const currentXValues = uniqueXValues.slice(i, i + limitCount);
+                    const frameData = advancedVSeed.dataset.filter((d)=>currentXValues.includes(d[encodingX]));
+                    specs.push({
+                        data: {
+                            id: id,
+                            values: frameData
+                        }
+                    });
+                }
+            }
+            const duration = interval;
+            return {
+                ...result,
+                stackCornerRadius: void 0,
+                animationUpdate: {
+                    duration
+                },
+                point: {
+                    visible: false
+                },
+                player: {
+                    visible: true,
+                    auto: autoPlay,
+                    interval: interval,
+                    loop: loop,
+                    alternate: false,
+                    position: 'middle',
+                    orient: position,
+                    type: 'discrete',
+                    specs,
+                    controller: {
+                        visible: true,
+                        start: {
+                            visible: true,
+                            order: 0,
+                            style: {
+                                fill: startButtonColor
+                            }
+                        },
+                        pause: {
+                            visible: true,
+                            order: 1,
+                            style: {
+                                fill: pauseButtonColor
+                            }
+                        },
+                        backward: {
+                            visible: true,
+                            order: 2,
+                            style: {
+                                fill: backwardButtonColor
+                            }
+                        },
+                        forward: {
+                            visible: true,
+                            order: 3,
+                            position: 'end',
+                            style: {
+                                fill: forwardButtonColor
+                            }
+                        }
+                    },
+                    slider: {
+                        visible: true,
+                        railStyle: {
+                            visible: true,
+                            fill: railColor,
+                            ['top' === position || 'bottom' === position ? 'height' : 'width']: 2
+                        },
+                        trackStyle: {
+                            visible: true,
+                            fill: trackColor,
+                            ['top' === position || 'bottom' === position ? 'height' : 'width']: 2
+                        },
+                        handlerStyle: {
+                            visible: true,
+                            lineWidth: 2,
+                            stroke: sliderHandleBorderColor,
+                            fill: sliderHandleColor,
+                            size: 9
+                        }
+                    }
+                }
+            };
+        };
+        const raceLine = [
+            initLine,
+            colorAdapter(color_color, linearColor),
+            background_backgroundColor,
+            isPlayer(playerLine, datasetXY),
+            progressive,
+            xBand,
+            yLinear,
+            brush_brush,
+            verticalCrosshairLine,
+            colorAdapter(discreteLegend, colorLegend),
+            colorLineStyleFill(lineStyle_lineStyle),
+            label_label,
+            tooltip_tooltip,
+            annotationPoint_annotationPoint,
+            annotationVerticalLine_annotationVerticalLine,
+            annotationHorizontalLine_annotationHorizontalLine,
+            annotationArea_annotationArea,
+            splitLine
+        ];
+        const raceLineSpecPipeline = raceLine;
+        const registerRaceLine = ()=>{
+            Builder.registerAdvancedPipeline('raceLine', raceLineAdvancedPipeline);
+            Builder.registerSpecPipeline('raceLine', raceLineSpecPipeline);
+        };
+        const defaultEncodingForRacePie = (advancedVSeed)=>{
+            const { measures = [], reshapeMeasures = [], dimensions = [] } = advancedVSeed;
+            const encoding = {};
+            racePie_generateDefaultDimensionEncoding(dimensions, encoding, hasMultipleMeasureInSingleView(reshapeMeasures));
+            racePie_generateDefaultMeasureEncoding(measures, encoding);
+            return {
+                ...advancedVSeed,
+                encoding
+            };
+        };
+        const encodingForRacePie = (advancedVSeed)=>{
+            const { measures = [], reshapeMeasures = [], dimensions = [] } = advancedVSeed;
+            const hasDimensionEncoding = dimensions.some((item)=>item.encoding);
+            const hasMeasureEncoding = measures.some((item)=>item.encoding);
+            const encoding = {};
+            const hasMulti = hasMultipleMeasureInSingleView(reshapeMeasures);
+            if (hasDimensionEncoding) racePie_generateDimensionEncoding(dimensions, encoding, hasMulti);
+            else racePie_generateDefaultDimensionEncoding(dimensions, encoding, hasMulti);
+            if (hasMeasureEncoding) racePie_generateMeasureEncoding(measures, encoding);
+            else racePie_generateDefaultMeasureEncoding(measures, encoding);
+            return {
+                ...advancedVSeed,
+                encoding
+            };
+        };
+        const racePie_generateDefaultDimensionEncoding = (dimensions, encoding, isMultiMeasure)=>{
+            const uniqueDimIds = chunk_QJLMYOTX_i(dimensions.map((d)=>d.id));
+            encoding.player = uniqueDimIds.slice(0, 1);
+            encoding.color = uniqueDimIds.slice(1, 2);
+            addDefaultColorEncoding(uniqueDimIds, encoding, isMultiMeasure);
+            encoding.detail = encoding.color;
+            encoding.tooltip = uniqueDimIds.filter((d)=>d !== MeasureId);
+            encoding.label = [];
+            encoding.row = [];
+            encoding.column = [];
+        };
+        const racePie_generateDimensionEncoding = (dimensions, encoding, isMultiMeasure)=>{
+            encoding.player = chunk_QJLMYOTX_i(dimensions.filter((item)=>'player' === item.encoding).map((item)=>item.id));
+            addColorToEncoding(dimensions, encoding, isMultiMeasure);
+            encoding.detail = chunk_QJLMYOTX_i(dimensions.filter((item)=>'detail' === item.encoding).map((item)=>item.id));
+            if (0 === encoding.detail.length) encoding.detail = encoding.color;
+            encoding.tooltip = chunk_QJLMYOTX_i(dimensions.map((item)=>item.id));
+            encoding.tooltip = encoding.tooltip.filter((d)=>d !== MeasureId);
+            encoding.label = chunk_QJLMYOTX_i(dimensions.filter((item)=>'label' === item.encoding).map((item)=>item.id));
+            encoding.label = encoding.label.filter((d)=>d !== MeasureId);
+        };
+        const racePie_generateDefaultMeasureEncoding = (measures, encoding)=>{
+            encoding.angle = chunk_QJLMYOTX_i(measures.filter((item)=>'angle' === item.encoding || !item.encoding).map((item)=>item.id));
+        };
+        const racePie_generateMeasureEncoding = (measures, encoding)=>{
+            encoding.angle = chunk_QJLMYOTX_i(measures.filter((item)=>'angle' === item.encoding || !item.encoding).map((item)=>item.id));
+            const color = chunk_QJLMYOTX_i(measures.filter((item)=>'color' === item.encoding).map((item)=>item.id));
+            if (color.length > 0) encoding.color = color;
+            const label = chunk_QJLMYOTX_i(measures.filter((item)=>'label' === item.encoding).map((item)=>item.id));
+            encoding.label = chunk_QJLMYOTX_i([
+                ...encoding.label || [],
+                ...label
+            ]);
+            const tooltip = chunk_QJLMYOTX_i(measures.filter((item)=>'tooltip' === item.encoding).map((item)=>item.id));
+            encoding.tooltip = chunk_QJLMYOTX_i([
+                ...encoding.tooltip || [],
+                ...label,
+                ...tooltip,
+                ...color
+            ]);
+        };
+        const racePieAdvancedPipeline = [
+            page_page_page,
+            initAdvancedVSeed_initAdvancedVSeed,
+            default_defaultMeasures_defaultMeasures,
+            defaultDimensions_defaultDimensions,
+            defaultMeasureId_defaultMeasureId,
+            encodingAdapter([
+                buildMeasures([
+                    'angle',
+                    'detail'
+                ]),
+                defaultEncodingForRacePie
+            ], [
+                buildMeasures([
+                    'angle',
+                    'detail'
+                ]),
+                encodingForRacePie,
+                pickDimensionsForReshape
+            ]),
+            pivotAdapter([
+                reshapeWithEncoding
+            ], [
+                pivotReshapeWithEncoding
+            ]),
+            pieConfig,
+            theme_theme,
+            annotation_annotation
+        ];
+        const initPie = (spec, context)=>{
+            const result = {
+                ...spec
+            };
+            const { advancedVSeed } = context;
+            const { datasetReshapeInfo } = advancedVSeed;
+            const { unfoldInfo, foldInfo } = datasetReshapeInfo[0];
+            result.type = 'pie';
+            result.outerRadius = 0.8;
+            result.innerRadius = 0;
+            result.valueField = foldInfo.measureValue;
+            result.categoryField = unfoldInfo.encodingColorId;
+            result.padding = 0;
+            result.region = [
+                {
+                    clip: true
+                }
+            ];
+            result.animation = true;
+            return result;
+        };
+        const playerPie = (spec, context)=>{
+            const { advancedVSeed } = context;
+            const { dimensions = [], datasetReshapeInfo, chartType, encoding } = advancedVSeed;
+            const baseConfig = advancedVSeed.config[chartType];
+            const result = datasetXY(spec, context);
+            if (!baseConfig || !baseConfig.player) return result;
+            const { player } = baseConfig;
+            const id = datasetReshapeInfo[0].id;
+            const { unfoldInfo } = datasetReshapeInfo[0];
+            const { encodingPlayer } = unfoldInfo;
+            const { maxCount, autoPlay = true, interval = 1000, loop = false, position, railColor, trackColor, sliderHandleColor, sliderHandleBorderColor, startButtonColor, pauseButtonColor, backwardButtonColor, forwardButtonColor } = player;
+            const dataGroups = chunk_HVPVHFDT_i(advancedVSeed.dataset, (item)=>item[encodingPlayer]);
+            if (result.data && 'values' in result.data) result.data.values = [];
+            const specs = Object.keys(dataGroups).sort().map((key)=>{
+                const items = dataGroups[key];
+                const sortedItems = items;
+                return {
+                    data: {
+                        id: id,
+                        values: false === maxCount ? sortedItems : sortedItems.slice(0, maxCount)
+                    }
+                };
+            });
+            const duration = interval;
+            const exchangeDuration = 0.6 * interval;
+            const dataKey = dimensions.filter((d)=>!encoding.player?.includes(d.id)).map((d)=>d.id);
+            const textSize = 36;
+            const padding = 12;
+            return {
+                ...result,
+                dataKey,
+                stackCornerRadius: void 0,
+                animationUpdate: {
+                    pie: [
+                        {
+                            type: 'update',
+                            options: {
+                                excludeChannels: [
+                                    'angle',
+                                    'startAngle',
+                                    'endAngle'
+                                ]
+                            },
+                            easing: 'linear',
+                            duration
+                        },
+                        {
+                            channel: [
+                                'angle',
+                                'startAngle',
+                                'endAngle'
+                            ],
+                            easing: 'circInOut',
+                            duration: exchangeDuration
+                        }
+                    ],
+                    point: [
+                        {
+                            type: 'update',
+                            easing: 'linear',
+                            duration
+                        }
+                    ],
+                    line: [
+                        {
+                            type: 'update',
+                            easing: 'linear',
+                            duration
+                        }
+                    ]
+                },
+                animationEnter: {
+                    pie: [
+                        {
+                            type: 'update',
+                            duration: exchangeDuration,
+                            easing: 'circInOut'
+                        }
+                    ]
+                },
+                animationExit: {
+                    pie: [
+                        {
+                            type: 'fadeOut',
+                            duration: exchangeDuration
+                        }
+                    ]
+                },
+                customMark: [
+                    {
+                        type: 'text',
+                        dataId: 'year',
+                        style: {
+                            textBaseline: 'bottom',
+                            fontSize: textSize,
+                            textAlign: 'right',
+                            text: (datum)=>datum[encodingPlayer],
+                            x: (_datum, ctx)=>ctx.vchart.getChart().getCanvasRect()?.width - padding,
+                            y: (_datum, _ctx)=>textSize + padding,
+                            fill: 'rgb(100, 100, 100)',
+                            fillOpacity: 0.25
+                        }
+                    }
+                ],
+                player: {
+                    visible: true,
+                    auto: autoPlay,
+                    interval: interval,
+                    loop: loop,
+                    alternate: false,
+                    position: 'middle',
+                    orient: position,
+                    type: 'discrete',
+                    specs,
+                    controller: {
+                        visible: true,
+                        start: {
+                            visible: true,
+                            order: 0,
+                            style: {
+                                fill: startButtonColor
+                            }
+                        },
+                        pause: {
+                            visible: true,
+                            order: 1,
+                            style: {
+                                fill: pauseButtonColor
+                            }
+                        },
+                        backward: {
+                            visible: true,
+                            order: 2,
+                            style: {
+                                fill: backwardButtonColor
+                            }
+                        },
+                        forward: {
+                            visible: true,
+                            order: 3,
+                            position: 'end',
+                            style: {
+                                fill: forwardButtonColor
+                            }
+                        }
+                    },
+                    slider: {
+                        visible: true,
+                        railStyle: {
+                            visible: true,
+                            fill: railColor,
+                            ['top' === position || 'bottom' === position ? 'height' : 'width']: 2
+                        },
+                        trackStyle: {
+                            visible: true,
+                            fill: trackColor,
+                            ['top' === position || 'bottom' === position ? 'height' : 'width']: 2
+                        },
+                        handlerStyle: {
+                            visible: true,
+                            lineWidth: 2,
+                            stroke: sliderHandleBorderColor,
+                            fill: sliderHandleColor,
+                            size: 9
+                        }
+                    }
+                }
+            };
+        };
+        const colorPieStyleFill = (stylePipe)=>(spec, context)=>{
+                const result = stylePipe(spec, context);
+                const { advancedVSeed, vseed } = context;
+                const { datasetReshapeInfo } = advancedVSeed;
+                const { unfoldInfo } = datasetReshapeInfo[0];
+                if (isLinearColor(advancedVSeed, vseed)) {
+                    if (result?.pie?.style) result.pie.style.fill = {
+                        field: unfoldInfo.encodingColor,
+                        scale: 'color'
+                    };
+                }
+                return result;
+            };
+        const pieStyle = (spec, context)=>{
+            const { advancedVSeed, vseed } = context;
+            const { chartType } = vseed;
+            const { dataset } = advancedVSeed;
+            const showStroke = dataset.length <= 30;
+            const config = advancedVSeed.config?.[chartType];
+            const result = {
+                ...spec,
+                pie: {
+                    style: {
+                        stroke: config?.backgroundColor ?? '#ffffff',
+                        lineWidth: showStroke ? 1 : 0
+                    }
+                }
+            };
+            if (spec.outerRadius) result.pie.state = {
+                hover: {
+                    outerRadius: 1.1 * spec.outerRadius
+                }
+            };
+            if (config?.cornerRadius) result.pie.style.cornerRadius = config.cornerRadius;
+            return result;
+        };
+        const labelPie = (spec, context)=>{
+            const result = {
+                ...spec
+            };
+            const { advancedVSeed, vseed } = context;
+            const { datasetReshapeInfo } = advancedVSeed;
+            const { chartType, encoding } = advancedVSeed;
+            const baseConfig = advancedVSeed.config[chartType];
+            const foldInfo = datasetReshapeInfo[0].foldInfo;
+            const { label } = baseConfig;
+            result.label = buildLabel(label, vseed.measures, vseed.dimensions, advancedVSeed.dimensions, advancedVSeed.measures, encoding, [
+                foldInfo
+            ]);
+            if (label.labelLayout) result.label.layout = {
+                align: label.labelLayout
+            };
+            return result;
+        };
+        const racePie = [
+            initPie,
+            colorAdapter(color_color, linearColor),
+            background_backgroundColor,
+            isPlayer(playerPie, datasetXY),
+            progressive,
+            brush_brush,
+            colorPieStyleFill(pieStyle),
+            colorAdapter(discreteLegend, colorLegend),
+            labelPie,
+            tooltip_tooltip,
+            annotationPoint_annotationPoint,
+            annotationVerticalLine_annotationVerticalLine,
+            annotationHorizontalLine_annotationHorizontalLine,
+            annotationArea_annotationArea
+        ];
+        const racePieSpecPipeline = racePie;
+        const registerRacePie = ()=>{
+            Builder.registerAdvancedPipeline('racePie', racePieAdvancedPipeline);
+            Builder.registerSpecPipeline('racePie', racePieSpecPipeline);
+        };
+        const defaultEncodingForRaceDonut = (advancedVSeed)=>{
+            const { measures = [], reshapeMeasures = [], dimensions = [] } = advancedVSeed;
+            const encoding = {};
+            raceDonut_generateDefaultDimensionEncoding(dimensions, encoding, hasMultipleMeasureInSingleView(reshapeMeasures));
+            raceDonut_generateDefaultMeasureEncoding(measures, encoding);
+            return {
+                ...advancedVSeed,
+                encoding
+            };
+        };
+        const encodingForRaceDonut = (advancedVSeed)=>{
+            const { measures = [], reshapeMeasures = [], dimensions = [] } = advancedVSeed;
+            const hasDimensionEncoding = dimensions.some((item)=>item.encoding);
+            const hasMeasureEncoding = measures.some((item)=>item.encoding);
+            const encoding = {};
+            const hasMulti = hasMultipleMeasureInSingleView(reshapeMeasures);
+            if (hasDimensionEncoding) raceDonut_generateDimensionEncoding(dimensions, encoding, hasMulti);
+            else raceDonut_generateDefaultDimensionEncoding(dimensions, encoding, hasMulti);
+            if (hasMeasureEncoding) raceDonut_generateMeasureEncoding(measures, encoding);
+            else raceDonut_generateDefaultMeasureEncoding(measures, encoding);
+            return {
+                ...advancedVSeed,
+                encoding
+            };
+        };
+        const raceDonut_generateDefaultDimensionEncoding = (dimensions, encoding, isMultiMeasure)=>{
+            const uniqueDimIds = chunk_QJLMYOTX_i(dimensions.map((d)=>d.id));
+            encoding.player = uniqueDimIds.slice(0, 1);
+            encoding.color = uniqueDimIds.slice(1, 2);
+            addDefaultColorEncoding(uniqueDimIds, encoding, isMultiMeasure);
+            encoding.detail = encoding.color;
+            encoding.tooltip = uniqueDimIds.filter((d)=>d !== MeasureId);
+            encoding.label = [];
+            encoding.row = [];
+            encoding.column = [];
+        };
+        const raceDonut_generateDimensionEncoding = (dimensions, encoding, isMultiMeasure)=>{
+            encoding.player = chunk_QJLMYOTX_i(dimensions.filter((item)=>'player' === item.encoding).map((item)=>item.id));
+            addColorToEncoding(dimensions, encoding, isMultiMeasure);
+            encoding.detail = chunk_QJLMYOTX_i(dimensions.filter((item)=>'detail' === item.encoding).map((item)=>item.id));
+            if (0 === encoding.detail.length) encoding.detail = encoding.color;
+            encoding.tooltip = chunk_QJLMYOTX_i(dimensions.map((item)=>item.id));
+            encoding.tooltip = encoding.tooltip.filter((d)=>d !== MeasureId);
+            encoding.label = chunk_QJLMYOTX_i(dimensions.filter((item)=>'label' === item.encoding).map((item)=>item.id));
+            encoding.label = encoding.label.filter((d)=>d !== MeasureId);
+        };
+        const raceDonut_generateDefaultMeasureEncoding = (measures, encoding)=>{
+            encoding.angle = chunk_QJLMYOTX_i(measures.filter((item)=>'angle' === item.encoding || !item.encoding).map((item)=>item.id));
+        };
+        const raceDonut_generateMeasureEncoding = (measures, encoding)=>{
+            encoding.angle = chunk_QJLMYOTX_i(measures.filter((item)=>'angle' === item.encoding || !item.encoding).map((item)=>item.id));
+            const color = chunk_QJLMYOTX_i(measures.filter((item)=>'color' === item.encoding).map((item)=>item.id));
+            if (color.length > 0) encoding.color = color;
+            const label = chunk_QJLMYOTX_i(measures.filter((item)=>'label' === item.encoding).map((item)=>item.id));
+            encoding.label = chunk_QJLMYOTX_i([
+                ...encoding.label || [],
+                ...label
+            ]);
+            const tooltip = chunk_QJLMYOTX_i(measures.filter((item)=>'tooltip' === item.encoding).map((item)=>item.id));
+            encoding.tooltip = chunk_QJLMYOTX_i([
+                ...encoding.tooltip || [],
+                ...label,
+                ...tooltip,
+                ...color
+            ]);
+        };
+        const raceDonutAdvancedPipeline = [
+            page_page_page,
+            initAdvancedVSeed_initAdvancedVSeed,
+            default_defaultMeasures_defaultMeasures,
+            defaultDimensions_defaultDimensions,
+            defaultMeasureId_defaultMeasureId,
+            encodingAdapter([
+                buildMeasures([
+                    'angle',
+                    'detail'
+                ]),
+                defaultEncodingForRaceDonut
+            ], [
+                buildMeasures([
+                    'angle',
+                    'detail'
+                ]),
+                encodingForRaceDonut,
+                pickDimensionsForReshape
+            ]),
+            pivotAdapter([
+                reshapeWithEncoding
+            ], [
+                pivotReshapeWithEncoding
+            ]),
+            donutConfig,
+            theme_theme,
+            annotation_annotation
+        ];
+        const initDonut = (spec, context)=>{
+            const result = {
+                ...spec
+            };
+            const { advancedVSeed } = context;
+            const { datasetReshapeInfo } = advancedVSeed;
+            const { foldInfo, unfoldInfo } = datasetReshapeInfo[0];
+            result.type = 'pie';
+            result.outerRadius = 0.8;
+            result.innerRadius = 0.8 * result.outerRadius;
+            result.valueField = foldInfo.measureValue;
+            result.categoryField = unfoldInfo.encodingColorId;
+            result.padding = 0;
+            result.region = [
+                {
+                    clip: true
+                }
+            ];
+            result.animation = true;
+            return result;
+        };
+        const raceDonut = [
+            initDonut,
+            colorAdapter(color_color, linearColor),
+            background_backgroundColor,
+            isPlayer(playerPie, datasetXY),
             progressive,
-            xLinear,
-            yLinear,
             brush_brush,
-            scatterSize,
-            labelScatter,
-            tooltipScatter,
+            labelPie,
+            colorPieStyleFill(pieStyle),
             colorAdapter(discreteLegend, colorLegend),
-            verticalCrosshairLine,
-            horizontalCrosshairLine,
-            colorPointStyleFill(pointStyle_pointStyle),
-            pointStateHover,
+            tooltip_tooltip,
             annotationPoint_annotationPoint,
             annotationVerticalLine_annotationVerticalLine,
             annotationHorizontalLine_annotationHorizontalLine,
-            annotationArea_annotationArea,
-            linearRegressionLine,
-            lowessRegressionLine,
-            polynomialRegressionLine,
-            logisticRegressionLine
+            annotationArea_annotationArea
         ];
-        const raceScatterSpecPipeline = raceScatter;
-        const registerRaceScatter = ()=>{
-            Builder.registerAdvancedPipeline('raceScatter', raceScatterAdvancedPipeline);
-            Builder.registerSpecPipeline('raceScatter', raceScatterSpecPipeline);
+        const raceDonutSpecPipeline = raceDonut;
+        const registerRaceDonut = ()=>{
+            Builder.registerAdvancedPipeline('raceDonut', raceDonutAdvancedPipeline);
+            Builder.registerSpecPipeline('raceDonut', raceDonutSpecPipeline);
         };
         const barParallelAdvancedPipeline = [
             page_page_page,
@@ -12334,81 +13121,6 @@ self.R = R;
             theme_theme,
             annotation_annotation
         ];
-        const initPie = (spec, context)=>{
-            const result = {
-                ...spec
-            };
-            const { advancedVSeed } = context;
-            const { datasetReshapeInfo } = advancedVSeed;
-            const { unfoldInfo, foldInfo } = datasetReshapeInfo[0];
-            result.type = 'pie';
-            result.outerRadius = 0.8;
-            result.innerRadius = 0;
-            result.valueField = foldInfo.measureValue;
-            result.categoryField = unfoldInfo.encodingColorId;
-            result.padding = 0;
-            result.region = [
-                {
-                    clip: true
-                }
-            ];
-            result.animation = true;
-            return result;
-        };
-        const colorPieStyleFill = (stylePipe)=>(spec, context)=>{
-                const result = stylePipe(spec, context);
-                const { advancedVSeed, vseed } = context;
-                const { datasetReshapeInfo } = advancedVSeed;
-                const { unfoldInfo } = datasetReshapeInfo[0];
-                if (isLinearColor(advancedVSeed, vseed)) {
-                    if (result?.pie?.style) result.pie.style.fill = {
-                        field: unfoldInfo.encodingColor,
-                        scale: 'color'
-                    };
-                }
-                return result;
-            };
-        const pieStyle = (spec, context)=>{
-            const { advancedVSeed, vseed } = context;
-            const { chartType } = vseed;
-            const { dataset } = advancedVSeed;
-            const showStroke = dataset.length <= 30;
-            const config = advancedVSeed.config?.[chartType];
-            const result = {
-                ...spec,
-                pie: {
-                    style: {
-                        stroke: config?.backgroundColor ?? '#ffffff',
-                        lineWidth: showStroke ? 1 : 0
-                    }
-                }
-            };
-            if (spec.outerRadius) result.pie.state = {
-                hover: {
-                    outerRadius: 1.1 * spec.outerRadius
-                }
-            };
-            if (config?.cornerRadius) result.pie.style.cornerRadius = config.cornerRadius;
-            return result;
-        };
-        const labelPie = (spec, context)=>{
-            const result = {
-                ...spec
-            };
-            const { advancedVSeed, vseed } = context;
-            const { datasetReshapeInfo } = advancedVSeed;
-            const { chartType, encoding } = advancedVSeed;
-            const baseConfig = advancedVSeed.config[chartType];
-            const foldInfo = datasetReshapeInfo[0].foldInfo;
-            const { label } = baseConfig;
-            result.label = buildLabel(label, vseed.measures, vseed.dimensions, advancedVSeed.dimensions, advancedVSeed.measures, encoding, [
-                foldInfo
-            ]);
-            if (label.labelLayout) result.label.layout = {
-                align: label.labelLayout
-            };
-            return result;
-        };
         const pivotHideIndicatorName = (spec, context)=>{
             const { advancedVSeed } = context;
             const { datasetReshapeInfo } = advancedVSeed;
@@ -12504,27 +13216,6 @@ self.R = R;
             theme_theme,
             annotation_annotation
         ];
-        const initDonut = (spec, context)=>{
-            const result = {
-                ...spec
-            };
-            const { advancedVSeed } = context;
-            const { datasetReshapeInfo } = advancedVSeed;
-            const { foldInfo, unfoldInfo } = datasetReshapeInfo[0];
-            result.type = 'pie';
-            result.outerRadius = 0.8;
-            result.innerRadius = 0.8 * result.outerRadius;
-            result.valueField = foldInfo.measureValue;
-            result.categoryField = unfoldInfo.encodingColorId;
-            result.padding = 0;
-            result.region = [
-                {
-                    clip: true
-                }
-            ];
-            result.animation = true;
-            return result;
-        };
         const donut = [
             initDonut,
             colorAdapter(color_color, linearColor),
@@ -17793,6 +18484,53 @@ self.R = R;
                 regressionLine: getLightRegressionLine()
             };
         };
+        const getRaceLineTheme = ()=>{
+            const lineTheme = getLineTheme();
+            const player = getLightPlayer();
+            return {
+                ...lineTheme,
+                legend: {
+                    ...lineTheme.legend,
+                    enable: false
+                },
+                xAxis: {
+                    ...lineTheme.xAxis,
+                    animation: {
+                        duration: player.interval
+                    }
+                },
+                label: {
+                    ...lineTheme.label,
+                    enable: false
+                },
+                yAxis: {
+                    ...lineTheme.yAxis,
+                    max: true,
+                    animation: {
+                        duration: player.interval,
+                        easing: 'linear'
+                    },
+                    nice: true
+                },
+                player: {
+                    ...player,
+                    maxCount: false
+                }
+            };
+        };
+        const getRacePieTheme = ()=>{
+            const pieTheme = getPieTheme();
+            const player = getLightPlayer();
+            return {
+                ...pieTheme,
+                legend: {
+                    ...pieTheme.legend,
+                    enable: false
+                },
+                player
+            };
+        };
+        const getRaceDonutTheme = ()=>getRacePieTheme();
         const lightTheme = ()=>{
             const tableConfig = getLightTableConfig();
             return {
@@ -17824,7 +18562,10 @@ self.R = R;
                     circlePacking: getCirclePackingTheme(),
                     raceBar: getRaceBarTheme(),
                     raceColumn: getRaceColumnTheme(),
-                    raceScatter: getRaceScatterTheme()
+                    raceScatter: getRaceScatterTheme(),
+                    raceLine: getRaceLineTheme(),
+                    racePie: getRacePieTheme(),
+                    raceDonut: getRaceDonutTheme()
                 }
             };
         };
@@ -18322,6 +19063,53 @@ self.R = R;
                 player
             };
         };
+        const raceLine_getRaceLineTheme = ()=>{
+            const lineTheme = line_getLineTheme();
+            const player = getDarkPlayer();
+            return {
+                ...lineTheme,
+                legend: {
+                    ...lineTheme.legend,
+                    enable: false
+                },
+                xAxis: {
+                    ...lineTheme.xAxis,
+                    animation: {
+                        duration: player.interval
+                    }
+                },
+                label: {
+                    ...lineTheme.label,
+                    enable: false
+                },
+                yAxis: {
+                    ...lineTheme.yAxis,
+                    max: true,
+                    animation: {
+                        duration: player.interval,
+                        easing: 'linear'
+                    },
+                    nice: true
+                },
+                player: {
+                    ...player,
+                    maxCount: false
+                }
+            };
+        };
+        const racePie_getRacePieTheme = ()=>{
+            const pieTheme = pie_getPieTheme();
+            const player = getDarkPlayer();
+            return {
+                ...pieTheme,
+                legend: {
+                    ...pieTheme.legend,
+                    enable: false
+                },
+                player
+            };
+        };
+        const racePie_getRaceDonutTheme = ()=>racePie_getRacePieTheme();
         const darkTheme = ()=>{
             const tableConfig = getDarkTableConfig();
             return {
@@ -18344,16 +19132,19 @@ self.R = R;
                     radar: radar_getRadarTheme(),
                     rose: rose_getRoseTheme(),
                     roseParallel: rose_getRoseParallelTheme(),
-                    funnel: funnel_getFunnelTheme(),
-                    heatmap: heatmap_getHeatmapTheme(),
-                    histogram: histogram_getHistogramTheme(),
-                    boxPlot: boxPlot_getBoxPlotTheme(),
                     treeMap: hierarchy_getTreeMapTheme(),
                     sunburst: hierarchy_getSunburstTheme(),
                     circlePacking: hierarchy_getCirclePackingTheme(),
                     raceBar: race_getRaceBarTheme(),
                     raceColumn: race_getRaceColumnTheme(),
-                    raceScatter: race_getRaceScatterTheme()
+                    raceScatter: race_getRaceScatterTheme(),
+                    raceLine: raceLine_getRaceLineTheme(),
+                    racePie: racePie_getRacePieTheme(),
+                    raceDonut: racePie_getRaceDonutTheme(),
+                    funnel: funnel_getFunnelTheme(),
+                    heatmap: heatmap_getHeatmapTheme(),
+                    histogram: histogram_getHistogramTheme(),
+                    boxPlot: boxPlot_getBoxPlotTheme()
                 }
             };
         };
@@ -18381,6 +19172,9 @@ self.R = R;
             registerRaceBar();
             registerRaceColumn();
             registerRaceScatter();
+            registerRaceLine();
+            registerRacePie();
+            registerRaceDonut();
             registerBarParallel();
             registerBarPercent();
             registerArea();
@@ -21810,6 +22604,9 @@ self.R = R;
             'raceBar',
             'raceColumn',
             'raceScatter',
+            'raceLine',
+            'racePie',
+            'raceDonut',
             'treeMap',
             'sunburst',
             'circlePacking',
@@ -22925,6 +23722,7 @@ self.R = R;
         });
         const zPlayer = schemas_object({
             interval: schemas_number().optional(),
+            maxCount: schemas_number().or(literal(false)).optional(),
             autoPlay: schemas_boolean().optional(),
             loop: schemas_boolean().optional(),
             position: schemas_enum([
@@ -22948,7 +23746,15 @@ self.R = R;
             player: zPlayer.nullish()
         });
         const zRaceScatterConfig = zScatterConfig.extend({
-            xAxis: zXLinearAxis.nullish(),
+            player: zPlayer.nullish()
+        });
+        const zRaceLineConfig = zScatterConfig.extend({
+            player: zPlayer.nullish()
+        });
+        const zRacePieConfig = zScatterConfig.extend({
+            player: zPlayer.nullish()
+        });
+        const zRaceDonutConfig = zScatterConfig.extend({
             player: zPlayer.nullish()
         });
         const zTreeMapConfig = schemas_object({
@@ -22997,6 +23803,9 @@ self.R = R;
             raceBar: zRaceBarConfig.nullish(),
             raceColumn: zRaceColumnConfig.nullish(),
             raceScatter: zRaceScatterConfig.nullish(),
+            raceLine: zRaceLineConfig.nullish(),
+            racePie: zRacePieConfig.nullish(),
+            raceDonut: zRaceDonutConfig.nullish(),
             treeMap: zTreeMapConfig.nullish(),
             sunburst: zSunburstConfig.nullish(),
             circlePacking: zCirclePackingConfig.nullish(),
@@ -23459,6 +24268,35 @@ self.R = R;
             regressionLine: zRegressionLine.nullish(),
             locale: zLocale.nullish()
         });
+        const zRaceLine = schemas_object({
+            chartType: literal('raceLine'),
+            dataset: zDataset.nullish(),
+            encoding: zEncoding.nullish(),
+            dimensions: zDimensions.nullish(),
+            measures: zMeasures.nullish(),
+            page: zPage.nullish(),
+            player: zPlayer.nullish(),
+            backgroundColor: zBackgroundColor.nullish(),
+            color: zColor.nullish(),
+            label: zLabel.nullish(),
+            legend: zLegend.nullish(),
+            tooltip: zTooltip.nullish(),
+            brush: zBrush.nullish(),
+            xAxis: zXBandAxis.nullish(),
+            yAxis: zYLinearAxis.nullish(),
+            crosshairLine: zCrosshairLine.nullish(),
+            sort: zSort.nullish(),
+            sortLegend: zSortLegend.nullish(),
+            theme: zTheme.nullish(),
+            pointStyle: schemas_array(zPointStyle).or(zPointStyle).nullish(),
+            lineStyle: schemas_array(zLineStyle).or(zLineStyle).nullish(),
+            annotationPoint: schemas_array(zAnnotationPoint).or(zAnnotationPoint).nullish(),
+            annotationVerticalLine: schemas_array(zAnnotationVerticalLine).or(zAnnotationVerticalLine).nullish(),
+            annotationHorizontalLine: schemas_array(zAnnotationHorizontalLine).or(zAnnotationHorizontalLine).nullish(),
+            annotationArea: schemas_array(zAnnotationArea).or(zAnnotationArea).nullish(),
+            dimensionLinkage: zDimensionLinkage.nullish(),
+            locale: zLocale.nullish()
+        });
         const zBarParallel = schemas_object({
             chartType: literal('barParallel'),
             dataset: zDataset.nullish(),
@@ -23781,6 +24619,40 @@ self.R = R;
             theme: zTheme.nullish(),
             locale: zLocale.nullish()
         });
+        const zRacePie = schemas_object({
+            chartType: literal('racePie'),
+            dataset: zDataset.nullish(),
+            encoding: zEncoding.nullish(),
+            dimensions: zDimensions.nullish(),
+            measures: zMeasures.nullish(),
+            page: zPage.nullish(),
+            player: zPlayer.nullish(),
+            backgroundColor: zBackgroundColor.nullish(),
+            color: zColor.nullish(),
+            label: zPieLabel.nullish(),
+            legend: zLegend.nullish(),
+            tooltip: zTooltip.nullish(),
+            brush: zBrush.nullish(),
+            theme: zTheme.nullish(),
+            locale: zLocale.nullish()
+        });
+        const zRaceDonut = schemas_object({
+            chartType: literal('raceDonut'),
+            dataset: zDataset.nullish(),
+            encoding: zEncoding.nullish(),
+            dimensions: zDimensions.nullish(),
+            measures: zMeasures.nullish(),
+            page: zPage.nullish(),
+            player: zPlayer.nullish(),
+            backgroundColor: zBackgroundColor.nullish(),
+            color: zColor.nullish(),
+            label: zPieLabel.nullish(),
+            legend: zLegend.nullish(),
+            tooltip: zTooltip.nullish(),
+            brush: zBrush.nullish(),
+            theme: zTheme.nullish(),
+            locale: zLocale.nullish()
+        });
         const zFunnel = schemas_object({
             chartType: literal('funnel'),
             dataset: zDataset.nullish(),
@@ -23862,12 +24734,15 @@ self.R = R;
             zRose,
             zRoseParallel,
             zRadar,
-            zRaceBar,
-            zRaceColumn,
-            zRaceScatter,
             zTreeMap,
             zSunburst,
             zCirclePacking,
+            zRaceBar,
+            zRaceColumn,
+            zRaceScatter,
+            zRaceLine,
+            zRacePie,
+            zRaceDonut,
             zFunnel,
             zHeatmap,
             zBoxPlot,