@visactor/vchart-types 1.6.0

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

@@ -0,0 +1,91 @@
+export type SeriesType = keyof typeof SeriesTypeEnum | string;
+export declare enum SeriesTypeEnum {
+    area = "area",
+    line = "line",
+    bar = "bar",
+    bar3d = "bar3d",
+    rangeColumn = "rangeColumn",
+    rangeColumn3d = "rangeColumn3d",
+    rangeArea = "rangeArea",
+    dot = "dot",
+    geo = "geo",
+    link = "link",
+    map = "map",
+    pie = "pie",
+    pie3d = "pie3d",
+    radar = "radar",
+    rose = "rose",
+    scatter = "scatter",
+    circularProgress = "circularProgress",
+    wordCloud = "wordCloud",
+    wordCloud3d = "wordCloud3d",
+    funnel = "funnel",
+    funnel3d = "funnel3d",
+    linearProgress = "linearProgress",
+    boxPlot = "boxPlot",
+    sankey = "sankey",
+    gaugePointer = "gaugePointer",
+    gauge = "gauge",
+    treemap = "treemap",
+    sunburst = "sunburst",
+    circlePacking = "circlePacking",
+    waterfall = "waterfall",
+    heatmap = "heatmap",
+    correlation = "correlation"
+}
+export declare enum SeriesMarkNameEnum {
+    label = "label",
+    point = "point",
+    line = "line",
+    area = "area",
+    bar = "bar",
+    bar3d = "bar3d",
+    boxPlot = "boxPlot",
+    outlier = "outlier",
+    circlePacking = "circlePacking",
+    group = "group",
+    gridBackground = "gridBackground",
+    grid = "grid",
+    dot = "dot",
+    title = "title",
+    subTitle = "subTitle",
+    symbol = "symbol",
+    funnel = "funnel",
+    funnel3d = "funnel3d",
+    transform = "transform",
+    transform3d = "transform3d",
+    transformLabel = "transformLabel",
+    outerLabel = "outerLabel",
+    outerLabelLine = "outerLabelLine",
+    pin = "pin",
+    pinBackground = "pinBackground",
+    pointer = "pointer",
+    segment = "segment",
+    track = "track",
+    cell = "cell",
+    cellBackground = "cellBackground",
+    link = "link",
+    arrow = "arrow",
+    pie = "pie",
+    pie3d = "pie3d",
+    labelLine = "labelLine",
+    progress = "progress",
+    minLabel = "minLabel",
+    maxLabel = "maxLabel",
+    rose = "rose",
+    node = "node",
+    sunburst = "sunburst",
+    nonLeaf = "nonLeaf",
+    leaf = "leaf",
+    nonLeafLabel = "nonLeafLabel",
+    leaderLine = "leaderLine",
+    stackLabel = "stackLabel",
+    word = "word",
+    fillingWord = "fillingWord",
+    nodePoint = "nodePoint",
+    ripplePoint = "ripplePoint",
+    centerPoint = "centerPoint",
+    centerLabel = "centerLabel",
+    barBackground = "barBackground"
+}
+export declare const seriesMarkNameSet: Set<string>;

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

@@ -0,0 +1,7 @@
+import type { DirectionType } from '../../typings';
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+export interface ILineAnimationParams {
+    direction: DirectionType;
+}
+export type LineAppearPreset = 'clipIn' | 'fadeIn' | 'grow';
+export declare function linePresetAnimation(params: ILineAnimationParams, preset: LineAppearPreset): IAnimationTypeConfig;

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

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

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

@@ -0,0 +1,21 @@
+import type { IMarkSpec } from '../../typings/spec/common';
+import type { ICartesianSeriesSpec } from '../cartesian/interface';
+import type { ISymbolMarkSpec, ILineMarkSpec } from '../../typings/visual';
+import type { IAnimationSpec } from '../../animation/spec';
+import type { LineAppearPreset } from './animation';
+import type { ILineLikeLabelSpec, ILineLikeSeriesTheme } from '../mixin/line-mixin';
+import type { IDataSamping, IMarkOverlap, IMarkProgressiveConfig } from '../../mark/interface';
+import type { SeriesMarkNameEnum } from '../interface/type';
+type LineMarks = 'point' | 'line';
+export interface ILineSeriesSpec extends ICartesianSeriesSpec, IAnimationSpec<LineMarks, LineAppearPreset>, IMarkProgressiveConfig, IDataSamping, IMarkOverlap {
+    type: 'line';
+    xField: string | string[];
+    yField: string | string[];
+    [SeriesMarkNameEnum.point]?: IMarkSpec<ISymbolMarkSpec>;
+    [SeriesMarkNameEnum.line]?: IMarkSpec<ILineMarkSpec>;
+    [SeriesMarkNameEnum.label]?: ILineLikeLabelSpec;
+    seriesMark?: 'line' | 'point';
+    activePoint?: boolean;
+}
+export type ILineSeriesTheme = ILineLikeSeriesTheme;
+export {};

package/types/series/line/line.d.ts

@@ -0,0 +1,26 @@
+import { CartesianSeries } from '../cartesian/cartesian';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import { LineLikeSeriesMixin } from '../mixin/line-mixin';
+import { type Datum, type Maybe } from '../../typings';
+import type { ILineSeriesSpec, ILineSeriesTheme } from './interface';
+import type { IMark } from '../../mark/interface';
+export interface LineSeries<T extends ILineSeriesSpec = ILineSeriesSpec> extends Pick<LineLikeSeriesMixin, 'initLineMark' | 'initSymbolMark' | 'initLabelMarkStyle' | 'initLineMarkStyle' | 'initSymbolMarkStyle' | '_lineMark' | '_symbolMark' | 'addSamplingCompile' | 'addOverlapCompile' | 'reCompileSampling'>, CartesianSeries<T> {
+}
+export declare class LineSeries<T extends ILineSeriesSpec = ILineSeriesSpec> extends CartesianSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _theme: Maybe<ILineSeriesTheme>;
+    protected _sortDataByAxis: boolean;
+    compile(): void;
+    initMark(): void;
+    protected initTooltip(): void;
+    initMarkStyle(): void;
+    initAnimation(): void;
+    onLayoutEnd(ctx: any): void;
+    getSeriesStyle(datum: Datum): (attribute: string) => unknown;
+    getDefaultShapeType(): string;
+    getActiveMarks(): IMark[];
+}
+export declare const registerLineSeries: () => void;

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

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

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

@@ -0,0 +1,25 @@
+import type { ICartesianSeriesSpec, ICartesianSeriesTheme } from '../cartesian/interface';
+import type { IMarkSpec, IMarkTheme } from '../../typings/spec/common';
+import type { ILineMarkSpec, ISymbolMarkSpec } from '../../typings/visual';
+import type { SeriesMarkNameEnum } from '../interface/type';
+import type { DataView } from '@visactor/vdataset';
+import type { IDotSeriesSpec } from '../dot/interface';
+export interface ILinkSeriesSpec extends ICartesianSeriesSpec, ILinkSeriesSpecFromDot {
+    type: 'link';
+    fromField: string;
+    toField: string;
+    dotSeriesIndex: number;
+    dotTypeField?: string;
+    [SeriesMarkNameEnum.link]?: IMarkSpec<ILineMarkSpec>;
+}
+type ILinkSeriesSpecFromDot = {
+    dataDot?: DataView;
+    dotSeriesSpec?: IDotSeriesSpec;
+    leftAppendPadding?: number;
+    clipHeight?: number;
+};
+export interface ILinkSeriesTheme extends ICartesianSeriesTheme {
+    [SeriesMarkNameEnum.link]?: Partial<IMarkTheme<ILineMarkSpec>>;
+    [SeriesMarkNameEnum.arrow]?: Partial<IMarkTheme<ISymbolMarkSpec>>;
+}
+export {};

package/types/series/link/link.d.ts

@@ -0,0 +1,53 @@
+import { CartesianSeries } from '../cartesian/cartesian';
+import type { Maybe, Datum } from '../../typings';
+import type { IMark } from '../../mark/interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { IDotSeriesSpec } from '../dot/interface';
+import type { ILinkSeriesSpec, ILinkSeriesTheme } from './interface';
+import type { SeriesMarkMap } from '../interface';
+export declare class LinkSeries<T extends ILinkSeriesSpec = ILinkSeriesSpec> extends CartesianSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _theme: Maybe<ILinkSeriesTheme>;
+    protected _fromField?: string;
+    getFromField(): string;
+    setFromField(field: string): void;
+    protected _toField?: string;
+    getToField(): string;
+    setToField(field: string): void;
+    protected _dotTypeField?: string;
+    getDotTypeField(): string;
+    setDotTypeField(field: string): void;
+    protected _dotSeriesSpec?: IDotSeriesSpec;
+    getDotSeriesSpec(): IDotSeriesSpec;
+    setDotSeriesSpec(spec: IDotSeriesSpec): void;
+    protected _getDotData(): any;
+    initData(): void;
+    setAttrFromSpec(): void;
+    private _clipMark;
+    private _containerMark;
+    private _linkMark;
+    private _arrowMark;
+    initMark(): void;
+    initMarkStyle(): void;
+    afterInitMark(): void;
+    dataToPositionXFrom(datum: Datum): number;
+    dataToPositionYFrom(datum: Datum): number;
+    dataToPositionXTo(datum: Datum): number;
+    dataToPositionYTo(datum: Datum): number;
+    dataToPositionArrowYTo(datum: Datum, arrowSize: number): number;
+    dataToOpacity(datum: Datum): number;
+    isPositionYFromHigher(datum: Datum): boolean;
+    isPositionXOuterRange(datum: Datum, field: string): boolean;
+    getDefaultColorDomain(): any;
+    getColorAttribute(): {
+        scale: any;
+        field: string;
+    };
+    protected initTooltip(): void;
+    protected onMarkTreePositionUpdate(marks: IMark[]): void;
+    getDotInfoData(): import("../../compile/mark/mark-data").MarkData;
+    getActiveMarks(): IMark[];
+}
+export declare const registerLinkSeries: () => void;

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

@@ -0,0 +1,6 @@
+import type { ISeriesTooltipHelper } from '../interface';
+import { BaseSeriesTooltipHelper } from '../base/tooltip-helper';
+import type { ITooltipPattern, TooltipActiveType } from '../../typings';
+export declare class LinkSeriesTooltipHelper extends BaseSeriesTooltipHelper implements ISeriesTooltipHelper {
+    getDefaultTooltipPattern(activeType: TooltipActiveType): ITooltipPattern | null;
+}

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

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

package/types/series/map/geo-source.d.ts

@@ -0,0 +1,20 @@
+import { DataView } from '@visactor/vdataset';
+import type { GeoSourceType } from '../../typings/geo';
+export interface IGeoJsonOption {
+    type: 'geojson';
+    centroid?: boolean;
+    simplify?: boolean;
+    rewind?: boolean | {
+        reverse?: boolean;
+    };
+}
+export interface ITopoJsonOption extends Omit<IGeoJsonOption, 'type'> {
+    type: 'topojson';
+    object: string;
+}
+export type GeoSourceOption = IGeoJsonOption | ITopoJsonOption;
+export declare const geoSourceMap: Map<string, DataView>;
+export declare function registerMapSource(key: string, source: GeoSourceType, option?: GeoSourceOption): void;
+export declare function unregisterMapSource(key: string): void;
+export declare function getMapSource(type: string): DataView;
+export declare function clearMapSource(): void;

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

@@ -0,0 +1,31 @@
+import type { IPathMarkSpec, ITextMarkSpec } from '../../typings/visual';
+import type { IMarkSpec, IMarkTheme, ISeriesSpec } from '../../typings/spec/common';
+import type { IAnimationSpec } from '../../animation/spec';
+type LineMarks = 'area';
+export interface IMapSeriesSpec extends ISeriesSpec, IAnimationSpec<LineMarks, 'fadeIn'> {
+    type: 'map';
+    map: string;
+    nameField?: string;
+    valueField?: string;
+    nameProperty?: string;
+    centroidProperty?: string;
+    nameMap?: {
+        [key: string]: string;
+    };
+    area?: IMarkSpec<Omit<IPathMarkSpec, 'smoothScale'>>;
+    defaultFillColor?: string;
+    label?: IMarkSpec<ITextMarkSpec> & {
+        offset?: number;
+        position?: string;
+        formatMethod?: (text: string | string[], datum?: any) => string | string[];
+    };
+}
+export interface IMapSeriesTheme {
+    defaultFillColor?: string;
+    label?: Partial<IMarkTheme<ITextMarkSpec> & {
+        offset?: number;
+        position?: string;
+    }>;
+    area?: Partial<IMarkTheme<Omit<IPathMarkSpec, 'smoothScale'>>>;
+}
+export {};

package/types/series/map/map.d.ts

@@ -0,0 +1,48 @@
+import { DataView } from '@visactor/vdataset';
+import type { Maybe, StringOrNumber } from '../../typings';
+import { GeoSeries } from '../geo/geo';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { IMapSeriesSpec, IMapSeriesTheme } from './interface';
+import type { PanEventParam, ZoomEventParam } from '../../event/interface';
+import type { ILabelMark } from '../../mark/label';
+import type { IMark } from '../../mark/interface';
+export declare class MapSeries<T extends IMapSeriesSpec = IMapSeriesSpec> extends GeoSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    map: string;
+    protected _nameMap: {
+        [key: StringOrNumber]: StringOrNumber;
+    };
+    getNameMap(): {
+        [key: string]: StringOrNumber;
+        [key: number]: StringOrNumber;
+    };
+    protected _theme: Maybe<IMapSeriesTheme>;
+    private _areaCache;
+    private _pathMark;
+    private _labelMark;
+    setAttrFromSpec(): void;
+    initData(): void;
+    initMark(): void;
+    initMarkStyle(): void;
+    initLabelMarkStyle(labelMark: ILabelMark): void;
+    initAnimation(): void;
+    protected initTooltip(): void;
+    protected getPath(datum: any): string;
+    onEvaluateEnd(): void;
+    getDimensionField(): string[];
+    getMeasureField(): string[];
+    release(): void;
+    handleZoom(e: ZoomEventParam): void;
+    handlePan(e: PanEventParam): void;
+    getDatumCenter(datum: any): [number, number];
+    getDatumName(datum: any): string;
+    dataToPositionX(data: any): number;
+    dataToPositionY(data: any): number;
+    viewDataUpdate(d: DataView): void;
+    protected _getDataIdKey(): string;
+    getActiveMarks(): IMark[];
+}
+export declare const registerMapSeries: () => void;

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

@@ -0,0 +1,5 @@
+import type { ISeriesTooltipHelper } from '../interface';
+import { BaseSeriesTooltipHelper } from '../base/tooltip-helper';
+export declare class MapSeriesTooltipHelper extends BaseSeriesTooltipHelper implements ISeriesTooltipHelper {
+    titleValueCallback: (datum: any) => any;
+}

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

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

package/types/series/mixin/line-mixin.d.ts

@@ -0,0 +1,60 @@
+import type { ISeriesOption } from '../interface/common';
+import type { ITrigger } from '../../interaction/interface';
+import type { ISeries } from '../interface/series';
+import type { IMark, IMarkProgressiveConfig } from '../../mark/interface';
+import type { ILineMark } from '../../mark/line';
+import type { ISymbolMark } from '../../mark/symbol';
+import type { ITextMark } from '../../mark/text';
+import type { DirectionType, IInvalidType, InterpolateType, ILineMarkSpec, ISymbolMarkSpec, Maybe, Datum, IMarkTheme } from '../../typings';
+import type { ISeriesMarkInfo, ISeriesMarkInitOption, ISeriesTooltipHelper } from '../interface';
+import type { ILabelSpec } from '../../component/label';
+import { type DimensionEventParams } from '../../event/events/dimension';
+import type { ILabelMark } from '../../mark/label';
+import type { Functional } from '@visactor/vrender-components';
+import type { IRegion } from '../../region/interface';
+import type { SeriesData } from '../base/series-data';
+export interface ILineLikeSeriesTheme {
+    line?: Partial<IMarkTheme<ILineMarkSpec>>;
+    point?: Partial<IMarkTheme<ISymbolMarkSpec>> & {
+        visibleInActive?: boolean;
+    };
+    label?: Partial<ILineLikeLabelSpec>;
+}
+export type ILineLikeLabelSpec = Omit<ILabelSpec, 'position'> & {
+    position?: Functional<'top' | 'bottom' | 'left' | 'right' | 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'center'>;
+};
+export interface LineLikeSeriesMixin extends ISeries {
+    _spec: any;
+    _option: ISeriesOption;
+    _seriesField: string;
+    _theme: Maybe<ILineLikeSeriesTheme>;
+    _trigger: ITrigger;
+    _tooltipHelper: ISeriesTooltipHelper;
+    _invalidType: IInvalidType;
+    _region: IRegion;
+    _direction: DirectionType;
+    _data: SeriesData;
+    _lineMark: ILineMark;
+    _symbolMark: ISymbolMark;
+    _symbolActiveMark: ISymbolMark;
+    _labelMark: ITextMark;
+    _fieldX?: string[];
+    _fieldY?: string[];
+    _fieldZ?: string[];
+    _createMark: (markInfo: ISeriesMarkInfo, option?: ISeriesMarkInitOption) => IMark;
+    _getInvalidDefined: () => boolean;
+    _getInvalidConnectType: () => IInvalidType;
+}
+export declare class LineLikeSeriesMixin {
+    addSamplingCompile(): void;
+    addOverlapCompile(): void;
+    reCompileSampling(): void;
+    initLineMark(progressive?: IMarkProgressiveConfig, isSeriesMark?: boolean): ILineMark;
+    initLineMarkStyle(direction?: DirectionType, areaCurveType?: InterpolateType): ILineMark;
+    protected _getEventElement(params: DimensionEventParams, reverse?: boolean): Datum[];
+    protected _dimensionTrigger(params: DimensionEventParams): void;
+    initSymbolMark(progressive?: IMarkProgressiveConfig, isSeriesMark?: boolean): ISymbolMark;
+    initSymbolMarkStyle(): ISymbolMark;
+    initLabelMarkStyle(labelMark?: ILabelMark): void;
+    encodeDefined(mark: IMark, attr: string): void;
+}

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

@@ -0,0 +1,25 @@
+import type { IElement, IAnimationTypeConfig } from '@visactor/vgrammar-core';
+import { AnimationStateEnum } from '../../../animation/interface';
+import type { Datum } from '../../../typings';
+export interface IPieAnimationParams {
+    growField?: 'angle' | 'radius';
+    growFrom: (datum: Datum, element: IElement, state: AnimationStateEnum) => number;
+}
+export type PieAppearPreset = 'growAngle' | 'growRadius' | 'fadeIn';
+export declare function pieGrowOption(pieParams: IPieAnimationParams, isOverall: boolean, state: AnimationStateEnum): (datum: Datum, element: IElement, params: AnimationStateEnum) => {
+    overall: number;
+} | {
+    overall: boolean;
+};
+export declare const Appear_Grow: (params: IPieAnimationParams) => IAnimationTypeConfig;
+export declare const Appear_FadeIn: {
+    type: string;
+};
+export declare const pieEnter: (params: IPieAnimationParams) => IAnimationTypeConfig;
+export declare const pieExit: (params: IPieAnimationParams) => IAnimationTypeConfig;
+export declare const pieDisappear: (params: IPieAnimationParams) => IAnimationTypeConfig;
+export declare function piePresetAnimation(params: IPieAnimationParams, preset: PieAppearPreset | boolean): IAnimationTypeConfig | {
+    type: string;
+};
+export declare const registerPieAnimation: () => void;
+export declare const registerPie3dAnimation: () => void;

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

@@ -0,0 +1,6 @@
+import type { IAnimationTimeline, IAnimationTypeConfig } from '@visactor/vgrammar-core';
+import type { IArcMark } from '../../../mark/arc';
+export type ICenterOffsetAnimationOptions = {
+    distance?: number;
+};
+export declare function centerOffsetConfig(mark: IArcMark, originalConfig: IAnimationTypeConfig): IAnimationTimeline;

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

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

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

@@ -0,0 +1,67 @@
+import type { IAnimationSpec } from '../../animation/spec';
+import type { IMarkSpec, IMarkTheme } from '../../typings/spec/common';
+import type { IArcMarkSpec, ITextMarkSpec, IArc3dMarkSpec, ILineMarkSpec } from '../../typings/visual';
+import type { SeriesMarkNameEnum } from '../interface/type';
+import type { IPolarSeriesSpec, IPolarSeriesTheme } from '../polar/interface';
+import type { PieAppearPreset } from './animation/animation';
+import type { ILabelSpec } from '../../component/label';
+export type PieMarks = 'pie' | 'label' | 'labelLine';
+export interface IPieSeriesSpec extends IPolarSeriesSpec, IAnimationSpec<PieMarks, PieAppearPreset> {
+    type: 'pie';
+    categoryField: string;
+    valueField: string;
+    centerX?: number;
+    centerY?: number;
+    centerOffset?: number;
+    radius?: number;
+    outerRadius?: number;
+    innerRadius?: number;
+    cornerRadius?: number;
+    startAngle?: number;
+    endAngle?: number;
+    padAngle?: number;
+    minAngle?: number;
+    [SeriesMarkNameEnum.pie]?: IMarkSpec<IArcMarkSpec>;
+    [SeriesMarkNameEnum.label]?: IArcLabelSpec;
+}
+export interface IPieSeriesTheme extends IPolarSeriesTheme {
+    [SeriesMarkNameEnum.pie]?: Partial<IMarkTheme<IArcMarkSpec>>;
+    [SeriesMarkNameEnum.label]?: IArcLabelSpec;
+    innerLabel?: IArcLabelSpec;
+    outerLabel?: IArcLabelSpec;
+}
+export type IPie3dSeriesSpec = {
+    type: 'pie3d';
+    angle3d?: number;
+} & Omit<IPieSeriesSpec, 'type'>;
+export interface IPie3dSeriesTheme extends IPolarSeriesTheme {
+    [SeriesMarkNameEnum.pie3d]?: Partial<IMarkTheme<IArc3dMarkSpec>>;
+    [SeriesMarkNameEnum.label]?: IArcLabelSpec;
+    innerLabel?: IArcLabelSpec;
+    outerLabel?: IArcLabelSpec;
+}
+export interface IArcLabelLineSpec extends IMarkSpec<ILineMarkSpec> {
+    visible?: boolean;
+    line1MinLength?: number;
+    line2MinLength?: number;
+    smooth?: boolean;
+}
+export type ArcLabelAlignType = 'arc' | 'labelLine' | 'edge';
+export type ArcLabelStrategyType = 'priority' | 'vertical' | 'none';
+export interface IArcLabelLayoutSpec {
+    textAlign?: ArcLabelAlignType;
+    align?: ArcLabelAlignType;
+    strategy?: ArcLabelStrategyType;
+    tangentConstraint?: boolean;
+}
+export interface IArcLabelSpec extends ILabelSpec {
+    position?: 'outside' | 'inside';
+    showRule?: 'all' | 'max' | 'min' | 'minAndMax' | 'headAndTail';
+    coverEnable?: boolean;
+    rotate?: boolean;
+    spaceWidth?: number;
+    layoutArcGap?: number;
+    style?: ITextMarkSpec;
+    line?: IArcLabelLineSpec;
+    layout?: IArcLabelLayoutSpec;
+}

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 {};