@visactor/vchart-types 0.10.0-alpha.2

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: ("max" | "min" | "values")[];
+    }[];
+    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;

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

@@ -0,0 +1,41 @@
+import type { IRectMarkSpec, ITextMarkSpec } from '../../typings';
+import type { IHierarchyData, IMarkSpec, IMarkTheme, ISeriesSpec } from '../../typings/spec';
+import type { TreemapOptions } from '@visactor/vgrammar-hierarchy';
+import type { ICartesianSeriesTheme } from '../cartesian/interface';
+import type { IAnimationSpec } from '../../animation/spec';
+import type { TreemapAppearPreset, TreemapMark } from './animation';
+import type { SeriesMarkNameEnum } from '../interface/type';
+export interface ITreemapSeriesSpec extends Omit<ISeriesSpec, 'data'>, IAnimationSpec<TreemapMark, TreemapAppearPreset> {
+    type: 'treemap';
+    categoryField: string;
+    valueField: string;
+    data: IHierarchyData;
+    aspectRatio?: number;
+    splitType?: TreemapOptions['splitType'];
+    gapWidth?: TreemapOptions['gapWidth'];
+    nodePadding?: TreemapOptions['padding'];
+    maxDepth?: TreemapOptions['maxDepth'];
+    minVisibleArea?: TreemapOptions['minVisibleArea'];
+    minChildrenVisibleArea?: TreemapOptions['minChildrenVisibleArea'];
+    minChildrenVisibleSize?: TreemapOptions['minChildrenVisibleSize'];
+    roam?: boolean;
+    drill?: boolean;
+    drillField?: string;
+    [SeriesMarkNameEnum.leaf]?: IMarkSpec<IRectMarkSpec>;
+    [SeriesMarkNameEnum.nonLeaf]?: IMarkSpec<IRectMarkSpec>;
+    [SeriesMarkNameEnum.label]?: IMarkSpec<ITextMarkSpec>;
+    [SeriesMarkNameEnum.nonLeafLabel]?: IMarkSpec<ITextMarkSpec> & {
+        position?: TreemapOptions['labelPosition'];
+        padding?: TreemapOptions['labelPadding'];
+    };
+}
+export interface ITreemapSeriesTheme extends ICartesianSeriesTheme {
+    gapWidth?: TreemapOptions['padding'];
+    nodePadding?: TreemapOptions['padding'];
+    [SeriesMarkNameEnum.leaf]?: Partial<IMarkTheme<IRectMarkSpec>>;
+    [SeriesMarkNameEnum.nonLeaf]?: Partial<IMarkTheme<IRectMarkSpec>>;
+    [SeriesMarkNameEnum.label]?: Partial<IMarkTheme<ITextMarkSpec>>;
+    [SeriesMarkNameEnum.nonLeafLabel]?: Partial<IMarkTheme<ITextMarkSpec> & {
+        padding?: TreemapOptions['labelPadding'];
+    }>;
+}

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

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

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

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

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

@@ -0,0 +1,61 @@
+import type { IMark } from '../../mark/interface';
+import { CartesianSeries } from '../cartesian/cartesian';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { ITreemapSeriesSpec } from './interface';
+import type { PanEventParam, ZoomEventParam } from '../../event/interface';
+import { DataView } from '@visactor/vdataset';
+import type { ILabelMark } from '../../mark/label';
+import { TreemapSeriesSpecTransformer } from './treemap-transform';
+export declare class TreemapSeries extends CartesianSeries<any> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    static readonly transformerConstructor: typeof TreemapSeriesSpecTransformer;
+    readonly transformerConstructor: typeof TreemapSeriesSpecTransformer;
+    private _leafMark;
+    private _nonLeafMark;
+    private _labelMark;
+    private _nonLeafLabelMark;
+    protected _spec: ITreemapSeriesSpec;
+    protected _categoryField: string;
+    getCategoryField(): string;
+    setCategoryField(f: string): string;
+    protected _valueField: string;
+    getValueField(): string;
+    setValueField(f: string): string;
+    private _maxDepth;
+    private _matrix;
+    private _viewBox;
+    private _enableAnimationHook;
+    setAttrFromSpec(): void;
+    initData(): void;
+    protected _addDataIndexAndKey(): void;
+    getRawDataStatisticsByField(field: string, isNumeric?: boolean): any;
+    protected _createHierarchyDataStatistics(dataName: string, rawData: DataView[]): DataView;
+    getStatisticFields(): {
+        key: string;
+        operations: import("../../data/transforms/dimension-statistics").StatisticOperations;
+    }[];
+    initMark(): void;
+    initMarkStyle(): void;
+    protected _initLeafMarkStyle(): void;
+    protected _initNonLeafMarkStyle(): void;
+    initLabelMarkStyle(labelMark: ILabelMark): void;
+    protected initNonLeafLabelMarkStyle(labelMark: ILabelMark): void;
+    initAnimation(): void;
+    protected initEvent(): void;
+    protected _getDataIdKey(): string;
+    protected initTooltip(): void;
+    private _shouldFilterElement;
+    handlePan(event: PanEventParam): void;
+    handleZoom(event: ZoomEventParam): void;
+    getDimensionField(): string[];
+    getMeasureField(): string[];
+    onLayoutEnd(ctx: any): void;
+    protected enableMarkAnimation(): void;
+    protected disableMarkAnimation(): void;
+    getDefaultShapeType(): string;
+    getActiveMarks(): IMark[];
+}
+export declare const registerTreemapSeries: () => void;

package/types/series/util/label-mark.d.ts

@@ -0,0 +1,4 @@
+import type { ITextMark } from '../../mark/text';
+import type { DirectionType } from '../../typings/space';
+import type { ISeries } from '../interface';
+export declare function setRectLabelPos(component: ISeries, labelMark: ITextMark, position: string, offset: number, x: (datum: any) => number, x1: (datum: any) => number, y: (datum: any) => number, y1: (datum: any) => number, direction: () => DirectionType): void;

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

@@ -0,0 +1,2 @@
+import type { DirectionType, ISeriesSpec } from '../../typings';
+export declare function getDirectionFromSeriesSpec(spec: ISeriesSpec): DirectionType;

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

@@ -0,0 +1,9 @@
+import type { IStackCacheNode } from '../../util/data';
+export declare function stackWithMinHeight(stackCache: IStackCacheNode, stackInverse: boolean, context: {
+    isVertical: boolean;
+    start: string;
+    end: string;
+    startMethod: string;
+    endMethod: string;
+    axisHelper: string;
+}): void;

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

@@ -0,0 +1,10 @@
+import type { IAxisHelper as CartesianHelper } from '../../component/axis/cartesian/interface/common';
+import type { Datum } from '../../typings';
+import type { IPolarAxisHelper } from '../../component/axis';
+import type { ICartesianSeries } from '..';
+export declare function isPolarAxisSeries(type: string): boolean;
+export declare function sortDataInAxisHelper(axisHelper: CartesianHelper | IPolarAxisHelper, field: string, dataList: Datum[]): void;
+export declare function getGroupAnimationParams(series: ICartesianSeries): {
+    dataIndex: (datum: any) => any;
+    dataCount: () => any;
+};

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

@@ -0,0 +1,5 @@
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+import type { IBarAnimationParams, BarAppearPreset } from '../bar/animation';
+export type WaterfallAppearPreset = BarAppearPreset;
+export declare function waterfallPresetAnimation(params: IBarAnimationParams, preset: BarAppearPreset): IAnimationTypeConfig;
+export declare const registerWaterfallAnimation: () => void;

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

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

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

@@ -0,0 +1,60 @@
+import type { Datum, IMarkSpec, IMarkTheme, IRuleMarkSpec, ITextMarkSpec } from '../../typings';
+import type { IAnimationSpec } from '../../animation/spec';
+import type { WaterfallAppearPreset } from './animation';
+import type { IBarSeriesSpec, IBarSeriesTheme } from '../bar/interface';
+import type { ILabelSpec } from '../../component/label';
+import type { SeriesMarkNameEnum } from '../interface/type';
+type WaterfallMarks = 'bar';
+export interface IWaterfallTotalText {
+    text?: string;
+}
+export interface IWaterfallTotalEnd extends IWaterfallTotalText {
+    type: 'end';
+}
+export interface IWaterfallTotalCustom extends IWaterfallTotalText {
+    type: 'custom';
+    tagField: string;
+    product: (datum: Datum, current: {
+        start: number;
+        end: number;
+    }) => {
+        start: number;
+        end: number;
+    };
+}
+export interface IWaterfallTotalField extends IWaterfallTotalText {
+    type: 'field';
+    tagField: string;
+    valueField?: string;
+    startField?: string;
+    collectCountField?: string;
+}
+export type IWaterfallStackLabelPosition = 'withChange' | 'middle' | 'max' | 'min';
+export type IWaterfallStackLabelValueType = 'change' | 'absolute';
+export interface IWaterfallSeriesSpec extends Omit<IBarSeriesSpec, 'type' | 'label'>, IAnimationSpec<WaterfallMarks, WaterfallAppearPreset> {
+    type: 'waterfall';
+    total?: IWaterfallTotalEnd | IWaterfallTotalField | IWaterfallTotalCustom;
+    [SeriesMarkNameEnum.leaderLine]?: IMarkSpec<IRuleMarkSpec>;
+    [SeriesMarkNameEnum.stackLabel]?: ILabelSpec & {
+        position?: IWaterfallStackLabelPosition;
+        offset?: number;
+        valueType?: IWaterfallStackLabelValueType;
+    };
+    [SeriesMarkNameEnum.label]?: ILabelSpec & {
+        visible: boolean;
+        offset?: number;
+    };
+}
+export interface IWaterfallSeriesTheme extends IBarSeriesTheme {
+    seriesFieldName: {
+        total: string;
+        increase: string;
+        decrease: string;
+    };
+    [SeriesMarkNameEnum.leaderLine]?: Partial<IMarkTheme<IRuleMarkSpec>>;
+    [SeriesMarkNameEnum.stackLabel]?: Partial<IMarkTheme<ITextMarkSpec> & {
+        offset?: number;
+        position?: IWaterfallStackLabelPosition;
+    }>;
+}
+export {};

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

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

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

@@ -0,0 +1,41 @@
+import type { IRuleMark } from '../../mark/rule';
+import { BarSeries } from '../bar/bar';
+import type { IWaterfallSeriesSpec } from './interface';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { ITransformOptions, DataView } from '@visactor/vdataset';
+import { SeriesData } from '../base/series-data';
+import type { ITextMark } from '../../mark/text';
+import type { IModelEvaluateOption } from '../../model/interface';
+import type { Datum } from '../../typings';
+import type { ILabelMark } from '../../mark/label';
+export declare const DefaultBandWidth = 6;
+export declare class WaterfallSeries<T extends IWaterfallSeriesSpec = IWaterfallSeriesSpec> extends BarSeries<any> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    static readonly transformerConstructor: any;
+    readonly transformerConstructor: any;
+    protected _stack: boolean;
+    protected _totalData?: SeriesData;
+    getTotalData(): any;
+    protected _spec: T;
+    protected _leaderLineMark: IRuleMark;
+    protected _stackLabelMark: ITextMark;
+    protected _labelMark: ITextMark;
+    protected initGroups(): void;
+    setAttrFromSpec(): void;
+    getSeriesKeys(): string[];
+    protected initData(): void;
+    initAnimation(): void;
+    viewDataUpdate(d: DataView): void;
+    addViewDataFilter(_option: ITransformOptions): void;
+    reFilterViewData(): void;
+    onEvaluateEnd(ctx: IModelEvaluateOption): void;
+    initMark(): void;
+    initLabelMarkStyle(labelMark: ILabelMark): void;
+    totalPositionX(datum: Datum, field: string, pos?: number): number;
+    totalPositionY(datum: Datum, field: string, pos?: number): number;
+    initMarkStyle(): void;
+}
+export declare const registerWaterfallSeries: () => void;

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

@@ -0,0 +1,14 @@
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+export interface IWordcloud3dAnimationParams {
+    radius: number;
+    depth_3d: number;
+}
+export interface IWordcloudAnimationParams {
+    animationConfig: () => IAnimationTypeConfig;
+}
+export type WordcloudAppearPreset = 'scaleIn' | 'fadeIn';
+export declare const WordCloud3dAnimation: (params: IWordcloud3dAnimationParams | (() => any)) => IAnimationTypeConfig;
+export declare const WordCloudScaleInAnimation: (params: IWordcloudAnimationParams) => IAnimationTypeConfig;
+export declare function wordcloudPresetAnimation(params: IWordcloudAnimationParams, preset: WordcloudAppearPreset | boolean): IAnimationTypeConfig;
+export declare const registerWordCloudAnimation: () => void;
+export declare const registerWordCloud3dAnimation: () => void;

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

@@ -0,0 +1,66 @@
+import type { IPadding } from '@visactor/vutils';
+import type { ITextMark } from '../../mark/text';
+import type { SeriesMarkMap } from '../interface';
+import type { IWordCloudSeriesSpec, WordCloudConfigType, WordCloudShapeConfigType, WordCloudShapeType } from './interface';
+import type { Datum, IPoint } from '../../typings';
+import { BaseSeries } from '../base/base-series';
+import type { IMark } from '../../mark/interface';
+export type IBaseWordCloudSeriesSpec = Omit<IWordCloudSeriesSpec, 'type'> & {
+    type: string;
+};
+export declare class BaseWordCloudSeries<T extends IBaseWordCloudSeriesSpec = IBaseWordCloudSeriesSpec> extends BaseSeries<T> {
+    static readonly mark: SeriesMarkMap;
+    protected _nameField: string;
+    protected _valueField?: string;
+    setValueField(field: string): void;
+    protected _fontFamilyField: string;
+    protected _fontWeightField: string;
+    protected _fontStyleField: string;
+    protected _colorHexField: string;
+    protected _colorMode: 'linear' | 'ordinal';
+    protected _colorList: string[];
+    protected _rotateAngles?: number[];
+    protected _fontWeightRange?: [number, number];
+    protected _textField?: string;
+    protected _fontSizeRange?: [number, number] | 'auto';
+    setFontSizeRange(fontSizeRange: [number, number] | 'auto'): void;
+    protected _maskShape?: string | WordCloudShapeType;
+    protected _isWordCloudShape: boolean;
+    protected _keepAspect?: boolean;
+    protected _random?: boolean;
+    protected _fontPadding?: number;
+    protected _fillingFontPadding?: number;
+    protected _wordCloudConfig?: WordCloudConfigType;
+    protected _wordCloudShapeConfig?: WordCloudShapeConfigType;
+    protected _padding?: IPadding;
+    protected _defaultFontFamily: string;
+    protected _keyWordColorCallback: (datum: Datum) => string;
+    protected _fillingColorCallback: (datum: Datum) => string;
+    setAttrFromSpec(): void;
+    protected _wordMark: ITextMark;
+    initMark(): void;
+    initMarkStyle(): void;
+    protected initTooltip(): void;
+    initAnimation(): void;
+    protected getWordOrdinalColorScale(field: string, isFillingWord: boolean): any;
+    protected initColorCallback(field: string, isFillingWord: boolean): (datum: Datum) => any;
+    getWordColor: (datum: Datum) => string;
+    compile(): void;
+    protected _wordCloudTransformOption(): Object;
+    protected _wordCloudShapeTransformOption(): Object;
+    getStatisticFields(): {
+        key: string;
+        operations: Array<'max' | 'min' | 'values'>;
+    }[];
+    dataToPosition(data: Datum): IPoint;
+    dataToPositionX(data: any): number;
+    dataToPositionY(data: any): number;
+    dataToPositionZ(data: any): number;
+    valueToPosition(value1: any, value2?: any): IPoint;
+    getGroupFields(): string[];
+    getStackGroupFields(): string[];
+    getStackValueField(): string;
+    onLayoutEnd(ctx: any): void;
+    getActiveMarks(): IMark[];
+    reInit(): void;
+}

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

@@ -0,0 +1,16 @@
+export declare const DEFAULT_ROTATE_ANGLES: number[];
+export declare const DEFAULT_DRAW_OUT_OF_BOUND = "hidden";
+export declare const DEFAULT_MIN_FONT_SIZE = 20;
+export declare const DEFAULT_FONTSIZE_RANGE: [number, number];
+export declare const DEFAULT_FONT_WEIGHT_RANGE: [number, number];
+export declare const DEFAULT_MASK_SHAPE = "circle";
+export declare const DEFAULT_ZOOM_TO_FIT: {
+    shrink: boolean;
+    enlarge: boolean;
+    fontSizeLimitMin: number;
+};
+export declare const DEFAULT_RANDOM = true;
+export declare const DEFAULT_FONT_PADDING = 1;
+export declare const DEFAULT_TEXT_ALIGN = "center";
+export declare const DEFAULT_TEXT_BASE_LINE = "alphabetic";
+export declare const SHAPE_TYPE: string[];

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

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

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

@@ -0,0 +1,111 @@
+import type { ITextMarkSpec, IMarkSpec, ISeriesSpec } from '../../typings';
+import type { IAnimationSpec, IMarkAnimateSpec, IStateAnimateSpec } from '../../animation/spec';
+import type { SeriesMarkNameEnum } from '../interface/type';
+import type { WordcloudAppearPreset } from './animation';
+import type { shapes } from '@visactor/vgrammar-wordcloud';
+export type WordCloudShapeType = keyof typeof shapes;
+export type EllipsisType = {
+    string?: string;
+    limitLength?: number;
+};
+export type ZoomToFitType = {
+    shrink?: boolean;
+    enlarge?: boolean;
+    fontSizeLimitMin?: number;
+    fontSizeLimitMax?: number;
+};
+export type DrawOutOfBoundType = 'clip' | 'hidden' | 'ellipsis';
+export type WordCloudConfigType = {
+    drawOutOfBound?: DrawOutOfBoundType;
+    ellipsis?: EllipsisType;
+    layoutMode?: 'fast' | 'grid' | 'default';
+    zoomToFit: ZoomToFitType;
+    progressiveTime?: number;
+    progressiveStep?: number;
+};
+export type WordCloudShapeConfigType = {
+    fillingSeriesField?: string;
+    fillingColorList?: string[];
+    fillingFontFamilyField?: string;
+    fillingFontWeightField?: string;
+    fillingFontStyleField?: string;
+    fillingColorHexField?: string;
+    fillingRotateAngles?: number[];
+    ratio?: number;
+    removeWhiteBorder?: boolean;
+    layoutMode?: 'default' | 'ensureMapping' | 'ensureMappingEnlarge';
+    fillingTimes?: number;
+    fillingXStep?: number;
+    fillingYStep?: number;
+    fillingXRatioStep?: number;
+    fillingYRatioStep?: number;
+    fillingInitialFontSize?: number;
+    fillingDeltaFontSize?: number;
+    fillingInitialOpacity?: number;
+    fillingDeltaOpacity?: number;
+    textLayoutTimes?: number;
+    fontSizeShrinkFactor?: number;
+    stepFactor?: number;
+    importantWordCount?: number;
+    globalShinkLimit?: number;
+    fontSizeEnlargeFactor?: number;
+    fillingDeltaFontSizeFactor?: number;
+    fillingRatio?: number;
+};
+export interface IWordCloudSeriesBaseSpec extends ISeriesSpec, IAnimationSpec<string, WordcloudAppearPreset> {
+    nameField: string;
+    valueField?: string;
+    fontFamilyField?: string;
+    fontWeightField?: string;
+    fontStyleField?: string;
+    colorHexField?: string;
+    colorMode?: 'linear' | 'ordinal';
+    colorList?: string[];
+    rotateAngles?: number[];
+    fontWeightRange?: [number, number];
+    fontSizeRange?: [number, number] | 'auto';
+    maskShape?: string | WordCloudShapeType;
+    keepAspect?: boolean;
+    random?: boolean;
+    wordCloudConfig?: WordCloudConfigType;
+    wordCloudShapeConfig?: WordCloudShapeConfigType;
+    [SeriesMarkNameEnum.word]?: IMarkSpec<ITextMarkSpec> & {
+        padding?: number;
+        formatMethod?: (datum?: any) => string;
+    };
+    [SeriesMarkNameEnum.fillingWord]?: IMarkSpec<ITextMarkSpec> & {
+        padding?: number;
+    };
+    animationAppear?: boolean | (IStateAnimateSpec<WordcloudAppearPreset> & {
+        duration?: number;
+        totalTime?: number;
+    }) | IMarkAnimateSpec<string>;
+}
+export interface IWordCloudSeriesSpec extends IWordCloudSeriesBaseSpec {
+    type: 'wordCloud';
+}
+export interface IWordCloudSeriesTheme {
+    [SeriesMarkNameEnum.word]?: IMarkSpec<ITextMarkSpec> & {
+        padding?: number;
+        formatMethod?: (datum?: any) => string;
+    };
+    [SeriesMarkNameEnum.fillingWord]?: IMarkSpec<ITextMarkSpec> & {
+        padding?: number;
+        formatMethod?: (datum?: any) => string;
+    };
+}
+export interface IWordCloud3dSeriesSpec extends IWordCloudSeriesBaseSpec {
+    type: 'wordCloud3d';
+    depth_3d?: number;
+    postProjection?: 'StereographicProjection';
+}
+export interface IWordCloud3dSeriesTheme {
+    [SeriesMarkNameEnum.word]?: IMarkSpec<ITextMarkSpec> & {
+        padding?: number;
+        formatMethod?: (text: string | string[], datum?: any) => string | string[];
+    };
+    [SeriesMarkNameEnum.fillingWord]?: IMarkSpec<ITextMarkSpec> & {
+        padding?: number;
+        formatMethod?: (text: string | string[], datum?: any) => string | string[];
+    };
+}