@visactor/vchart-types 0.16.17-alpha.2

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

@@ -0,0 +1,16 @@
+import { MarkTypeEnum } from '../../mark/interface/type';
+import type { IArcSeries, SeriesMarkMap } from '../interface';
+import { SeriesMarkNameEnum, SeriesTypeEnum } from '../interface/type';
+import type { IPie3dSeriesSpec } from './interface';
+import { BasePieSeries } from './pie';
+export declare class Pie3dSeries<T extends IPie3dSeriesSpec = IPie3dSeriesSpec> extends BasePieSeries<T> 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;
+}
+export declare const registerPie3dSeries: () => void;

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

@@ -0,0 +1,83 @@
+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/type';
+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, 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;
+    protected initTooltip(): void;
+    initMarkStyleWithSpec(mark?: IMark, spec?: any, key?: string): void;
+    initLabelMarkStyle(textMark: ITextMark): 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;
+    _compareSpec(ignoreCheckKeys?: {
+        [key: string]: true;
+    }): {
+        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;
+    protected _noAnimationDataKey(datum: Datum, index: number): number;
+    getActiveMarks(): IMark[];
+    protected _mergeThemeToSpec(): void;
+}
+export declare class PieSeries<T extends IPieSeriesSpec = IPieSeriesSpec> extends BasePieSeries<T> implements IArcSeries {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+}
+export declare const registerPieSeries: () => void;
+export {};

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

@@ -0,0 +1,41 @@
+import type { EasingType } from '@visactor/vrender-core';
+import { ACustomAnimate, TagPointsUpdate } from '@visactor/vrender-core';
+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/types/series/polar/interface.d.ts

@@ -0,0 +1,22 @@
+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;
+    sortDataByAxis?: boolean;
+}
+export interface IPolarSeriesTheme {
+    radius?: number;
+    outerRadius?: number;
+    innerRadius?: number;
+    startAngle?: number;
+    endAngle?: number;
+}

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

@@ -0,0 +1,59 @@
+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 _sortDataByAxis: boolean;
+    get sortDataByAxis(): boolean;
+    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;
+    onRadiusAxisHelperUpdate(): void;
+    onAngleAxisHelperUpdate(): void;
+    afterInitMark(): void;
+    protected _computeLayoutRadius(): number;
+    fillData(): void;
+    _sortDataInAxisDomain(): void;
+    protected _getInvalidDefined: (datum: Datum) => boolean;
+}

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

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

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

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

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

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

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

@@ -0,0 +1,21 @@
+import type { IArcMarkSpec, IMarkSpec, IMarkTheme } from '../../../typings';
+import type { IPolarSeriesSpec, IPolarSeriesTheme } from '../interface';
+export interface IContinuousTickData {
+    index?: number;
+    value: number;
+}
+export interface ITickMaskSpec {
+    angle?: number;
+    offsetAngle?: number;
+    forceAlign?: boolean;
+}
+export interface IProgressLikeSeriesSpec extends IPolarSeriesSpec {
+    roundCap?: boolean | [boolean, boolean];
+    cornerRadius?: number;
+    tickMask?: Omit<IMarkSpec<IArcMarkSpec>, 'state'> & ITickMaskSpec;
+}
+export interface IProgressLikeSeriesTheme extends IPolarSeriesTheme {
+    roundCap?: boolean | [boolean, boolean];
+    cornerRadius?: number;
+    tickMask?: Omit<IMarkTheme<IArcMarkSpec>, 'state'> & ITickMaskSpec;
+}

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

@@ -0,0 +1,34 @@
+import type { Datum } from '@visactor/vgrammar-core';
+import type { IMarkStyle } from '../../../mark/interface';
+import type { ConvertToMarkStyleSpec, ICommonSpec } from '../../../typings';
+import { PolarSeries } from '../polar';
+import type { IContinuousTickData, IProgressLikeSeriesSpec } from './interface';
+import type { IPolarAxis } from '../../../component/axis';
+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;
+    setAttrFromSpec(): void;
+    getStackGroupFields(): string[];
+    getStackValueField(): string;
+    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;
+    protected _getAngleValueStartWithoutMask(datum: Datum): number;
+    protected _getAngleValueEndWithoutMask(datum: Datum): number;
+    getDimensionField(): string[];
+    getMeasureField(): string[];
+    initMark(): void;
+    initMarkStyle(): void;
+    protected _initArcGroupMark(): IGroupMark;
+    protected _initArcGroupMarkStyle(): void;
+    protected _getAngleAxis(): IPolarAxis;
+    protected _getAngleAxisTickData(angleAxis?: IPolarAxis): IContinuousTickData[];
+    protected _isTickMaskVisible(angleAxis?: IPolarAxis): boolean;
+    protected _getAngleAxisSubTickData(angleAxis: IPolarAxis): IContinuousTickData[];
+}

package/types/series/polar/rose-like/index.d.ts

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

package/types/series/polar/rose-like/interface.d.ts

@@ -0,0 +1,3 @@
+import type { IPolarSeriesSpec, IPolarSeriesTheme } from '../interface';
+export type IRoseLikeSeriesSpec = IPolarSeriesSpec;
+export type IRoseLikeSeriesTheme = IPolarSeriesTheme;

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

@@ -0,0 +1,13 @@
+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;
+}

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

@@ -0,0 +1,28 @@
+import type { Maybe, Datum } from '../../../typings';
+import type { SeriesMarkMap } from '../../interface';
+import { SeriesTypeEnum } from '../../interface/type';
+import type { ICircularProgressSeriesSpec, ICircularProgressSeriesTheme } from './interface';
+import { ProgressLikeSeries } from '../../polar/progress-like/progress-like';
+import type { IMark } from '../../../mark/interface';
+export declare class CircularProgressSeries<T extends ICircularProgressSeriesSpec = ICircularProgressSeriesSpec> extends ProgressLikeSeries<T> {
+    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 _initProgressMark;
+    private _initProgressMarkStyle;
+    protected initTooltip(): void;
+    private _initTrackMark;
+    private _initTrackMarkStyle;
+    protected _getRadiusValueStart: (datum: Datum) => number;
+    protected _getRadiusValueEnd: (datum: Datum) => number;
+    initAnimation(): void;
+    getActiveMarks(): IMark[];
+}
+export declare const registerCircularProgressSeries: () => void;

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

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

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

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

package/types/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/type';
+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/types/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/types/series/progress/linear/animation.d.ts

@@ -0,0 +1,10 @@
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+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;
+export declare const registerLinearProgressAnimation: () => void;

package/types/series/progress/linear/constant.d.ts

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

package/types/series/progress/linear/index.d.ts

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

package/types/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/type';
+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/types/series/progress/linear/linear.d.ts

@@ -0,0 +1,27 @@
+import { CartesianSeries } from '../../cartesian/cartesian';
+import type { SeriesMarkMap } from '../../interface';
+import { SeriesTypeEnum } from '../../interface/type';
+import type { Maybe } from '../../../typings';
+import type { ILinearProgressSeriesSpec, ILinearProgressSeriesTheme } from './interface';
+import type { IMark } from '../../../mark/interface';
+export declare class LinearProgressSeries<T extends ILinearProgressSeriesSpec = ILinearProgressSeriesSpec> extends CartesianSeries<T> {
+    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;
+    getActiveMarks(): IMark[];
+}
+export declare const registerLinearProgressSeries: () => void;

package/types/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/types/series/radar/animation.d.ts

@@ -0,0 +1,73 @@
+import type { Datum, IAnimationTypeConfig, IElement } from '@visactor/vgrammar-core';
+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;
+export declare const registerRadarAnimation: () => void;

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

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

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

@@ -0,0 +1,22 @@
+import type { IAnimationSpec } from '../../animation/spec';
+import type { IMarkOverlap, 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/type';
+import type { ILineLikeLabelSpec, 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, IMarkOverlap {
+    type: 'radar';
+    [SeriesMarkNameEnum.point]?: IMarkSpec<ISymbolMarkSpec>;
+    [SeriesMarkNameEnum.line]?: IMarkSpec<ILineMarkSpec>;
+    [SeriesMarkNameEnum.area]?: IMarkSpec<IAreaMarkSpec>;
+    [SeriesMarkNameEnum.label]?: ILineLikeLabelSpec;
+    seriesMark?: 'point' | 'line' | 'area';
+    activePoint?: boolean;
+}
+export interface IRadarSeriesTheme extends IRoseLikeSeriesTheme, ILineLikeSeriesTheme {
+    [SeriesMarkNameEnum.area]?: Partial<IMarkTheme<IAreaMarkSpec>>;
+}
+export {};

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

@@ -0,0 +1,29 @@
+import { LineLikeSeriesMixin } from '../mixin/line-mixin';
+import type { IMark, IMarkProgressiveConfig } from '../../mark/interface';
+import type { Datum, Maybe } from '../../typings';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { IRadarSeriesSpec, IRadarSeriesTheme } from './interface';
+import { RoseLikeSeries } from '../polar/rose-like';
+export interface RadarSeries<T extends IRadarSeriesSpec> extends Pick<LineLikeSeriesMixin, 'initLineMark' | 'initSymbolMark' | 'initLabelMarkStyle' | 'initLineMarkStyle' | 'initSymbolMarkStyle' | 'encodeDefined' | '_lineMark' | '_symbolMark' | 'addOverlapCompile'>, RoseLikeSeries<T> {
+}
+export declare class RadarSeries<T extends IRadarSeriesSpec = IRadarSeriesSpec> extends RoseLikeSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _theme: Maybe<IRadarSeriesTheme>;
+    private _areaMark;
+    protected _sortDataByAxis: boolean;
+    initGroups(): void;
+    compile(): void;
+    initMark(): void;
+    initMarkStyle(): void;
+    initAreaMark(progressive: IMarkProgressiveConfig, isSeriesMark: boolean): void;
+    initAreaMarkStyle(): void;
+    protected initTooltip(): void;
+    initAnimation(): void;
+    getDefaultShapeType(): string;
+    getActiveMarks(): IMark[];
+    getSeriesStyle(datum: Datum): (attribute: string) => any;
+}
+export declare const registerRadarSeries: () => void;

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

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

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

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

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

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

package/types/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;
+}