@visactor/vchart 1.2.0-beta.6 → 1.2.0-beta.7

package/build/es5/series/pie/pie-3d.d.ts

@@ -0,0 +1,16 @@
+import { MarkTypeEnum } from '../../mark/interface';
+import type { IArcSeries, SeriesMarkMap } from '../interface';
+import { SeriesMarkNameEnum } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { IPie3dSeriesSpec } from './interface';
+import { BasePieSeries } from './pie';
+export declare class Pie3dSeries extends BasePieSeries<IPie3dSeriesSpec> implements IArcSeries {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    protected _pieMarkName: SeriesMarkNameEnum;
+    protected _pieMarkType: MarkTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _angle3d: number;
+    setAttrFromSpec(): void;
+    initMarkStyle(): void;
+}

package/build/es5/series/pie/pie.d.ts

@@ -0,0 +1,79 @@
+import type { Maybe, IPoint, Datum, StateValueType } from '../../typings';
+import type { IModelLayoutOption } from '../../model/interface';
+import { PolarSeries } from '../polar/polar';
+import type { IMark } from '../../mark/interface';
+import { MarkTypeEnum } from '../../mark/interface';
+import type { IArcMark } from '../../mark/arc';
+import type { ITextMark } from '../../mark/text';
+import type { IPathMark } from '../../mark/path';
+import type { IArcSeries, SeriesMarkMap } from '../interface';
+import { SeriesMarkNameEnum } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { IArcLabelSpec, IPieSeriesSpec, IPieSeriesTheme } from './interface';
+import { SeriesData } from '../base/series-data';
+type IBasePieSeriesSpec = Omit<IPieSeriesSpec, 'type'> & {
+    type: string;
+};
+export declare class BasePieSeries<T extends IBasePieSeriesSpec> extends PolarSeries<T> implements IArcSeries {
+    protected _pieMarkName: SeriesMarkNameEnum;
+    protected _pieMarkType: MarkTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _viewDataLabel: SeriesData;
+    protected _center: IPoint | null;
+    get center(): IPoint;
+    protected _centerOffset: number;
+    protected _cornerRadius: number;
+    protected _startAngle: number;
+    protected _endAngle: number;
+    protected _padAngle: number;
+    protected _pieMark: IArcMark | null;
+    protected _labelMark: ITextMark | null;
+    protected _labelLineMark: IPathMark | null;
+    protected _theme: Maybe<IPieSeriesTheme>;
+    setAttrFromSpec(): void;
+    initData(): void;
+    initMark(): void;
+    initMarkStyle(): void;
+    initMarkStyleWithSpec(mark?: IMark, spec?: any, key?: string): void;
+    afterInitMark(): void;
+    initEvent(): void;
+    initGroups(): void;
+    onLayoutEnd(ctx: IModelLayoutOption): void;
+    getDimensionField(): string[];
+    getMeasureField(): string[];
+    private viewDataLabelUpdate;
+    protected generateRadiusStyle(spec: any): any;
+    protected computeLayoutRadius(): number;
+    computeCenter(datum: Datum): IPoint;
+    protected generateLinePath(state: StateValueType): {
+        path: (datum: Datum) => string;
+    };
+    getRadius(state?: StateValueType): number;
+    getInnerRadius(state?: StateValueType): number;
+    getLabelConfig(): IArcLabelSpec;
+    computeRadius(r: number, k?: number): number;
+    computeDatumRadius(datum: Datum, state?: string): number;
+    updateSpec(spec: any): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    computeDatumInnerRadius(datum: Datum, state?: string): number;
+    dataToPosition(datum: Datum): IPoint | null;
+    dataToCentralPosition: (datum: Datum) => IPoint | null;
+    initAnimation(): void;
+    getDefaultShapeType(): string;
+    getGroupFields(): string[];
+    getStackGroupFields(): string[];
+    getStackValueField(): string;
+    setValueFieldToStack(): void;
+    setValueFieldToPercent(): void;
+    protected _noAnimationDataKey(datum: Datum, index: number): number;
+}
+export declare class PieSeries extends BasePieSeries<IPieSeriesSpec> implements IArcSeries {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+}
+export {};

package/build/es5/series/polar/animation.d.ts

@@ -0,0 +1,41 @@
+import type { EasingType } from '@visactor/vrender';
+import { ACustomAnimate, TagPointsUpdate } from '@visactor/vrender';
+import type { IPolarAxisHelper } from '../../component/axis';
+export declare class PolarPointUpdate extends ACustomAnimate<{
+    x: number;
+    y: number;
+}> {
+    valid: boolean;
+    private _fromAngle;
+    private _fromRadius;
+    private _toAngle;
+    private _toRadius;
+    private _pointToCoord;
+    private _coordToPoint;
+    constructor(from: {
+        x: number;
+        y: number;
+    }, to: {
+        x: number;
+        y: number;
+    }, duration: number, easing: EasingType, params: {
+        pointToCoord: IPolarAxisHelper['pointToCoord'];
+        coordToPoint: IPolarAxisHelper['coordToPoint'];
+    });
+    getEndProps(): Record<string, any>;
+    onBind(): void;
+    onUpdate(end: boolean, ratio: number, out: Record<string, any>): void;
+}
+export declare class PolarTagPointsUpdate extends TagPointsUpdate {
+    private points;
+    private interpolatePoints;
+    private _pointToCoord;
+    private _coordToPoint;
+    constructor(from: any, to: any, duration: number, easing: EasingType, params?: {
+        newPointAnimateType?: 'grow' | 'appear';
+        pointToCoord: IPolarAxisHelper['pointToCoord'];
+        coordToPoint: IPolarAxisHelper['coordToPoint'];
+    });
+    onUpdate(end: boolean, ratio: number, out: Record<string, any>): void;
+    private polarPointInterpolation;
+}

package/build/es5/series/polar/interface.d.ts

@@ -0,0 +1,21 @@
+import type { ISeriesSpec } from '../../typings/spec/common';
+export interface IPolarSeriesSpec extends ISeriesSpec {
+    centerX?: number;
+    centerY?: number;
+    outerRadius?: number;
+    innerRadius?: number;
+    startAngle?: number;
+    endAngle?: number;
+    categoryField?: string | string[];
+    valueField?: string | string[];
+    radiusField?: string | string[];
+    angleField?: string | string[];
+    radius?: number;
+}
+export interface IPolarSeriesTheme {
+    radius?: number;
+    outerRadius?: number;
+    innerRadius?: number;
+    startAngle?: number;
+    endAngle?: number;
+}

package/build/es5/series/polar/polar.d.ts

@@ -0,0 +1,62 @@
+import type { IBaseScale } from '@visactor/vscale';
+import type { IPoint, IPolarPoint } from '../../typings/coordinate';
+import type { IPolarSeries } from '../interface';
+import type { IPolarAxisHelper } from '../../component/axis/polar/interface';
+import { BaseSeries } from '../base/base-series';
+import type { IPolarSeriesSpec } from './interface';
+import type { Datum, StringOrNumber } from '../../typings';
+export declare abstract class PolarSeries<T extends IPolarSeriesSpec = IPolarSeriesSpec> extends BaseSeries<T> implements IPolarSeries {
+    readonly coordinate: 'polar';
+    protected _outerRadius: number;
+    get outerRadius(): number;
+    protected _innerRadius: number;
+    get innerRadius(): number;
+    protected _angleField: string[];
+    getAngleField(): string[];
+    setAngleField(f: string | string[]): string[];
+    protected _radiusField: string[];
+    getRadiusField(): string[];
+    setRadiusField(f: string | string[]): string[];
+    protected _innerRadiusField: string[];
+    get innerRadiusField(): string[];
+    setInnerRadiusField(f: string | string[]): string[];
+    protected _radiusScale: IBaseScale;
+    get radiusScale(): IBaseScale;
+    setRadiusScale(s: IBaseScale): IBaseScale;
+    protected _angleScale: IBaseScale;
+    get angleScale(): IBaseScale;
+    setAngleScale(s: IBaseScale): IBaseScale;
+    private _angleAxisHelper;
+    get angleAxisHelper(): IPolarAxisHelper;
+    set angleAxisHelper(h: IPolarAxisHelper);
+    private _radiusAxisHelper;
+    get radiusAxisHelper(): IPolarAxisHelper;
+    set radiusAxisHelper(h: IPolarAxisHelper);
+    protected _buildMarkAttributeContext(): void;
+    valueToPosition(angleValue: StringOrNumber | StringOrNumber[], radiusValue: StringOrNumber | StringOrNumber[]): IPoint;
+    dataToPosition(datum: Datum): IPoint;
+    dataToPositionX(datum: Datum): number;
+    dataToPositionY(datum: Datum): number;
+    dataToPositionZ(datum: Datum): number;
+    positionToData(p: IPolarPoint): any;
+    radiusToData(r: number): any;
+    angleToData(a: number): any;
+    getStatisticFields(): {
+        key: string;
+        operations: Array<'max' | 'min' | 'values'>;
+    }[];
+    protected _getDefaultSpecFromChart(chartSpec: any): Partial<T>;
+    setAttrFromSpec(): void;
+    updateSpec(spec: any): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    onRadiusAxisHelperUpdate(): void;
+    onAngleAxisHelperUpdate(): void;
+    afterInitMark(): void;
+    protected _computeLayoutRadius(): number;
+    setValueFieldToStackOffsetSilhouette(): void;
+}

package/build/es5/series/polar/progress-like/animation.d.ts

@@ -0,0 +1,6 @@
+import type { IAnimationTypeConfig } from '@visactor/vgrammar';
+export type ProgressLikeAppearPreset = 'grow' | 'fadeIn';
+export interface IProgressLikeAnimationParams {
+    startAngle?: number;
+}
+export declare function progressLikePresetAnimation(params: IProgressLikeAnimationParams, preset: ProgressLikeAppearPreset): IAnimationTypeConfig;

package/build/es5/series/polar/progress-like/index.d.ts

@@ -0,0 +1,3 @@
+export * from './progress-like';
+export * from './interface';
+export * from './animation';

package/build/es5/series/polar/progress-like/interface.d.ts

@@ -0,0 +1,9 @@
+import type { IPolarSeriesSpec, IPolarSeriesTheme } from '../interface';
+export interface IProgressLikeSeriesSpec extends IPolarSeriesSpec {
+    roundCap?: boolean | [boolean, boolean];
+    cornerRadius?: number;
+}
+export interface IProgressLikeSeriesTheme extends IPolarSeriesTheme {
+    roundCap?: boolean | [boolean, boolean];
+    cornerRadius?: number;
+}

package/build/es5/series/polar/progress-like/progress-like.d.ts

@@ -0,0 +1,22 @@
+import type { Datum } from '@visactor/vgrammar';
+import type { IMarkStyle } from '../../../mark/interface';
+import type { ConvertToMarkStyleSpec, ICommonSpec } from '../../../typings';
+import { PolarSeries } from '../polar';
+import type { IProgressLikeSeriesSpec } from './interface';
+export declare abstract class ProgressLikeSeries<T extends IProgressLikeSeriesSpec> extends PolarSeries<T> {
+    protected _stack: boolean;
+    protected _startAngle: number;
+    protected _endAngle: number;
+    setAttrFromSpec(): void;
+    getStackGroupFields(): string[];
+    getStackValueField(): string;
+    setValueFieldToStack(): void;
+    setValueFieldToPercent(): void;
+    setValueFieldToStackOffsetSilhouette(): void;
+    getGroupFields(): string[];
+    protected _convertMarkStyle<T extends ICommonSpec = ICommonSpec>(style: Partial<IMarkStyle<T> | ConvertToMarkStyleSpec<T>>): Partial<IMarkStyle<T> | ConvertToMarkStyleSpec<T>>;
+    protected _getAngleValueStart(datum: Datum): number;
+    protected _getAngleValueEnd(datum: Datum): number;
+    getDimensionField(): string[];
+    getMeasureField(): string[];
+}

package/build/es5/series/polar/rose-like/index.d.ts

@@ -0,0 +1,2 @@
+export * from './rose-like';
+export * from './interface';

package/build/es5/series/polar/rose-like/interface.d.ts

@@ -0,0 +1,8 @@
+import type { ILabelSpec } from '../../../component/label';
+import type { IPolarSeriesSpec, IPolarSeriesTheme } from '../interface';
+export interface IRoseLikeSeriesSpec extends IPolarSeriesSpec {
+    label?: Partial<ILabelSpec>;
+}
+export interface IRoseLikeSeriesTheme extends IPolarSeriesTheme {
+    label?: Partial<ILabelSpec>;
+}

package/build/es5/series/polar/rose-like/rose-like.d.ts

@@ -0,0 +1,14 @@
+import { PolarSeries } from '../polar';
+import type { IRoseLikeSeriesSpec } from './interface';
+export declare abstract class RoseLikeSeries<T extends IRoseLikeSeriesSpec> extends PolarSeries<T> {
+    getStackGroupFields(): string[];
+    getStackValueField(): string;
+    getGroupFields(): string[];
+    setAttrFromSpec(): void;
+    setValueFieldToStack(): void;
+    setValueFieldToPercent(): void;
+    getDimensionField(): string[];
+    getMeasureField(): string[];
+    getDefaultShapeType(): string;
+    setValueFieldToStackOffsetSilhouette(): void;
+}

package/build/es5/series/progress/circular/circular.d.ts

@@ -0,0 +1,22 @@
+import type { Maybe, Datum } from '../../../typings';
+import type { SeriesMarkMap } from '../../interface';
+import { SeriesTypeEnum } from '../../interface';
+import type { ICircularProgressSeriesSpec, ICircularProgressSeriesTheme } from './interface';
+import { ProgressLikeSeries } from '../../polar/progress-like/progress-like';
+export declare class CircularProgressSeries extends ProgressLikeSeries<ICircularProgressSeriesSpec> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _theme: Maybe<ICircularProgressSeriesTheme>;
+    private _progressMark;
+    private _trackMark;
+    getStackGroupFields(): string[];
+    getGroupFields(): string[];
+    initMark(): void;
+    initMarkStyle(): void;
+    private initProgressMarkStyle;
+    private initTrackMarkStyle;
+    protected _getRadiusValueStart(datum: Datum): number;
+    protected _getRadiusValueEnd(datum: Datum): number;
+    initAnimation(): void;
+}

package/build/es5/series/progress/circular/index.d.ts

@@ -0,0 +1 @@
+export * from './circular';

package/build/es5/series/progress/circular/interface.d.ts

@@ -0,0 +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';
+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>;
+}
+export interface ICircularProgressSeriesTheme extends IProgressLikeSeriesTheme {
+    [SeriesMarkNameEnum.progress]?: Partial<IMarkTheme<IProgressArcMarkSpec>>;
+    [SeriesMarkNameEnum.track]?: Partial<IMarkTheme<IProgressArcMarkSpec>>;
+}

package/build/es5/series/progress/interface.d.ts

@@ -0,0 +1,7 @@
+import type { IMarkSpec, ISeriesSpec } from '../../typings/spec/common';
+import type { IArcMarkSpec, IRectMarkSpec, IGroupMarkSpec } from '../../typings/visual';
+export interface IProgressSeriesSpec extends ISeriesSpec {
+    cornerRadius?: number;
+    progress?: IMarkSpec<IArcMarkSpec> | IMarkSpec<IRectMarkSpec>;
+    track?: IMarkSpec<IArcMarkSpec> | IMarkSpec<IGroupMarkSpec>;
+}

package/build/es5/series/progress/linear/animation.d.ts

@@ -0,0 +1,9 @@
+import type { IAnimationTypeConfig } from '@visactor/vgrammar';
+import type { DirectionType } from '../../../typings';
+export interface ILinearProgressAnimationParams {
+    direction: DirectionType;
+}
+export type LinearProgressAppearPreset = 'grow' | 'fadeIn';
+export declare const linearProgressDisappear: (params: ILinearProgressAnimationParams) => IAnimationTypeConfig;
+export declare const Appear_FadeIn: IAnimationTypeConfig;
+export declare function linearProgressPresetAnimation(params: ILinearProgressAnimationParams, preset: LinearProgressAppearPreset | boolean): IAnimationTypeConfig;

package/build/es5/series/progress/linear/index.d.ts

@@ -0,0 +1 @@
+export * from './linear';

package/build/es5/series/progress/linear/interface.d.ts

@@ -0,0 +1,26 @@
+import type { IAnimationSpec } from '../../../animation/spec';
+import type { DirectionType } from '../../../typings';
+import type { IMarkSpec, IMarkTheme } from '../../../typings/spec/common';
+import type { IRectMarkSpec } from '../../../typings/visual';
+import type { SeriesMarkNameEnum } from '../../interface';
+import type { IProgressSeriesSpec } from '../interface';
+import type { LinearProgressAppearPreset } from './animation';
+export interface ILinearProgressSeriesSpec extends IProgressSeriesSpec, IAnimationSpec<string, LinearProgressAppearPreset> {
+    type: 'linearProgress';
+    xField: string | string[];
+    yField: string | string[];
+    direction?: DirectionType;
+    bandWidth?: number;
+    [SeriesMarkNameEnum.progress]?: IMarkSpec<IRectMarkSpec> & {
+        topPadding?: number;
+        bottomPadding?: number;
+        leftPadding?: number;
+        rightPadding?: number;
+    };
+    [SeriesMarkNameEnum.track]?: IMarkSpec<IRectMarkSpec>;
+}
+export interface ILinearProgressSeriesTheme {
+    bandWidth?: number;
+    [SeriesMarkNameEnum.progress]?: Partial<IMarkTheme<IRectMarkSpec>>;
+    [SeriesMarkNameEnum.track]?: Partial<IMarkTheme<IRectMarkSpec>>;
+}

package/build/es5/series/progress/linear/linear.d.ts

@@ -0,0 +1,24 @@
+import { CartesianSeries } from '../../cartesian/cartesian';
+import type { SeriesMarkMap } from '../../interface';
+import { SeriesTypeEnum } from '../../interface';
+import type { Maybe } from '../../../typings';
+import type { ILinearProgressSeriesSpec, ILinearProgressSeriesTheme } from './interface';
+export declare class LinearProgressSeries extends CartesianSeries<ILinearProgressSeriesSpec> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _theme: Maybe<ILinearProgressSeriesTheme>;
+    private _progressMark;
+    private _trackMark;
+    private _progressGroupMark;
+    initMark(): void;
+    initMarkStyle(): void;
+    private initProgressMark;
+    private initProgressMarkStyle;
+    private initTrackMark;
+    private initTrackMarkStyle;
+    private initProgressGroupMark;
+    private initProgressGroupMarkStyle;
+    initAnimation(): void;
+    protected initTooltip(): void;
+}

package/build/es5/series/progress/linear/tooltip-helper.d.ts

@@ -0,0 +1,7 @@
+import { BaseSeriesTooltipHelper } from '../../base/tooltip-helper';
+import type { ISeriesTooltipHelper } from '../../interface';
+import type { ITooltipPattern, TooltipActiveType } from '../../../typings';
+import type { IDimensionInfo } from '../../../event/events/dimension/interface';
+export declare class LinearProgressSeriesTooltipHelper extends BaseSeriesTooltipHelper implements ISeriesTooltipHelper {
+    getDefaultTooltipPattern(activeType: TooltipActiveType, dimensionInfo?: IDimensionInfo[]): ITooltipPattern | null;
+}

package/build/es5/series/radar/animation.d.ts

@@ -0,0 +1,72 @@
+import type { Datum, IAnimationTypeConfig, IElement } from '@visactor/vgrammar';
+import type { IPoint, Maybe } from '../../typings';
+import type { IPolarAxisHelper } from '../../component/axis';
+export interface IRadarAnimationParams {
+    center: () => Maybe<IPoint>;
+    radius: () => number;
+    startAngle: number;
+    pointToCoord: IPolarAxisHelper['pointToCoord'];
+    coordToPoint: IPolarAxisHelper['coordToPoint'];
+}
+export type RadarAppearPreset = 'grow' | 'fadeIn' | 'clipIn';
+export declare const radarFadeAnimation: (animationType: 'in' | 'out') => {
+    type: string;
+};
+export declare const radarGrowAnimation: (params: IRadarAnimationParams, animationType: 'in' | 'out') => {
+    type: string;
+    options: () => {
+        center: IPoint;
+    };
+};
+export declare function radarPresetAnimation(params: IRadarAnimationParams, preset: RadarAppearPreset, animationType: 'in' | 'out'): {
+    type: string;
+};
+export declare const radarSymbolMoveAnimation: (params: IRadarAnimationParams, animationType: 'in' | 'out') => {
+    channel: {
+        x: {
+            from: () => number;
+            to: (datum: Datum, element: IElement) => any;
+        };
+        y: {
+            from: () => number;
+            to: (datum: Datum, element: IElement) => any;
+        };
+    };
+} | {
+    channel: {
+        x: {
+            from: (datum: Datum, element: IElement) => any;
+            to: () => number;
+        };
+        y: {
+            from: (datum: Datum, element: IElement) => any;
+            to: () => number;
+        };
+    };
+};
+export declare function radarSymbolPresetAnimation(params: IRadarAnimationParams, preset: RadarAppearPreset, animationType: 'in' | 'out'): {
+    type: string;
+} | {
+    channel: {
+        x: {
+            from: () => number;
+            to: (datum: any, element: IElement) => any;
+        };
+        y: {
+            from: () => number;
+            to: (datum: any, element: IElement) => any;
+        };
+    };
+} | {
+    channel: {
+        x: {
+            from: (datum: any, element: IElement) => any;
+            to: () => number;
+        };
+        y: {
+            from: (datum: any, element: IElement) => any;
+            to: () => number;
+        };
+    };
+};
+export declare const radarGroupClipAnimation: (params: IRadarAnimationParams, animationType: 'in' | 'out') => IAnimationTypeConfig;

package/build/es5/series/radar/interface.d.ts

@@ -0,0 +1,20 @@
+import type { IAnimationSpec } from '../../animation/spec';
+import type { IMarkProgressiveConfig } from '../../mark/interface';
+import type { IMarkSpec, IMarkTheme } from '../../typings/spec/common';
+import type { IAreaMarkSpec, ILineMarkSpec, ISymbolMarkSpec } from '../../typings/visual';
+import type { SeriesMarkNameEnum } from '../interface';
+import type { ILineLikeSeriesTheme } from '../mixin/line-mixin';
+import type { IRoseLikeSeriesSpec, IRoseLikeSeriesTheme } from '../polar/rose-like';
+import type { RadarAppearPreset } from './animation';
+type RadarMarks = 'point' | 'line' | 'area';
+export interface IRadarSeriesSpec extends IRoseLikeSeriesSpec, IAnimationSpec<RadarMarks, RadarAppearPreset>, IMarkProgressiveConfig {
+    type: 'radar';
+    [SeriesMarkNameEnum.point]?: IMarkSpec<ISymbolMarkSpec>;
+    [SeriesMarkNameEnum.line]?: IMarkSpec<ILineMarkSpec>;
+    [SeriesMarkNameEnum.area]?: IMarkSpec<IAreaMarkSpec>;
+    seriesMark?: 'point' | 'line' | 'area';
+}
+export interface IRadarSeriesTheme extends IRoseLikeSeriesTheme, ILineLikeSeriesTheme {
+    [SeriesMarkNameEnum.area]?: Partial<IMarkTheme<IAreaMarkSpec>>;
+}
+export {};

package/build/es5/series/radar/radar.d.ts

@@ -0,0 +1,22 @@
+import { LineLikeSeriesMixin } from '../mixin/line-mixin';
+import type { IMarkProgressiveConfig } from '../../mark/interface';
+import type { Maybe } from '../../typings';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface';
+import type { IRadarSeriesSpec, IRadarSeriesTheme } from './interface';
+import { RoseLikeSeries } from '../polar/rose-like';
+export interface RadarSeries extends Pick<LineLikeSeriesMixin, 'initLineMark' | 'initSymbolMark' | 'initLabelMarkStyle' | 'initLineMarkStyle' | 'initSymbolMarkStyle' | '_lineMark' | '_symbolMark'>, RoseLikeSeries<IRadarSeriesSpec> {
+}
+export declare class RadarSeries extends RoseLikeSeries<IRadarSeriesSpec> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _theme: Maybe<IRadarSeriesTheme>;
+    private _areaMark;
+    initGroups(): void;
+    initMark(): void;
+    initMarkStyle(): void;
+    initAreaMark(progressive: IMarkProgressiveConfig, isSeriesMark: boolean): void;
+    initAreaMarkStyle(): void;
+    initAnimation(): void;
+}

package/build/es5/series/range-area/interface.d.ts

@@ -0,0 +1,6 @@
+import type { IAreaSeriesSpec } from '../area/interface';
+export interface IRangeAreaSeriesSpec extends Omit<IAreaSeriesSpec, 'type'> {
+    type: 'rangeArea';
+    minField?: string;
+    maxField?: string;
+}

package/build/es5/series/range-area/range-area.d.ts

@@ -0,0 +1,11 @@
+import { AreaSeries } from '../area/area';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface';
+export declare class RangeAreaSeries extends AreaSeries {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    initMark(): void;
+    initMarkStyle(): void;
+    protected initTooltip(): void;
+}

package/build/es5/series/range-area/tooltip-helper.d.ts

@@ -0,0 +1,7 @@
+import type { ISeriesTooltipHelper } from '../interface';
+import { BaseSeriesTooltipHelper } from '../base/tooltip-helper';
+import type { ITooltipPattern, TooltipActiveType } from '../../typings';
+import type { IDimensionInfo } from '../../event/events/dimension/interface';
+export declare class RangeAreaSeriesTooltipHelper extends BaseSeriesTooltipHelper implements ISeriesTooltipHelper {
+    getDefaultTooltipPattern(activeType: TooltipActiveType, dimensionInfo?: IDimensionInfo[]): ITooltipPattern | null;
+}

package/build/es5/series/range-column/animation.d.ts

@@ -0,0 +1,9 @@
+import type { DirectionType } from '../../typings';
+import type { IAnimationTypeConfig } from '@visactor/vgrammar';
+export interface IRangeColumnAnimationParams {
+    direction: DirectionType;
+}
+export type RangeColumnAppearPreset = 'fadeIn' | 'grow';
+export declare const rangeColumnGrowIn: (params: IRangeColumnAnimationParams) => IAnimationTypeConfig;
+export declare const rangeColumnGrowOut: (params: IRangeColumnAnimationParams) => IAnimationTypeConfig;
+export declare function rangeColumnPresetAnimation(params: IRangeColumnAnimationParams, preset: RangeColumnAppearPreset): IAnimationTypeConfig;

package/build/es5/series/range-column/interface.d.ts

@@ -0,0 +1,56 @@
+import type { IBarSeriesSpec } from '../bar/interface';
+import type { ICartesianSeriesTheme } from '../cartesian/interface';
+import type { 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';
+import type { ILabelSpec } from '../../component/label';
+import type { SeriesMarkNameEnum } from '../interface';
+export declare enum PositionEnum {
+    middle = "middle",
+    start = "start",
+    end = "end",
+    bothEnd = "bothEnd"
+}
+export declare enum minMaxPositionEnum {
+    middle = "middle",
+    start = "start",
+    end = "end"
+}
+type RangeColumnMarks = 'rangeColumn';
+export interface IRangeColumnSeriesSpec extends Omit<IBarSeriesSpec, 'type' | 'label' | keyof IAnimationSpec<RangeColumnMarks, RangeColumnAppearPreset>>, IAnimationSpec<RangeColumnMarks, RangeColumnAppearPreset> {
+    type: 'rangeColumn';
+    minField: string;
+    maxField: string;
+    [SeriesMarkNameEnum.bar]?: IMarkSpec<IRectMarkSpec>;
+    [SeriesMarkNameEnum.label]?: Partial<ILabelSpec> & {
+        position?: PositionEnum;
+        [SeriesMarkNameEnum.minLabel]?: IMarkSpec<IPositionedTextMarkSpec> & {
+            visible: boolean;
+            position?: keyof typeof minMaxPositionEnum;
+            offset?: number;
+            formatMethod?: (text: string | string[], datum?: any) => string | string[];
+        };
+        [SeriesMarkNameEnum.maxLabel]?: IMarkSpec<IPositionedTextMarkSpec> & {
+            visible: boolean;
+            position?: minMaxPositionEnum;
+            offset?: number;
+            formatMethod?: (text: string | string[], datum?: any) => string | string[];
+        };
+    };
+}
+export interface IRangeColumnSeriesTheme extends ICartesianSeriesTheme {
+    [SeriesMarkNameEnum.bar]?: Partial<IMarkTheme<IRectMarkSpec>>;
+    [SeriesMarkNameEnum.label]?: Partial<ILabelSpec> & {
+        [SeriesMarkNameEnum.minLabel]?: Partial<IMarkTheme<ITextMarkSpec> & {
+            position?: keyof typeof minMaxPositionEnum;
+        }>;
+        [SeriesMarkNameEnum.maxLabel]?: Partial<IMarkTheme<ITextMarkSpec> & {
+            position?: keyof typeof minMaxPositionEnum;
+        }>;
+    };
+}
+export interface IRangeColumn3dSeriesSpec extends Omit<IRangeColumnSeriesSpec, 'type'> {
+    type: 'rangeColumn3d';
+}
+export {};