@visactor/vchart-types 0.16.17-alpha.2

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

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

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

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

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

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

@@ -0,0 +1,15 @@
+import { MarkTypeEnum } from '../../mark/interface/type';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import { RangeColumnSeries } from './range-column';
+import type { AdaptiveSpec } from '../../typings';
+import type { IRangeColumn3dSeriesSpec } from './interface';
+export declare const DefaultBandWidth = 6;
+export declare class RangeColumn3dSeries<T extends IRangeColumn3dSeriesSpec = IRangeColumn3dSeriesSpec> extends RangeColumnSeries<AdaptiveSpec<T, 'type'>> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    protected _barMarkType: MarkTypeEnum;
+    protected _barName: string;
+    static readonly mark: SeriesMarkMap;
+}
+export declare const registerRangeColumn3dSeries: () => void;

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

@@ -0,0 +1,26 @@
+import { BarSeries } from '../bar/bar';
+import { MarkTypeEnum } from '../../mark/interface/type';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import { type ITextMark } from '../../mark/text';
+import type { IRangeColumnSeriesSpec } from './interface';
+export declare const DefaultBandWidth = 6;
+export declare class RangeColumnSeries<T extends IRangeColumnSeriesSpec = IRangeColumnSeriesSpec> extends BarSeries<any> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    protected _barMarkType: MarkTypeEnum;
+    protected _barName: string;
+    protected _spec: T;
+    static readonly mark: SeriesMarkMap;
+    protected _stack: boolean;
+    private _minLabelMark?;
+    private _maxLabelMark?;
+    private _labelMark?;
+    initMark(): void;
+    initMarkStyle(): void;
+    initLabelMarkStyle(labelMark: ITextMark): void;
+    initBandRectMarkStyle(): void;
+    initAnimation(): void;
+    protected initTooltip(): void;
+}
+export declare const registerRangeColumnSeries: () => void;

package/types/series/range-column/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 RangeColumnSeriesTooltipHelper extends BaseSeriesTooltipHelper implements ISeriesTooltipHelper {
+    getDefaultTooltipPattern(activeType: TooltipActiveType): ITooltipPattern | null;
+}

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

@@ -0,0 +1,13 @@
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+export interface IRoseAnimationParams {
+    innerRadius: () => number;
+    growField?: 'angle' | 'radius';
+}
+export type RoseAppearPreset = 'growAngle' | 'growRadius' | 'fadeIn';
+export declare const Appear_Grow: (params: IRoseAnimationParams) => IAnimationTypeConfig;
+export declare const Appear_FadeIn: IAnimationTypeConfig;
+export declare const roseEnter: (params: IRoseAnimationParams) => IAnimationTypeConfig;
+export declare const roseExit: (params: IRoseAnimationParams) => IAnimationTypeConfig;
+export declare const roseDisappear: (params: IRoseAnimationParams) => IAnimationTypeConfig;
+export declare function rosePresetAnimation(params: IRoseAnimationParams, preset: RoseAppearPreset | boolean): IAnimationTypeConfig;
+export declare const registerRoseAnimation: () => void;

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

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

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

@@ -0,0 +1,19 @@
+import type { IAnimationSpec } from '../../animation/spec';
+import type { IMarkSpec, IMarkTheme } from '../../typings/spec';
+import type { IArcMarkSpec } from '../../typings/visual';
+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';
+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;
+}
+export interface IRoseSeriesTheme extends IRoseLikeSeriesTheme {
+    [SeriesMarkNameEnum.rose]?: Partial<IMarkTheme<IArcMarkSpec>>;
+    [SeriesMarkNameEnum.label]?: IArcLabelSpec;
+}

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

@@ -0,0 +1,28 @@
+import type { Maybe } from '../../typings';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { IRoseSeriesSpec, IRoseSeriesTheme } from './interface';
+import { RoseLikeSeries } from '../polar/rose-like';
+import type { ITextMark } from '../../mark/text';
+import type { IMark } from '../../mark/interface';
+export declare const DefaultBandWidth = 0.5;
+export declare class RoseSeries<T extends IRoseSeriesSpec = IRoseSeriesSpec> extends RoseLikeSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _theme: Maybe<IRoseSeriesTheme>;
+    protected _supportStack: boolean;
+    private _roseMark;
+    protected _labelMark: ITextMark | null;
+    initMark(): void;
+    initMarkStyle(): void;
+    private initRoseMark;
+    private getRoseAngle;
+    private initRoseMarkStyle;
+    protected initTooltip(): void;
+    initLabelMarkStyle(textMark: ITextMark): void;
+    initAnimation(): void;
+    getDefaultShapeType(): string;
+    getActiveMarks(): IMark[];
+}
+export declare const registerRoseSeries: () => void;

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

@@ -0,0 +1,13 @@
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+import type { DirectionType } from '../../typings';
+export type SankeyMark = 'node' | 'link' | 'label';
+export type SankeyAppearPreset = 'growIn' | 'fadeIn';
+export interface ISankeyAnimationParams {
+    direction: DirectionType;
+    growFrom: () => number;
+}
+export declare const sankeyGrowIn: (params: ISankeyAnimationParams, isOverall?: boolean) => IAnimationTypeConfig;
+export declare const sankeyGrowOut: (params: ISankeyAnimationParams, isOverall?: boolean) => IAnimationTypeConfig;
+export declare const sankeyNodePresetAnimation: (params: ISankeyAnimationParams, preset: SankeyAppearPreset) => IAnimationTypeConfig;
+export declare const sankeyLinkPresetAnimation: (preset: SankeyAppearPreset) => IAnimationTypeConfig;
+export declare const registerSankeyAnimation: () => void;

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

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

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

@@ -0,0 +1,108 @@
+import type { ISeriesSpec, DirectionType, IMarkTheme } from '../../typings';
+import type { IMarkSpec } from '../../typings/spec/common';
+import type { IRectMarkSpec, ILinkPathMarkSpec } from '../../typings/visual';
+import type { IAnimationSpec } from '../../animation/spec';
+import type { SankeyAppearPreset, SankeyMark } from './animation';
+import type { SeriesMarkNameEnum } from '../interface/type';
+import type { ILabelSpec } from '../../component/label';
+export interface ISankeySeriesSpec extends Omit<ISeriesSpec, 'data'>, IAnimationSpec<SankeyMark, SankeyAppearPreset> {
+    nameKey: any;
+    type: 'sankey';
+    categoryField: string;
+    valueField: string;
+    sourceField?: string;
+    targetField?: string;
+    direction?: DirectionType;
+    nodeAlign?: 'left' | 'right' | 'center' | 'justify' | 'start' | 'end';
+    nodeGap?: number;
+    nodeWidth?: string | number | ((node: SankeyNodeElement) => number);
+    linkWidth?: number | ((link: SankeyLinkElement) => number);
+    minStepWidth?: number;
+    minNodeHeight?: number;
+    minLinkHeight?: number;
+    iterations?: number;
+    nodeKey?: string | number | ((datum: SankeyNodeDatum) => string | number);
+    linkSortBy?: (a: SankeyLinkElement, b: SankeyLinkElement) => number;
+    nodeSortBy?: (a: SankeyNodeElement, b: SankeyNodeElement) => number;
+    setNodeLayer?: (datum: SankeyNodeDatum) => number;
+    [SeriesMarkNameEnum.node]?: IMarkSpec<IRectMarkSpec>;
+    [SeriesMarkNameEnum.link]?: IMarkSpec<ILinkPathMarkSpec>;
+    emphasis?: {
+        enable: boolean;
+        trigger?: 'click' | 'hover';
+        effect: 'self' | 'adjacency' | 'related';
+    };
+    [SeriesMarkNameEnum.label]?: ILabelSpec & {
+        position: 'outside' | 'inside-start' | 'inside-middle' | 'inside-end' | 'left' | 'right';
+        limit: number;
+    };
+}
+export interface SankeyLinkDatum {
+    source: string | number;
+    target: string | number;
+    value?: number;
+}
+export interface SankeyNodeDatum {
+    value?: number;
+}
+export interface HierarchyNodeDatum {
+    value?: number;
+    children?: HierarchyNodeDatum[];
+}
+export type SankeyData = {
+    nodes?: SankeyNodeDatum[];
+    links: SankeyLinkDatum[];
+} | {
+    nodes: HierarchyNodeDatum[];
+};
+export interface SankeyNodeElement {
+    key: string | number;
+    index: number;
+    depth: number;
+    endDepth?: number;
+    layer?: number;
+    isLastLayer?: boolean;
+    value: number;
+    datum: SankeyNodeDatum;
+    sourceLinks: SankeyLinkElement[];
+    targetLinks: SankeyLinkElement[];
+    x0?: number;
+    y0?: number;
+    x1?: number;
+    y1?: number;
+}
+export interface SankeyLinkElement {
+    vertical?: boolean;
+    index: number;
+    source: string | number;
+    target: string | number;
+    value: number;
+    datum: SankeyLinkDatum | SankeyLinkDatum[];
+    thickness?: number;
+    sourceRect?: {
+        x0: number;
+        x1: number;
+        y0: number;
+        y1: number;
+    };
+    targetRect?: {
+        x0: number;
+        x1: number;
+        y0: number;
+        y1: number;
+    };
+    parents?: (string | number)[];
+    y0?: number;
+    y1?: number;
+    x0?: number;
+    x1?: number;
+}
+export type SankeyLayoutResult = {
+    nodes: SankeyNodeElement[];
+    links: SankeyLinkElement[];
+    columns: SankeyNodeElement[][];
+}[];
+export interface ISankeySeriesTheme {
+    [SeriesMarkNameEnum.node]?: IMarkTheme<IRectMarkSpec>;
+    [SeriesMarkNameEnum.link]?: IMarkTheme<ILinkPathMarkSpec>;
+}

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

@@ -0,0 +1,67 @@
+import { CartesianSeries } from '../cartesian/cartesian';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { Datum } 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 { IMark } from '../../mark/interface';
+export declare class SankeySeries<T extends ISankeySeriesSpec = ISankeySeriesSpec> extends CartesianSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    private _nodeMark;
+    private _linkMark;
+    private _labelMark?;
+    private _nodeLayoutZIndex;
+    private _labelLayoutZIndex;
+    private _labelLimit;
+    protected _nodesSeriesData?: SeriesData;
+    protected _linksSeriesData?: SeriesData;
+    private _viewBox;
+    protected _categoryField: string;
+    private _colorScale;
+    getCategoryField(): string;
+    setCategoryField(f: string): string;
+    protected _valueField: string;
+    getValueField(): string;
+    setValueField(f: string): string;
+    setAttrFromSpec(): void;
+    initData(): void;
+    initMark(): void;
+    initMarkStyle(): void;
+    protected _initNodeMarkStyle(): void;
+    protected _initLinkMarkStyle(): void;
+    protected _initLabelMarkStyle(): void;
+    private _createText;
+    initAnimation(): void;
+    protected initEvent(): void;
+    private nodesSeriesDataUpdate;
+    private linksSeriesDataUpdate;
+    protected _handleAdjacencyClick: (params: ExtendEventParam) => void;
+    protected _handleRelatedClick: (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 initTooltip(): void;
+    _setNodeOrdinalColorScale(): void;
+    getNodeList(): any;
+    _getNodeNameFromData(datum: Datum): any;
+    extractNamesFromTree(tree: any, categoryName: string): Set<unknown>;
+    getDimensionField(): string[];
+    getMeasureField(): string[];
+    getRawDataStatisticsByField(field: string, isNumeric?: boolean): {
+        values?: any[];
+        min?: number;
+        max?: number;
+    };
+    private _collectByField;
+    onLayoutEnd(ctx: any): void;
+    getDefaultShapeType(): string;
+    protected _noAnimationDataKey(datum: Datum, index: number): unknown | undefined;
+    getActiveMarks(): IMark[];
+}
+export declare const registerSankeySeries: () => void;

package/types/series/sankey/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 SankeySeriesTooltipHelper extends BaseSeriesTooltipHelper implements ISeriesTooltipHelper {
+    getDefaultTooltipPattern(activeType: TooltipActiveType, dimensionInfo?: IDimensionInfo[]): ITooltipPattern | null;
+}

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

@@ -0,0 +1,8 @@
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+export type ScatterMarks = 'point' | 'label';
+export type ScatterAppearPreset = 'scaleIn' | 'fadeIn';
+export interface IScatterAnimationParams {
+    [key: string]: object;
+}
+export declare const scatterPresetAnimation: (_params: IScatterAnimationParams, preset: ScatterAppearPreset) => IAnimationTypeConfig;
+export declare const registerScatterAnimation: () => void;

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

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

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

@@ -0,0 +1,24 @@
+import type { ICartesianSeriesSpec, ICartesianSeriesTheme } from '../cartesian/interface';
+import type { IMarkSpec, IMarkTheme } from '../../typings/spec/common';
+import type { ISymbolMarkSpec, IVisualSpecBase, ShapeType, FunctionType } from '../../typings';
+import type { IAnimationSpec } from '../../animation/spec';
+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';
+export interface IScatterSeriesSpec extends ICartesianSeriesSpec, IAnimationSpec<ScatterMarks, ScatterAppearPreset>, IMarkProgressiveConfig {
+    type: 'scatter';
+    xField: string | string[];
+    yField: string | string[];
+    [SeriesMarkNameEnum.point]?: IMarkSpec<ISymbolMarkSpec>;
+    sizeField?: string;
+    size?: number | number[] | FunctionType<number> | IVisualSpecBase<unknown, number>;
+    shapeField?: string;
+    shape?: ShapeType | ShapeType[] | FunctionType<ShapeType> | IVisualSpecBase<unknown, ShapeType>;
+    [SeriesMarkNameEnum.label]?: ILineLikeLabelSpec;
+}
+export interface IScatterSeriesTheme extends ICartesianSeriesTheme {
+    size?: number;
+    shape?: ShapeType;
+    [SeriesMarkNameEnum.point]?: Partial<IMarkTheme<ISymbolMarkSpec>>;
+}

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

@@ -0,0 +1,37 @@
+import type { DataView } from '@visactor/vdataset';
+import type { Maybe, IScatterInvalidType } from '../../typings';
+import type { IScatterSeriesSpec, IScatterSeriesTheme } from './interface';
+import { CartesianSeries } from '../cartesian/cartesian';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { ILabelMark } from '../../mark/label';
+import type { IMark } from '../../mark/interface';
+export declare class ScatterSeries<T extends IScatterSeriesSpec = IScatterSeriesSpec> extends CartesianSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _theme: Maybe<IScatterSeriesTheme>;
+    private _symbolMark;
+    private _labelMark;
+    private _size;
+    private _sizeField;
+    private _shape;
+    private _shapeField;
+    protected _invalidType: IScatterInvalidType;
+    setAttrFromSpec(): void;
+    private _getSeriesAttribute;
+    private getSizeAttribute;
+    private getShapeAttribute;
+    initMark(): void;
+    initMarkStyle(): void;
+    initAnimation(): void;
+    private initSymbolMarkStyle;
+    protected initTooltip(): void;
+    viewDataStatisticsUpdate(d: DataView): void;
+    initLabelMarkStyle(labelMark?: ILabelMark): void;
+    handleZoom(e: any): void;
+    handlePan(e: any): void;
+    getDefaultShapeType(): string;
+    getActiveMarks(): IMark[];
+}
+export declare const registerScatterSeries: () => void;

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

@@ -0,0 +1,3 @@
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+import type { ISunburstAnimationParams } from './interface';
+export declare const sunburstEnter: (params: ISunburstAnimationParams) => IAnimationTypeConfig;

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

@@ -0,0 +1,3 @@
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+import type { ISunburstAnimationParams } from './interface';
+export declare const sunburstExit: (params: ISunburstAnimationParams) => IAnimationTypeConfig;

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

@@ -0,0 +1,6 @@
+export * from './preset';
+export * from './enter';
+export * from './exit';
+export * from './preset';
+export * from './interface';
+export declare const registerSunburstAnimation: () => void;

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

@@ -0,0 +1,12 @@
+export type SunburstMark = 'arc' | 'label';
+export type SunburstAppearPreset = 'growAngle' | 'growRadius' | 'fadeIn';
+export type SunburstAppearParams = 'growAngle' | 'growRadius' | 'fadeIn';
+export interface ISunburstAnimationParams {
+    animationInfo: () => animationInfo;
+}
+export type animationInfo = {
+    startAngle: number;
+    endAngle: number;
+    outerRadius: number;
+    innerRadius: number;
+};

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

@@ -0,0 +1,3 @@
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+import type { ISunburstAnimationParams, SunburstAppearPreset } from './interface';
+export declare const sunburstPresetAnimation: (_params: ISunburstAnimationParams, preset: SunburstAppearPreset) => IAnimationTypeConfig;

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

@@ -0,0 +1,3 @@
+import type { IElement } from '@visactor/vgrammar-core';
+export declare const computeRatio: (angle: number, range: [number, number]) => number;
+export declare const getInnerMostElements: (element: IElement) => IElement[];

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

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

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

@@ -0,0 +1,41 @@
+import type { IAnimationSpec } from '../../animation/spec';
+import type { IMarkSpec, IMarkTheme, ISeriesSpec } from '../../typings/spec';
+import type { SunburstLabelConfig } from '@visactor/vgrammar-hierarchy';
+import type { SunburstAppearPreset, SunburstMark } from './animation';
+import type { IArcMarkSpec, ITextMarkSpec } from '../../typings';
+import type { IPolarSeriesTheme } from '../polar/interface';
+import type { SeriesMarkNameEnum } from '../interface/type';
+export interface ISunburstSeriesSpec extends Omit<ISeriesSpec, 'data'>, IAnimationSpec<SunburstMark, SunburstAppearPreset> {
+    type: 'sunburst';
+    categoryField: string;
+    valueField: string;
+    centerX?: number;
+    centerY?: number;
+    offsetX?: number;
+    offsetY?: number;
+    startAngle?: number;
+    endAngle?: number;
+    innerRadius?: number | number[];
+    outerRadius?: number | number[];
+    gap?: number | number[];
+    labelLayout?: SunburstLabelConfig | (SunburstLabelConfig | null)[];
+    labelAutoVisible?: LabelAutoVisibleType;
+    drill?: boolean;
+    drillField?: string;
+    [SeriesMarkNameEnum.label]?: IMarkSpec<ITextMarkSpec>;
+    [SeriesMarkNameEnum.sunburst]?: IMarkSpec<IArcMarkSpec>;
+}
+export interface ISunburstSeriesTheme extends Omit<IPolarSeriesTheme, 'label' | 'innerRadius' | 'outerRadius'> {
+    startAngle?: number;
+    endAngle?: number;
+    innerRadius?: number | number[];
+    outerRadius?: number | number[];
+    gap?: number | number[];
+    labelLayout?: SunburstLabelConfig | SunburstLabelConfig[];
+    [SeriesMarkNameEnum.label]?: IMarkTheme<ITextMarkSpec>;
+    [SeriesMarkNameEnum.sunburst]?: IMarkTheme<IArcMarkSpec>;
+}
+export type LabelAutoVisibleType = {
+    enable?: boolean;
+    circumference?: number;
+};

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

@@ -0,0 +1,60 @@
+import type { Datum } from '../../typings';
+import type { ISunburstSeriesSpec } from './interface';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { IMark } from '../../mark/interface';
+import { PolarSeries } from '../polar/polar';
+export declare class SunburstSeries extends PolarSeries<any> {
+    protected _spec: ISunburstSeriesSpec;
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    private _sunburstMark;
+    private _labelMark;
+    protected _categoryField: string;
+    protected _valueField: string;
+    private _centerX;
+    private _centerY;
+    private _offsetX;
+    private _offsetY;
+    private _startAngle;
+    private _endAngle;
+    private __innerRadius;
+    private __outerRadius;
+    private _gap;
+    private _labelLayout;
+    private _labelAutoVisible?;
+    private _label;
+    private _sunburst;
+    setCategoryField(f: string): string;
+    getCategoryField(): string;
+    setValueField(f: string): string;
+    getValueField(): string;
+    getDimensionField(): string[];
+    getMeasureField(): string[];
+    setAttrFromSpec(): void;
+    protected initData(): void;
+    getStatisticFields(): {
+        key: string;
+        operations: ("values" | "max" | "min")[];
+    }[];
+    protected _addDataIndexAndKey(): void;
+    initMark(): void;
+    initMarkStyle(): void;
+    private _initArcMark;
+    private _initArcMarkStyle;
+    private _initLabelMark;
+    private _initLabelMarkStyle;
+    protected initTooltip(): void;
+    initAnimation(): void;
+    initEvent(): void;
+    onLayoutEnd(ctx: any): void;
+    private _computeRadius;
+    private _computeLevel;
+    getGroupFields(): string[];
+    getStackGroupFields(): string[];
+    getStackValueField(): string;
+    protected _noAnimationDataKey(datum: Datum, index: number): unknown | undefined;
+    getActiveMarks(): IMark[];
+}
+export declare const registerSunBurstSeries: () => void;

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

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

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

@@ -0,0 +1,5 @@
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+export type TreemapMark = 'leaf' | 'nonLeaf';
+export type TreemapAppearPreset = 'growIn' | 'fadeIn';
+export declare const treemapPresetAnimation: (preset: TreemapAppearPreset) => IAnimationTypeConfig;
+export declare const registerTreemapAnimation: () => void;

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

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