@visactor/vchart-types 0.10.0-alpha.2 → 0.11.6-alpha.1

package/types/series/pie/pie.d.ts

@@ -18,8 +18,7 @@ export declare class BasePieSeries<T extends IBasePieSeriesSpec> extends PolarSe
     protected _pieMarkType: MarkTypeEnum;
     static readonly mark: SeriesMarkMap;
     protected _viewDataLabel: SeriesData;
-    protected _center: IPoint | null;
-    get center(): IPoint;
+    getCenter(): IPoint;
     protected _centerOffset: number;
     protected _cornerRadius: number;
     protected _startAngle: number;
@@ -47,7 +46,6 @@ export declare class BasePieSeries<T extends IBasePieSeriesSpec> extends PolarSe
     getMeasureField(): string[];
     private viewDataLabelUpdate;
     protected generateRadiusStyle(spec: any): any;
-    protected computeLayoutRadius(): number;
     computeCenter(datum: Datum): IPoint;
     getRadius(state?: StateValueType): number;
     getInnerRadius(state?: StateValueType): number;
@@ -63,7 +61,7 @@ export declare class BasePieSeries<T extends IBasePieSeriesSpec> extends PolarSe
         reCompile: boolean;
     };
     computeDatumInnerRadius(datum: Datum, state?: string): number;
-    dataToPosition(datum: Datum): IPoint | null;
+    dataToPosition(datum: Datum, checkInViewData?: boolean): IPoint | null;
     dataToCentralPosition: (datum: Datum) => IPoint | null;
     initAnimation(): void;
     getDefaultShapeType(): string;

package/types/series/polar/interface.d.ts

@@ -1,7 +1,7 @@
 import type { ISeriesSpec } from '../../typings/spec/common';
 export interface IPolarSeriesSpec extends ISeriesSpec {
-    centerX?: number;
-    centerY?: number;
+    centerX?: number | string;
+    centerY?: number | string;
     outerRadius?: number;
     innerRadius?: number;
     startAngle?: number;

package/types/series/polar/polar.d.ts

@@ -38,7 +38,7 @@ export declare abstract class PolarSeries<T extends IPolarSeriesSpec = IPolarSer
     get sortDataByAxis(): boolean;
     protected _buildMarkAttributeContext(): void;
     valueToPosition(angleValue: StringOrNumber | StringOrNumber[], radiusValue: StringOrNumber | StringOrNumber[]): IPoint;
-    dataToPosition(datum: Datum): IPoint;
+    dataToPosition(datum: Datum, checkInViewData?: boolean): IPoint;
     dataToPositionX(datum: Datum): number;
     dataToPositionY(datum: Datum): number;
     dataToPositionZ(datum: Datum): number;
@@ -54,7 +54,7 @@ export declare abstract class PolarSeries<T extends IPolarSeriesSpec = IPolarSer
     onAngleAxisHelperUpdate(): void;
     afterInitMark(): void;
     protected _computeLayoutRadius(): number;
-    fillData(): void;
+    protected initEvent(): void;
     _sortDataInAxisDomain(): void;
-    protected _getInvalidDefined: (datum: Datum) => boolean;
+    protected getInvalidCheckFields(): string[];
 }

package/types/series/polar/progress-like/progress-like.d.ts

@@ -8,7 +8,6 @@ import type { IGroupMark } from '../../../mark/group';
 import type { SeriesMarkMap } from '../../interface';
 export declare abstract class ProgressLikeSeries<T extends IProgressLikeSeriesSpec> extends PolarSeries<T> {
     static readonly mark: SeriesMarkMap;
-    protected _supportStack: boolean;
     protected _startAngle: number;
     protected _endAngle: number;
     protected _arcGroupMark: IGroupMark | null;

package/types/series/progress/circular/circular-transformer.d.ts

@@ -0,0 +1,5 @@
+import { BaseSeriesSpecTransformer } from '../../base';
+import type { ICircularProgressSeriesSpec, ICircularProgressSeriesTheme } from './interface';
+export declare class CircularProgressSeriesSpecTransformer<T extends ICircularProgressSeriesSpec = ICircularProgressSeriesSpec, K extends ICircularProgressSeriesTheme = ICircularProgressSeriesTheme> extends BaseSeriesSpecTransformer<T, K> {
+    protected _supportStack: boolean;
+}

package/types/series/progress/circular/circular.d.ts

@@ -4,10 +4,13 @@ import { SeriesTypeEnum } from '../../interface/type';
 import type { ICircularProgressSeriesSpec } from './interface';
 import { ProgressLikeSeries } from '../../polar/progress-like/progress-like';
 import type { IMark } from '../../../mark/interface';
+import { CircularProgressSeriesSpecTransformer } from './circular-transformer';
 export declare class CircularProgressSeries<T extends ICircularProgressSeriesSpec = ICircularProgressSeriesSpec> extends ProgressLikeSeries<T> {
     static readonly type: string;
     type: SeriesTypeEnum;
     static readonly mark: SeriesMarkMap;
+    static readonly transformerConstructor: any;
+    readonly transformerConstructor: typeof CircularProgressSeriesSpecTransformer;
     private _progressMark;
     private _trackMark;
     getStackGroupFields(): string[];

package/types/series/progress/circular/interface.d.ts

@@ -1,20 +1,20 @@
 import type { IAnimationSpec } from '../../../animation/spec';
 import type { IMarkSpec, IMarkTheme } from '../../../typings/spec/common';
-import type { IProgressArcMarkSpec } from '../../../typings/visual';
 import type { ProgressLikeAppearPreset } from '../../polar/progress-like/animation';
 import type { IProgressSeriesSpec } from '../interface';
 import type { IProgressLikeSeriesSpec, IProgressLikeSeriesTheme } from '../../polar/progress-like/interface';
 import type { SeriesMarkNameEnum } from '../../interface/type';
+import type { IArcMarkSpec } from '../../../typings';
 export type CircularProgressMarks = 'progress' | 'track';
 export interface ICircularProgressSeriesSpec extends IProgressSeriesSpec, IProgressLikeSeriesSpec, IAnimationSpec<CircularProgressMarks, ProgressLikeAppearPreset> {
     type: 'circularProgress';
     categoryField?: string | string[];
     radiusField?: string;
     maxValue?: number;
-    [SeriesMarkNameEnum.progress]?: IMarkSpec<IProgressArcMarkSpec>;
-    [SeriesMarkNameEnum.track]?: IMarkSpec<IProgressArcMarkSpec>;
+    [SeriesMarkNameEnum.progress]?: IMarkSpec<IArcMarkSpec>;
+    [SeriesMarkNameEnum.track]?: IMarkSpec<IArcMarkSpec>;
 }
 export interface ICircularProgressSeriesTheme extends IProgressLikeSeriesTheme {
-    [SeriesMarkNameEnum.progress]?: Partial<IMarkTheme<IProgressArcMarkSpec>>;
-    [SeriesMarkNameEnum.track]?: Partial<IMarkTheme<IProgressArcMarkSpec>>;
+    [SeriesMarkNameEnum.progress]?: Partial<IMarkTheme<IArcMarkSpec>>;
+    [SeriesMarkNameEnum.track]?: Partial<IMarkTheme<IArcMarkSpec>>;
 }

package/types/series/radar/interface.d.ts

@@ -1,4 +1,5 @@
 import type { IAnimationSpec } from '../../animation/spec';
+import { IMultiLabelSpec } from '../../component/label';
 import type { IMarkOverlap, IMarkProgressiveConfig } from '../../mark/interface';
 import type { IMarkSpec, IMarkTheme } from '../../typings/spec/common';
 import type { IAreaMarkSpec, ILineMarkSpec, ISymbolMarkSpec } from '../../typings/visual';
@@ -12,7 +13,7 @@ export interface IRadarSeriesSpec extends IRoseLikeSeriesSpec, IAnimationSpec<Ra
     [SeriesMarkNameEnum.point]?: IMarkSpec<ISymbolMarkSpec>;
     [SeriesMarkNameEnum.line]?: IMarkSpec<ILineMarkSpec>;
     [SeriesMarkNameEnum.area]?: IMarkSpec<IAreaMarkSpec>;
-    [SeriesMarkNameEnum.label]?: ILineLikeLabelSpec;
+    [SeriesMarkNameEnum.label]?: IMultiLabelSpec<ILineLikeLabelSpec>;
     seriesMark?: 'point' | 'line' | 'area';
     activePoint?: boolean;
 }

package/types/series/range-area/range-area.d.ts

@@ -1,4 +1,3 @@
-import type { DataView } from '@visactor/vdataset';
 import { AreaSeries } from '../area/area';
 import type { SeriesMarkMap } from '../interface';
 import { SeriesTypeEnum } from '../interface/type';
@@ -9,7 +8,8 @@ export declare class RangeAreaSeries<T extends IAreaSeriesSpec = IAreaSeriesSpec
     static readonly mark: SeriesMarkMap;
     initMark(): void;
     initMarkStyle(): void;
+    initAreaMarkStyle(): void;
     protected initTooltip(): void;
-    viewDataStatisticsUpdate(d: DataView): void;
+    protected _isFieldAllValid(): boolean;
 }
 export declare const registerRangeAreaSeries: () => void;

package/types/series/range-column/interface.d.ts

@@ -1,6 +1,6 @@
 import type { IBarSeriesSpec } from '../bar/interface';
 import type { ICartesianSeriesTheme } from '../cartesian/interface';
-import type { IMarkSpec, IMarkTheme } from '../../typings/spec/common';
+import type { IFormatMethod, IMarkSpec, IMarkTheme } from '../../typings/spec/common';
 import type { IPositionedTextMarkSpec, IRectMarkSpec, ITextMarkSpec } from '../../typings/visual';
 import type { IAnimationSpec } from '../../animation/spec';
 import type { RangeColumnAppearPreset } from './animation';
@@ -26,16 +26,16 @@ export interface IRangeColumnSeriesSpec extends Omit<IBarSeriesSpec, 'type' | 'l
     [SeriesMarkNameEnum.label]?: Partial<ILabelSpec> & {
         position?: PositionEnum;
         [SeriesMarkNameEnum.minLabel]?: IMarkSpec<IPositionedTextMarkSpec> & {
-            visible: boolean;
+            visible?: boolean;
             position?: keyof typeof minMaxPositionEnum;
             offset?: number;
-            formatMethod?: (text: string | string[], datum?: any) => string | string[];
+            formatMethod?: IFormatMethod<[text: string | string[], datum?: any]>;
         };
         [SeriesMarkNameEnum.maxLabel]?: IMarkSpec<IPositionedTextMarkSpec> & {
-            visible: boolean;
+            visible?: boolean;
             position?: minMaxPositionEnum;
             offset?: number;
-            formatMethod?: (text: string | string[], datum?: any) => string | string[];
+            formatMethod?: IFormatMethod<[text: string | string[], datum?: any]>;
         };
     };
 }

package/types/series/range-column/range-column-transformer.d.ts

@@ -1,5 +1,6 @@
 import { BarSeriesSpecTransformer } from '../bar/bar-transformer';
 import type { IRangeColumnSeriesSpec, IRangeColumnSeriesTheme } from './interface';
 export declare class RangeColumnSeriesSpecTransformer<T extends IRangeColumnSeriesSpec = IRangeColumnSeriesSpec, K extends IRangeColumnSeriesTheme = IRangeColumnSeriesTheme> extends BarSeriesSpecTransformer<any, K> {
+    protected _supportStack: boolean;
     protected _transformLabelSpec(spec: T): void;
 }

package/types/series/range-column/range-column.d.ts

@@ -15,7 +15,6 @@ export declare class RangeColumnSeries<T extends IRangeColumnSeriesSpec = IRange
     static readonly mark: SeriesMarkMap;
     static readonly transformerConstructor: any;
     readonly transformerConstructor: any;
-    protected _stack: boolean;
     private _minLabelMark?;
     private _maxLabelMark?;
     private _labelMark?;

package/types/series/rose/interface.d.ts

@@ -5,13 +5,14 @@ import type { SeriesMarkNameEnum } from '../interface/type';
 import type { IRoseLikeSeriesSpec, IRoseLikeSeriesTheme } from '../polar/rose-like';
 import type { RoseAppearPreset } from './animation';
 import type { IArcLabelSpec } from '../pie/interface';
+import { IMultiLabelSpec } from '../../component/label';
 export type RoseMarks = 'rose';
 export interface IRoseSeriesSpec extends IRoseLikeSeriesSpec, IAnimationSpec<RoseMarks, RoseAppearPreset> {
     type: 'rose';
     categoryField: string | string[];
     valueField: string | string[];
     [SeriesMarkNameEnum.rose]?: IMarkSpec<IArcMarkSpec>;
-    [SeriesMarkNameEnum.label]?: IArcLabelSpec;
+    [SeriesMarkNameEnum.label]?: IMultiLabelSpec<IArcLabelSpec>;
 }
 export interface IRoseSeriesTheme extends IRoseLikeSeriesTheme {
     [SeriesMarkNameEnum.rose]?: Partial<IMarkTheme<IArcMarkSpec>>;

package/types/series/rose/rose-transformer.d.ts

@@ -1,5 +1,6 @@
 import { BaseSeriesSpecTransformer } from '../base';
 import type { IRoseSeriesSpec, IRoseSeriesTheme } from './interface';
 export declare class RoseSeriesSpecTransformer<T extends IRoseSeriesSpec = IRoseSeriesSpec, K extends IRoseSeriesTheme = IRoseSeriesTheme> extends BaseSeriesSpecTransformer<T, K> {
+    protected _supportStack: boolean;
     protected _transformLabelSpec(spec: T): void;
 }

package/types/series/rose/rose.d.ts

@@ -13,7 +13,6 @@ export declare class RoseSeries<T extends IRoseSeriesSpec = IRoseSeriesSpec> ext
     static readonly mark: SeriesMarkMap;
     static readonly transformerConstructor: any;
     readonly transformerConstructor: typeof RoseSeriesSpecTransformer;
-    protected _supportStack: boolean;
     private _roseMark;
     protected _labelMark: ITextMark | null;
     initMark(): void;

package/types/series/sankey/interface.d.ts

@@ -25,6 +25,11 @@ export interface ISankeySeriesSpec extends Omit<ISeriesSpec, 'data'>, IAnimation
     linkSortBy?: (a: SankeyLinkElement, b: SankeyLinkElement) => number;
     nodeSortBy?: (a: SankeyNodeElement, b: SankeyNodeElement) => number;
     setNodeLayer?: (datum: SankeyNodeDatum) => number;
+    dropIsolatedNode?: boolean;
+    nodeHeight?: number | ((node: SankeyNodeElement) => number);
+    linkHeight?: number | ((link: SankeyLinkElement, sourceNode: SankeyNodeElement, sourceNodeHeight: number) => number);
+    equalNodeHeight?: boolean;
+    linkOverlap?: 'start' | 'center' | 'end';
     [SeriesMarkNameEnum.node]?: IMarkSpec<IRectMarkSpec>;
     [SeriesMarkNameEnum.link]?: IMarkSpec<ILinkPathMarkSpec>;
     emphasis?: {
@@ -33,8 +38,8 @@ export interface ISankeySeriesSpec extends Omit<ISeriesSpec, 'data'>, IAnimation
         effect: 'self' | 'adjacency' | 'related';
     };
     [SeriesMarkNameEnum.label]?: ILabelSpec & {
-        position: 'outside' | 'inside-start' | 'inside-middle' | 'inside-end' | 'left' | 'right';
-        limit: number;
+        position?: 'outside' | 'inside-start' | 'inside-middle' | 'inside-end' | 'left' | 'right';
+        limit?: number;
     };
 }
 export interface SankeyLinkDatum {

package/types/series/sankey/sankey.d.ts

@@ -1,11 +1,11 @@
 import { CartesianSeries } from '../cartesian/cartesian';
 import type { SeriesMarkMap } from '../interface';
 import { SeriesTypeEnum } from '../interface/type';
-import type { Datum } from '../../typings';
+import type { Datum, StringOrNumber } from '../../typings';
 import { SeriesData } from '../base/series-data';
 import type { ISankeySeriesSpec } from './interface';
 import type { ExtendEventParam } from '../../event/interface';
-import type { IElement, IGlyphElement } from '@visactor/vgrammar-core';
+import type { IElement, IGlyphElement, IMark as IVgrammarMark } from '@visactor/vgrammar-core';
 import type { IMark } from '../../mark/interface';
 export declare class SankeySeries<T extends ISankeySeriesSpec = ISankeySeriesSpec> extends CartesianSeries<T> {
     static readonly type: string;
@@ -22,6 +22,7 @@ export declare class SankeySeries<T extends ISankeySeriesSpec = ISankeySeriesSpe
     private _viewBox;
     protected _categoryField: string;
     private _colorScale;
+    private _nodeList;
     getCategoryField(): string;
     setCategoryField(f: string): string;
     protected _valueField: string;
@@ -30,8 +31,15 @@ export declare class SankeySeries<T extends ISankeySeriesSpec = ISankeySeriesSpe
     setAttrFromSpec(): void;
     initData(): void;
     initMark(): void;
+    protected _buildMarkAttributeContext(): void;
+    valueToNode(value: StringOrNumber | StringOrNumber[]): any;
+    valueToLink(value: StringOrNumber | StringOrNumber[]): any;
+    valueToPositionX(value: StringOrNumber | StringOrNumber[]): any;
+    valueToPositionY(value: StringOrNumber | StringOrNumber[]): any;
     initMarkStyle(): void;
     protected _initNodeMarkStyle(): void;
+    protected _fillByNode: (datum: Datum) => any;
+    protected _fillByLink: (datum: Datum) => any;
     protected _initLinkMarkStyle(): void;
     protected _initLabelMarkStyle(): void;
     private _createText;
@@ -39,18 +47,19 @@ export declare class SankeySeries<T extends ISankeySeriesSpec = ISankeySeriesSpe
     protected initEvent(): void;
     private nodesSeriesDataUpdate;
     private linksSeriesDataUpdate;
-    protected _handleAdjacencyClick: (params: ExtendEventParam) => void;
-    protected _handleRelatedClick: (params: ExtendEventParam) => void;
+    protected _handleEmphasisElement: (params: ExtendEventParam) => void;
     protected _handleClearEmpty: () => void;
     protected _handleNodeAdjacencyClick: (element: IElement) => void;
     protected _handleLinkAdjacencyClick: (element: IGlyphElement) => void;
     protected _handleNodeRelatedClick: (element: IElement) => void;
     protected _handleLinkRelatedClick: (element: IGlyphElement) => void;
+    protected _highLightElements(vGrammarElements: IVgrammarMark['elements'], highlightNodes: string[]): void;
     protected initTooltip(): void;
     _setNodeOrdinalColorScale(): void;
     getNodeList(): any;
     _getNodeNameFromData(datum: Datum): any;
     extractNamesFromTree(tree: any, categoryName: string): Set<unknown>;
+    extractNamesFromLink(links: any[]): Set<unknown>;
     getDimensionField(): string[];
     getMeasureField(): string[];
     getRawDataStatisticsByField(field: string, isNumeric?: boolean): {

package/types/series/scatter/interface.d.ts

@@ -6,6 +6,7 @@ import type { ScatterAppearPreset, ScatterMarks } from './animation';
 import type { IMarkProgressiveConfig } from '../../mark/interface';
 import type { SeriesMarkNameEnum } from '../interface/type';
 import type { ILineLikeLabelSpec } from '../mixin/line-mixin';
+import { IMultiLabelSpec } from '../../component/label';
 export interface IScatterSeriesSpec extends ICartesianSeriesSpec, IAnimationSpec<ScatterMarks, ScatterAppearPreset>, IMarkProgressiveConfig {
     type: 'scatter';
     xField?: string | string[];
@@ -15,7 +16,7 @@ export interface IScatterSeriesSpec extends ICartesianSeriesSpec, IAnimationSpec
     size?: number | number[] | FunctionType<number> | IVisualSpecBase<unknown, number>;
     shapeField?: string;
     shape?: ShapeType | ShapeType[] | FunctionType<ShapeType> | IVisualSpecBase<unknown, ShapeType>;
-    [SeriesMarkNameEnum.label]?: ILineLikeLabelSpec;
+    [SeriesMarkNameEnum.label]?: IMultiLabelSpec<ILineLikeLabelSpec>;
 }
 export interface IScatterSeriesTheme extends ICartesianSeriesTheme {
     size?: number;

package/types/series/sunburst/sunburst.d.ts

@@ -36,7 +36,7 @@ export declare class SunburstSeries extends PolarSeries<any> {
     protected initData(): void;
     getStatisticFields(): {
         key: string;
-        operations: ("max" | "min" | "values")[];
+        operations: ("values" | "max" | "min")[];
     }[];
     protected _addDataIndexAndKey(): void;
     initMark(): void;

package/types/series/sunburst/tooltip-helper.d.ts

@@ -1,5 +1,5 @@
 import type { Datum } from '../../typings';
 import { BaseSeriesTooltipHelper } from '../base/tooltip-helper';
 export declare class SunburstTooltipHelper extends BaseSeriesTooltipHelper {
-    contentKeyCallback: (datum: Datum) => any;
+    markTooltipKeyCallback: (datum: Datum) => any;
 }

package/types/series/treemap/interface.d.ts

@@ -5,6 +5,7 @@ import type { ICartesianSeriesTheme } from '../cartesian/interface';
 import type { IAnimationSpec } from '../../animation/spec';
 import type { TreemapAppearPreset, TreemapMark } from './animation';
 import type { SeriesMarkNameEnum } from '../interface/type';
+import { ILabelSpec } from '../../component';
 export interface ITreemapSeriesSpec extends Omit<ISeriesSpec, 'data'>, IAnimationSpec<TreemapMark, TreemapAppearPreset> {
     type: 'treemap';
     categoryField: string;
@@ -23,8 +24,8 @@ export interface ITreemapSeriesSpec extends Omit<ISeriesSpec, 'data'>, IAnimatio
     drillField?: string;
     [SeriesMarkNameEnum.leaf]?: IMarkSpec<IRectMarkSpec>;
     [SeriesMarkNameEnum.nonLeaf]?: IMarkSpec<IRectMarkSpec>;
-    [SeriesMarkNameEnum.label]?: IMarkSpec<ITextMarkSpec>;
-    [SeriesMarkNameEnum.nonLeafLabel]?: IMarkSpec<ITextMarkSpec> & {
+    [SeriesMarkNameEnum.label]?: Omit<ILabelSpec, 'position' | 'overlap'>;
+    [SeriesMarkNameEnum.nonLeafLabel]?: Omit<ILabelSpec, 'position' | 'overlap'> & {
         position?: TreemapOptions['labelPosition'];
         padding?: TreemapOptions['labelPadding'];
     };

package/types/series/treemap/tooltip-helper.d.ts

@@ -1,5 +1,5 @@
 import { BaseSeriesTooltipHelper } from '../base/tooltip-helper';
 export declare class TreemapTooltipHelper extends BaseSeriesTooltipHelper {
     get defaultShapeType(): string;
-    contentKeyCallback: (datum: any) => any;
+    markTooltipKeyCallback: (datum: any) => any;
 }

package/types/series/treemap/treemap.d.ts

@@ -30,6 +30,8 @@ export declare class TreemapSeries extends CartesianSeries<any> {
     private _enableAnimationHook;
     setAttrFromSpec(): void;
     initData(): void;
+    compile(): void;
+    protected _runTreemapTransform(render?: boolean): void;
     protected _addDataIndexAndKey(): void;
     getRawDataStatisticsByField(field: string, isNumeric?: boolean): any;
     protected _createHierarchyDataStatistics(dataName: string, rawData: DataView[]): DataView;
@@ -57,5 +59,6 @@ export declare class TreemapSeries extends CartesianSeries<any> {
     protected disableMarkAnimation(): void;
     getDefaultShapeType(): string;
     getActiveMarks(): IMark[];
+    isHierarchyData: () => boolean;
 }
 export declare const registerTreemapSeries: () => void;

package/types/series/venn/animation.d.ts

@@ -0,0 +1,6 @@
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+export type VennMark = 'circle' | 'overlap';
+export type VennAppearPreset = 'growIn' | 'fadeIn' | 'scaleIn';
+export declare const vennCirclePresetAnimation: (preset: VennAppearPreset) => IAnimationTypeConfig;
+export declare const vennOverlapPresetAnimation: (preset: VennAppearPreset) => IAnimationTypeConfig;
+export declare const registerVennAnimation: () => void;

package/types/series/venn/constant.d.ts

@@ -0,0 +1,2 @@
+import type { SeriesMarkMap } from '../interface/common';
+export declare const vennSeriesMark: SeriesMarkMap;

package/types/series/venn/interface.d.ts

@@ -0,0 +1,21 @@
+import type { IArcMarkSpec, IPathMarkSpec } from '../../typings';
+import type { IMarkSpec, IMarkTheme, ISeriesSpec } from '../../typings/spec';
+import type { IAnimationSpec } from '../../animation/spec';
+import type { VennAppearPreset, VennMark } from './animation';
+import type { SeriesMarkNameEnum } from '../interface/type';
+import type { ILabelSpec } from '../../component';
+export interface IVennSeriesSpec extends ISeriesSpec, IAnimationSpec<VennMark, VennAppearPreset> {
+    type: 'venn';
+    categoryField?: string;
+    valueField: string;
+    [SeriesMarkNameEnum.circle]?: IMarkSpec<IArcMarkSpec>;
+    [SeriesMarkNameEnum.overlap]?: IMarkSpec<IPathMarkSpec>;
+    [SeriesMarkNameEnum.label]?: Omit<ILabelSpec, 'position'>;
+    [SeriesMarkNameEnum.overlapLabel]?: Omit<ILabelSpec, 'position'>;
+}
+export interface IVennSeriesTheme {
+    [SeriesMarkNameEnum.circle]?: Partial<IMarkTheme<IArcMarkSpec>>;
+    [SeriesMarkNameEnum.overlap]?: Partial<IMarkTheme<IPathMarkSpec>>;
+    [SeriesMarkNameEnum.label]?: Omit<ILabelSpec, 'position'>;
+    [SeriesMarkNameEnum.overlapLabel]?: Omit<ILabelSpec, 'position'>;
+}

package/types/series/venn/tooltip-helper.d.ts

@@ -0,0 +1,5 @@
+import { BaseSeriesTooltipHelper } from '../base/tooltip-helper';
+export declare class VennTooltipHelper extends BaseSeriesTooltipHelper {
+    dimensionTooltipTitleCallback: (datum: any) => string;
+    markTooltipKeyCallback: (datum: any) => string;
+}

package/types/series/venn/util.d.ts

@@ -0,0 +1 @@
+export declare const getVennSeriesDataKey: (sets: string | string[]) => string;

package/types/series/venn/venn-transform.d.ts

@@ -0,0 +1,6 @@
+import type { ISeriesSpec } from '../../typings';
+import { BaseSeriesSpecTransformer } from '../base';
+import type { IVennSeriesSpec, IVennSeriesTheme } from './interface';
+export declare class VennSeriesSpecTransformer<T extends ISeriesSpec = Omit<IVennSeriesSpec, 'data'>, K extends IVennSeriesTheme = IVennSeriesTheme> extends BaseSeriesSpecTransformer<T, K> {
+    protected _transformLabelSpec(spec: T): void;
+}

package/types/series/venn/venn.d.ts

@@ -0,0 +1,63 @@
+import type { IMark } from '../../mark/interface';
+import type { Datum, IPoint, StringOrNumber } from '../../typings';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { IVennSeriesSpec } from './interface';
+import type { ILabelMark } from '../../mark/label';
+import { VennSeriesSpecTransformer } from './venn-transform';
+import { BaseSeries } from '../base';
+import type { BaseLegend } from '../../component/legend/base-legend';
+export declare class VennSeries<T extends IVennSeriesSpec = IVennSeriesSpec> extends BaseSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    static readonly transformerConstructor: typeof VennSeriesSpecTransformer;
+    readonly transformerConstructor: typeof VennSeriesSpecTransformer;
+    private _circleMark;
+    private _overlapMark;
+    private _labelMark;
+    protected _spec: T;
+    private _viewBox;
+    protected _categoryField: string;
+    getCategoryField(): string;
+    setCategoryField(f: string): string;
+    protected _valueField: string;
+    getValueField(): string;
+    setValueField(f: string): string;
+    setAttrFromSpec(): void;
+    compile(): void;
+    protected _runVennTransform(render?: boolean): void;
+    initMark(): void;
+    initMarkStyle(): void;
+    protected _initCircleMarkStyle(): void;
+    protected _initOverlapMarkStyle(): void;
+    initLabelMarkStyle(labelMark: ILabelMark): void;
+    initOverlapLabelMarkStyle(labelMark: ILabelMark): void;
+    protected initTooltip(): void;
+    getDimensionField(): string[];
+    getMeasureField(): string[];
+    onLayoutEnd(ctx: any): void;
+    getDefaultShapeType(): string;
+    getActiveMarks(): IMark[];
+    getStatisticFields(): {
+        key: string;
+        operations: Array<'max' | 'min' | 'values'>;
+    }[];
+    getGroupFields(): string[];
+    dataToPosition(data: Datum, checkInViewData?: boolean): IPoint;
+    dataToPositionX(data: Datum): number;
+    dataToPositionY(data: Datum): number;
+    valueToPosition(value1: any, value2?: any): IPoint;
+    getStackGroupFields(): string[];
+    getStackValueField(): string;
+    protected _getSeriesInfo(field: string, keys: string[]): {
+        key: string;
+        originalKey: string;
+        style: (attribute: string) => unknown;
+        shapeType: string;
+    }[];
+    getSeriesFieldValue(datum: Datum, seriesField?: string): string;
+    legendSelectedFilter(component: BaseLegend<any>, selectedKeys: StringOrNumber[]): StringOrNumber[];
+    initAnimation(): void;
+}
+export declare const registerVennSeries: () => void;

package/types/series/waterfall/interface.d.ts

@@ -2,7 +2,7 @@ import type { Datum, IMarkSpec, IMarkTheme, IRuleMarkSpec, ITextMarkSpec } from
 import type { IAnimationSpec } from '../../animation/spec';
 import type { WaterfallAppearPreset } from './animation';
 import type { IBarSeriesSpec, IBarSeriesTheme } from '../bar/interface';
-import type { ILabelSpec } from '../../component/label';
+import type { ILabelSpec, ITotalLabelSpec } from '../../component/label';
 import type { SeriesMarkNameEnum } from '../interface/type';
 type WaterfallMarks = 'bar';
 export interface IWaterfallTotalText {
@@ -40,6 +40,11 @@ export interface IWaterfallSeriesSpec extends Omit<IBarSeriesSpec, 'type' | 'lab
         offset?: number;
         valueType?: IWaterfallStackLabelValueType;
     };
+    totalLabel?: ITotalLabelSpec & {
+        position?: IWaterfallStackLabelPosition;
+        offset?: number;
+        valueType?: IWaterfallStackLabelValueType;
+    };
     [SeriesMarkNameEnum.label]?: ILabelSpec & {
         visible: boolean;
         offset?: number;

package/types/series/waterfall/waterfall-transformer.d.ts

@@ -1,5 +1,6 @@
 import { BarSeriesSpecTransformer } from '../bar/bar-transformer';
 import type { IWaterfallSeriesSpec, IWaterfallSeriesTheme } from './interface';
 export declare class WaterfallSeriesSpecTransformer<T extends IWaterfallSeriesSpec = IWaterfallSeriesSpec, K extends IWaterfallSeriesTheme = IWaterfallSeriesTheme> extends BarSeriesSpecTransformer<any, K> {
+    protected _supportStack: boolean;
     protected _transformLabelSpec(spec: T): void;
 }

package/types/series/waterfall/waterfall.d.ts

@@ -9,6 +9,7 @@ import type { ITextMark } from '../../mark/text';
 import type { IModelEvaluateOption } from '../../model/interface';
 import type { Datum } from '../../typings';
 import type { ILabelMark } from '../../mark/label';
+import type { ILabelInfo } from '../../component/label/label';
 export declare const DefaultBandWidth = 6;
 export declare class WaterfallSeries<T extends IWaterfallSeriesSpec = IWaterfallSeriesSpec> extends BarSeries<any> {
     static readonly type: string;
@@ -16,7 +17,6 @@ export declare class WaterfallSeries<T extends IWaterfallSeriesSpec = IWaterfall
     static readonly mark: SeriesMarkMap;
     static readonly transformerConstructor: any;
     readonly transformerConstructor: any;
-    protected _stack: boolean;
     protected _totalData?: SeriesData;
     getTotalData(): any;
     protected _spec: T;
@@ -34,6 +34,14 @@ export declare class WaterfallSeries<T extends IWaterfallSeriesSpec = IWaterfall
     onEvaluateEnd(ctx: IModelEvaluateOption): void;
     initMark(): void;
     initLabelMarkStyle(labelMark: ILabelMark): void;
+    initTotalLabelMarkStyle(labelMark: ILabelMark): void;
+    getTotalLabelComponentStyle(info: Pick<ILabelInfo, 'baseMark' | 'labelMark'>): {
+        customLayoutFunc: (labels: import("@visactor/vrender-components").LabelItem[]) => import("@visactor/vrender-core").IText[];
+        dataFilter: (labels: import("@visactor/vrender-components").LabelItem[]) => import("@visactor/vrender-components").LabelItem[];
+        overlap: {
+            strategy: any;
+        };
+    };
     totalPositionX(datum: Datum, field: string, pos?: number): number;
     totalPositionY(datum: Datum, field: string, pos?: number): number;
     initMarkStyle(): void;

package/types/series/word-cloud/base.d.ts

@@ -36,7 +36,9 @@ export declare class BaseWordCloudSeries<T extends IBaseWordCloudSeriesSpec = IB
     protected _defaultFontFamily: string;
     protected _keyWordColorCallback: (datum: Datum) => string;
     protected _fillingColorCallback: (datum: Datum) => string;
+    protected _dataChange: boolean;
     setAttrFromSpec(): void;
+    protected initData(): void;
     protected _wordMark: ITextMark;
     initMark(): void;
     initMarkStyle(): void;

package/types/series/word-cloud/interface.d.ts

@@ -1,4 +1,4 @@
-import type { ITextMarkSpec, IMarkSpec, ISeriesSpec } from '../../typings';
+import type { ITextMarkSpec, IMarkSpec, ISeriesSpec, ITextFormatMethod } from '../../typings';
 import type { IAnimationSpec, IMarkAnimateSpec, IStateAnimateSpec } from '../../animation/spec';
 import type { SeriesMarkNameEnum } from '../interface/type';
 import type { WordcloudAppearPreset } from './animation';
@@ -71,7 +71,7 @@ export interface IWordCloudSeriesBaseSpec extends ISeriesSpec, IAnimationSpec<st
     wordCloudShapeConfig?: WordCloudShapeConfigType;
     [SeriesMarkNameEnum.word]?: IMarkSpec<ITextMarkSpec> & {
         padding?: number;
-        formatMethod?: (datum?: any) => string;
+        formatMethod?: ITextFormatMethod<[datum?: any]>;
     };
     [SeriesMarkNameEnum.fillingWord]?: IMarkSpec<ITextMarkSpec> & {
         padding?: number;
@@ -87,11 +87,9 @@ export interface IWordCloudSeriesSpec extends IWordCloudSeriesBaseSpec {
 export interface IWordCloudSeriesTheme {
     [SeriesMarkNameEnum.word]?: IMarkSpec<ITextMarkSpec> & {
         padding?: number;
-        formatMethod?: (datum?: any) => string;
     };
     [SeriesMarkNameEnum.fillingWord]?: IMarkSpec<ITextMarkSpec> & {
         padding?: number;
-        formatMethod?: (datum?: any) => string;
     };
 }
 export interface IWordCloud3dSeriesSpec extends IWordCloudSeriesBaseSpec {
@@ -102,10 +100,8 @@ export interface IWordCloud3dSeriesSpec extends IWordCloudSeriesBaseSpec {
 export interface IWordCloud3dSeriesTheme {
     [SeriesMarkNameEnum.word]?: IMarkSpec<ITextMarkSpec> & {
         padding?: number;
-        formatMethod?: (text: string | string[], datum?: any) => string | string[];
     };
     [SeriesMarkNameEnum.fillingWord]?: IMarkSpec<ITextMarkSpec> & {
         padding?: number;
-        formatMethod?: (text: string | string[], datum?: any) => string | string[];
     };
 }

package/types/theme/builtin/common/series/venn.d.ts

@@ -0,0 +1,2 @@
+import type { IVennSeriesTheme } from '../../../../series/venn/interface';
+export declare const venn: IVennSeriesTheme;

package/types/theme/index.d.ts

@@ -2,3 +2,4 @@ export * from './builtin';
 export * from './interface';
 export * from './theme-manager';
 export * from './color-scheme';
+export * from './token';