@visactor/vchart-types 0.16.17-alpha.0

package/types/animation/animate-manager.d.ts

@@ -0,0 +1,12 @@
+import { StateManager } from '../compile/signal/state-manager';
+import type { StateValueMap } from '../compile/signal/interface';
+import type { IAnimate, IAnimateState } from './interface';
+import { AnimationStateEnum } from './interface';
+export declare class AnimateManager extends StateManager implements IAnimate {
+    protected _stateMap: IAnimateState & StateValueMap;
+    readonly id: number;
+    protected stateKeyToSignalName: (key: string) => string;
+    getAnimationStateSignalName(): string;
+    updateAnimateState(state: AnimationStateEnum, noRender?: boolean): void;
+    protected _getDefaultStateMap(): IAnimateState & StateValueMap;
+}

package/types/animation/config.d.ts

@@ -0,0 +1,56 @@
+export declare const DEFAULT_ANIMATION_CONFIG: {
+    appear: {
+        duration: number;
+        easing: string;
+    };
+    update: {
+        type: string;
+        duration: number;
+        easing: string;
+    };
+    enter: {
+        duration: number;
+        easing: string;
+    };
+    exit: {
+        duration: number;
+        easing: string;
+    };
+    disappear: {
+        duration: number;
+        easing: string;
+    };
+};
+export declare const ScaleInOutAnimation: {
+    appear: {
+        type: string;
+    };
+    enter: {
+        type: string;
+    };
+    exit: {
+        type: string;
+    };
+    disappear: {
+        type: string;
+    };
+};
+export declare const FadeInOutAnimation: {
+    appear: {
+        type: string;
+    };
+    enter: {
+        type: string;
+    };
+    exit: {
+        type: string;
+    };
+    disappear: {
+        type: string;
+    };
+};
+export declare const registerScaleInOutAnimation: () => void;
+export declare const registerFadeInOutAnimation: () => void;
+export declare const registerCartesianGroupClipAnimation: () => void;
+export declare const registerLineAnimation: () => void;
+export declare const registerVGrammarAnimation: () => void;

package/types/animation/interface.d.ts

@@ -0,0 +1,29 @@
+export type { MarkAnimationSpec } from '@visactor/vgrammar-core';
+import type { ICompilable } from '../compile/interface';
+export declare enum AnimationStateEnum {
+    appear = "appear",
+    disappear = "disappear",
+    enter = "enter",
+    update = "update",
+    state = "state",
+    exit = "exit",
+    normal = "normal",
+    none = "none"
+}
+export type IAnimationState = keyof typeof AnimationStateEnum;
+export interface IAnimateState {
+    animationState: {
+        callback: (datum: any, element: any) => AnimationStateEnum;
+    };
+}
+export interface IAnimate extends ICompilable {
+    id: number;
+    updateAnimateState: (state: AnimationStateEnum, noRender?: boolean) => void;
+    getAnimationStateSignalName: () => string;
+}
+export interface ICartesianGroupAnimationParams {
+    direction: () => 'x' | 'y';
+    orient: () => 'positive' | 'negative';
+    width: () => number;
+    height: () => number;
+}

package/types/animation/spec.d.ts

@@ -0,0 +1,24 @@
+import type { IAnimationConfig } from '@visactor/vgrammar-core';
+import type { EasingType } from '@visactor/vrender-core';
+export type { IRunningConfig as IMorphConfig, IMorphAnimationConfig } from '@visactor/vgrammar-core';
+export type IStateAnimateSpec<Preset extends string> = {
+    preset?: Preset | false;
+    duration?: number;
+    delay?: number;
+    easing?: EasingType;
+    oneByOne?: boolean;
+};
+export type IMarkAnimateSpec<MarkName extends string> = Partial<Record<MarkName, false | IAnimationConfig | IAnimationConfig[]>>;
+export interface IAnimationSpec<MarkName extends string, Preset extends string> {
+    animationAppear?: boolean | IStateAnimateSpec<Preset> | IMarkAnimateSpec<MarkName>;
+    animationEnter?: boolean | Omit<IStateAnimateSpec<Preset>, 'preset'> | IMarkAnimateSpec<MarkName>;
+    animationUpdate?: boolean | Omit<IStateAnimateSpec<Preset>, 'preset'> | IMarkAnimateSpec<MarkName>;
+    animationExit?: boolean | Omit<IStateAnimateSpec<Preset>, 'preset'> | IMarkAnimateSpec<MarkName>;
+    animationDisappear?: boolean | Omit<IStateAnimateSpec<Preset>, 'preset'> | IMarkAnimateSpec<MarkName>;
+    animationNormal?: IMarkAnimateSpec<MarkName>;
+}
+export interface IMorphSeriesSpec {
+    enable?: boolean;
+    morphKey?: string;
+    morphElementKey?: string;
+}

package/types/animation/utils.d.ts

@@ -0,0 +1,17 @@
+import type { IAnimationConfig } from '@visactor/vgrammar-core';
+import type { MarkAnimationSpec, IAnimationState } from './interface';
+import type { IStateAnimateSpec, IAnimationSpec } from './spec';
+import type { SeriesMarkNameEnum } from '../series/interface/type';
+import type { ISeries } from '../series';
+import type { ISeriesSpec } from '../typings';
+import type { ISeriesMarkAttributeContext } from '../compile/mark';
+export declare const AnimationStates: string[];
+export declare function animationConfig<Preset extends string>(defaultConfig?: MarkAnimationSpec, userConfig?: Partial<Record<IAnimationState, boolean | IStateAnimateSpec<Preset> | IAnimationConfig | IAnimationConfig[]>>, params?: {
+    dataIndex: (datum: any) => number;
+}): MarkAnimationSpec;
+export declare function userAnimationConfig<M extends string, Preset extends string>(markName: SeriesMarkNameEnum | string, spec: IAnimationSpec<M, Preset>, ctx: ISeriesMarkAttributeContext): Partial<Record<"none" | "state" | "normal" | "update" | "appear" | "enter" | "exit" | "disappear", boolean | IAnimationConfig | IAnimationConfig[] | IStateAnimateSpec<string>>>;
+export declare function shouldMarkDoMorph(spec: ISeriesSpec & IAnimationSpec<string, string>, markName: string): boolean;
+export declare function isTimeLineAnimation(animationConfig: IAnimationConfig): boolean;
+export declare function isChannelAnimation(animationConfig: IAnimationConfig): boolean;
+export declare function uniformAnimationConfig<Preset extends string>(config: Partial<Record<IAnimationState, boolean | IStateAnimateSpec<Preset> | IAnimationConfig | IAnimationConfig[]>>, ctx: ISeriesMarkAttributeContext): Partial<Record<"none" | "state" | "normal" | "update" | "appear" | "enter" | "exit" | "disappear", boolean | IAnimationConfig | IAnimationConfig[] | IStateAnimateSpec<Preset>>>;
+export declare function isAnimationEnabledForSeries(series: ISeries): boolean;

package/types/chart/area/area.d.ts

@@ -0,0 +1,12 @@
+import { CartesianChart } from '../cartesian/cartesian';
+import type { IAreaChartSpec } from './interface';
+export declare class AreaChart extends CartesianChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _canStack: boolean;
+    protected _getDefaultSeriesSpec(spec: IAreaChartSpec): any;
+    transformSpec(spec: any): void;
+}
+export declare const registerAreaChart: () => void;

package/types/chart/area/index.d.ts

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

package/types/chart/area/interface.d.ts

@@ -0,0 +1,7 @@
+import type { ICartesianChartSpec } from '../cartesian/interface';
+import type { IAreaSeriesSpec } from '../../series/area/interface';
+import type { IChartExtendsSeriesSpec } from '../../typings/spec';
+export interface IAreaChartSpec extends ICartesianChartSpec, IChartExtendsSeriesSpec<IAreaSeriesSpec> {
+    type: 'area';
+    series?: IAreaSeriesSpec[];
+}

package/types/chart/bar/bar-3d.d.ts

@@ -0,0 +1,9 @@
+import { CartesianChart } from '../cartesian/cartesian';
+export declare class Bar3dChart extends CartesianChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _getDefaultSeriesSpec(spec: any): any;
+}
+export declare const registerBar3dChart: () => void;

package/types/chart/bar/bar.d.ts

@@ -0,0 +1,11 @@
+import { CartesianChart } from '../cartesian/cartesian';
+export declare class BarChart extends CartesianChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _canStack: boolean;
+    protected _getDefaultSeriesSpec(spec: any): any;
+    transformSpec(spec: any): void;
+}
+export declare const registerBarChart: () => void;

package/types/chart/bar/index.d.ts

@@ -0,0 +1,3 @@
+export * from './bar';
+export * from './bar-3d';
+export * from './interface';

package/types/chart/bar/interface.d.ts

@@ -0,0 +1,11 @@
+import type { IBarSeriesSpec, IBar3dSeriesSpec } from '../../series/bar/interface';
+import type { IChartExtendsSeriesSpec } from '../../typings/spec/common';
+import type { ICartesianChartSpec } from '../cartesian/interface';
+export interface IBarChartSpec extends ICartesianChartSpec, IChartExtendsSeriesSpec<IBarSeriesSpec> {
+    type: 'bar';
+    series?: IBarSeriesSpec[];
+}
+export interface IBar3dChartSpec extends ICartesianChartSpec, IChartExtendsSeriesSpec<IBar3dSeriesSpec> {
+    type: 'bar3d';
+    series?: IBar3dSeriesSpec[];
+}

package/types/chart/base-chart.d.ts

@@ -0,0 +1,154 @@
+import { ChartData } from './chart-meta/data';
+import type { ISeriesSpec, Datum, IMarkStateSpec, IRegionQuerier, MaybeArray, IPadding, IRect, StringOrNumber, IChartSpec, IDataValues } from '../typings';
+import type { LayoutCallBack } from '../layout/interface';
+import type { ILayoutModelState, ILayoutOrientPadding, ILayoutRect, IModel, IModelOption, IUpdateSpecResult } from '../model/interface';
+import type { IChart, IChartLayoutOption, IChartRenderOption, IChartOption, IChartEvaluateOption, ILayoutParams, DimensionIndexOption } from './interface';
+import type { ISeries } from '../series/interface';
+import type { IRegion } from '../region/interface';
+import type { IComponent } from '../component/interface';
+import { type IMark } from '../mark/interface';
+import type { IEvent } from '../event/interface';
+import type { DataView } from '@visactor/vdataset';
+import type { DataSet } from '@visactor/vdataset/es/data-set';
+import { Stack } from './stack';
+import type { IParserOptions } from '@visactor/vdataset/es/parser';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { IRunningConfig as IMorphConfig, IView } from '@visactor/vgrammar-core';
+import { CompilableBase } from '../compile/compilable-base';
+import type { IGlobalScale } from '../scale/interface';
+import type { IRectMark } from '../mark/rect';
+export declare class BaseChart extends CompilableBase implements IChart {
+    readonly type: string;
+    readonly id: number;
+    protected _spec: any;
+    getSpec(): any;
+    setSpec(s: any): void;
+    getOption(): IChartOption;
+    protected _regions: IRegion[];
+    protected _series: ISeries[];
+    protected _components: IComponent[];
+    protected _layoutFunc: LayoutCallBack;
+    protected _layoutRect: IRect;
+    getLayoutRect(): IRect;
+    protected _viewRect: ILayoutRect;
+    getViewRect(): ILayoutRect;
+    protected _viewBox: IBoundsLike;
+    protected _layoutTag: boolean;
+    getLayoutTag(): boolean;
+    setLayoutTag(tag: boolean, morphConfig?: IMorphConfig, reLayout?: boolean): boolean;
+    protected _modelOption: IModelOption;
+    protected _globalScale: IGlobalScale;
+    protected _idMap: Map<number, IModel | IMark>;
+    protected _event: IEvent;
+    getEvent(): IEvent;
+    protected _dataSet: DataSet;
+    protected _chartData: ChartData;
+    get chartData(): ChartData;
+    protected _option: IChartOption;
+    readonly state: ILayoutModelState;
+    protected _stack: Stack;
+    protected _canStack: boolean;
+    padding: IPadding;
+    protected _paddingSpec: ILayoutOrientPadding;
+    protected _canvasRect: ILayoutRect;
+    protected _backgroundMark: IRectMark;
+    constructor(spec: any, option: IChartOption);
+    created(): void;
+    transformSpec(spec: any): void;
+    init(options?: any): void;
+    reDataFlow(): void;
+    onResize(width: number, height: number): void;
+    updateViewBox(viewBox: IBoundsLike, reLayout: boolean): void;
+    createBackground(bg: IChartSpec['background']): void;
+    createRegion(regionSpec: any[]): void;
+    initRegion(): void;
+    createSeries(seriesSpec: ISeriesSpec[]): void;
+    initSeries(): void;
+    getAllSeries: () => ISeries[];
+    getSeriesById(id: number): ISeries | undefined;
+    private _createComponent;
+    createComponent(spec: any): void;
+    initComponent(): void;
+    getAllComponents(): IComponent[];
+    getAllModels(): IModel[];
+    getModelInFilter(filter: string | {
+        type: string;
+        index: number;
+    } | ((model: IModel) => boolean)): IModel;
+    createLayout(): void;
+    setLayout(layout: LayoutCallBack): void;
+    private _initLayoutFunc;
+    layout(params: ILayoutParams): void;
+    onLayoutStart(option: IChartLayoutOption): void;
+    onLayoutEnd(option: IChartLayoutOption): void;
+    onEvaluateEnd(option: IChartEvaluateOption): void;
+    getLayoutElements(): (IComponent | IRegion | ISeries)[];
+    getRegionsInIndex: (index?: number[]) => IRegion[];
+    getAllRegions: () => IRegion[];
+    getRegionsInIds: (ids: number[]) => IRegion[];
+    getRegionsInQuerier: (region?: MaybeArray<IRegionQuerier>) => IRegion[];
+    getRegionsInUserId: (userId: StringOrNumber) => IRegion | undefined;
+    getRegionsInUserIdOrIndex: (user_ids?: StringOrNumber[], index?: number[]) => IRegion[];
+    getComponents: () => IComponent[];
+    getSeriesInIndex: (index?: number[]) => ISeries[];
+    getSeriesInIds: (ids?: number[]) => ISeries[];
+    getSeriesInUserId: (userId: StringOrNumber) => ISeries | undefined;
+    getSeriesInUserIdOrIndex: (user_ids?: StringOrNumber[], index?: number[]) => ISeries[];
+    getComponentByIndex: (key: string, index: number) => IComponent;
+    getComponentsByKey: (key: string) => IComponent[];
+    getComponentByUserId: (userId: StringOrNumber) => IComponent;
+    getModelById(id: number): IModel | undefined;
+    getModelByUserId(userId: StringOrNumber): IModel | undefined;
+    getAllMarks(): IMark[];
+    getMarkById(id: number): IMark | undefined;
+    updateData(id: StringOrNumber, data: unknown, updateGlobalScale?: boolean, options?: IParserOptions): void;
+    updateFullData(data: IDataValues | IDataValues[], updateGlobalScale?: boolean): void;
+    onRender(option: IChartRenderOption): void;
+    setCanvasRect(width: number, height: number): void;
+    getCanvasRect(): Omit<IRect, 'x' | 'y'>;
+    getSeriesData(id: StringOrNumber | undefined, index: number | undefined): DataView | undefined;
+    private _transformSpecScale;
+    createGlobalScale(): void;
+    updateGlobalScaleDomain(): void;
+    updateGlobalScale(result: IUpdateSpecResult): void;
+    updateGlobalScaleTheme(): void;
+    updateSpec(spec: any, morphConfig?: IMorphConfig): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    updateChartConfig(result: IUpdateSpecResult, oldSpec: IChartSpec): void;
+    updateDataSpec(result: IUpdateSpecResult): void;
+    updateRegionSpec(result: IUpdateSpecResult): void;
+    updateComponentSpec(result: IUpdateSpecResult): void;
+    updateSeriesSpec(result: IUpdateSpecResult): void;
+    getCanvas(): HTMLCanvasElement;
+    protected isValidSeries(seriesType: string): boolean;
+    protected _getDefaultSeriesSpec(spec: any): any;
+    private _updateLayoutRect;
+    setCurrentTheme(reInit?: boolean): void;
+    protected setRegionTheme(reInit?: boolean): void;
+    protected setComponentTheme(reInit?: boolean): void;
+    protected setSeriesTheme(reInit?: boolean): void;
+    clear(): void;
+    compile(): void;
+    afterCompile(): void;
+    compileLayout(): void;
+    compileBackground(): void;
+    compileRegions(): void;
+    compileSeries(): void;
+    compileComponents(): void;
+    release(): void;
+    onLayout(srView: IView): void;
+    updateState(state: Record<string, Omit<IMarkStateSpec<unknown>, 'style'>>, filter?: (series: ISeries, mark: IMark, stateKey: string) => boolean): void;
+    setSelected(datum: MaybeArray<any> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier): void;
+    setHovered(datum: MaybeArray<Datum> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier): void;
+    initEvent(): void;
+    protected _enableMarkAnimation(states: string | string[]): void;
+    protected _disableMarkAnimation(states: string | string[]): void;
+    protected _setStateInDatum(stateKey: string, checkReverse: boolean, datum: MaybeArray<Datum> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier): void;
+    setDimensionIndex(value: StringOrNumber, opt: DimensionIndexOption): void;
+    getColorScheme(): import("../theme").IThemeColorScheme;
+}

package/types/chart/box-plot/box-plot.d.ts

@@ -0,0 +1,11 @@
+import { CartesianChart } from '../cartesian/cartesian';
+import type { IBoxPlotChartSpec } from './interface';
+export declare class BoxPlotChart extends CartesianChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _getDefaultSeriesSpec(spec: IBoxPlotChartSpec): any;
+    transformSpec(spec: IBoxPlotChartSpec): void;
+}
+export declare const registerBoxplotChart: () => void;

package/types/chart/box-plot/index.d.ts

@@ -0,0 +1,2 @@
+export * from './box-plot';
+export * from './interface';

package/types/chart/box-plot/interface.d.ts

@@ -0,0 +1,7 @@
+import type { IBoxPlotSeriesSpec } from '../../series/box-plot/interface';
+import type { ICartesianChartSpec } from '../cartesian/interface';
+import type { IChartExtendsSeriesSpec } from '../../typings/spec/common';
+export interface IBoxPlotChartSpec extends ICartesianChartSpec, IChartExtendsSeriesSpec<IBoxPlotSeriesSpec> {
+    type: 'boxPlot';
+    series?: IBoxPlotSeriesSpec[];
+}

package/types/chart/cartesian/cartesian.d.ts

@@ -0,0 +1,8 @@
+import { BaseChart } from '../base-chart';
+export declare class CartesianChart extends BaseChart {
+    readonly seriesType: string;
+    protected isValidSeries(type: string): boolean;
+    protected needAxes(): boolean;
+    protected _getDefaultSeriesSpec(spec: any): any;
+    transformSpec(spec: any): void;
+}

package/types/chart/cartesian/index.d.ts

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

package/types/chart/cartesian/interface.d.ts

@@ -0,0 +1,15 @@
+import type { IChartSpec } from '../../typings/spec/common';
+import type { ICartesianAxisSpec } from '../../component/axis/cartesian/interface';
+import type { ICartesianCrosshairSpec } from '../../component/crosshair/interface';
+import type { IMarkLineSpec } from '../../component/marker/mark-line/interface';
+import type { IMarkAreaSpec } from '../../component/marker/mark-area/interface';
+import type { IMarkPointSpec } from '../../component/marker/mark-point/interface';
+import type { DirectionType } from '../../typings';
+export interface ICartesianChartSpec extends IChartSpec {
+    direction?: DirectionType;
+    axes?: ICartesianAxisSpec[];
+    crosshair?: ICartesianCrosshairSpec | ICartesianCrosshairSpec[];
+    markLine?: IMarkLineSpec | IMarkLineSpec[];
+    markArea?: IMarkAreaSpec | IMarkLineSpec[];
+    markPoint?: IMarkPointSpec | IMarkPointSpec[];
+}

package/types/chart/chart-meta/data.d.ts

@@ -0,0 +1,15 @@
+import type { IData } from './../../typings/spec/common';
+import { DataView } from '@visactor/vdataset';
+import type { DataSet } from '@visactor/vdataset';
+import type { StringOrNumber } from '../../typings';
+export declare class ChartData {
+    protected _dataArr: DataView[];
+    get dataList(): DataView[];
+    protected _onError: (...args: any[]) => void;
+    protected _dataSet: DataSet;
+    constructor(dataSet: DataSet, onError: (...args: any[]) => void);
+    parseData(dataSpec: IData): void;
+    updateData(dataSpec: IData, fullUp?: boolean, forceMerge?: boolean): boolean;
+    private _dataValueForEach;
+    getSeriesData(id: StringOrNumber | undefined, index: number | undefined): DataView | undefined;
+}

package/types/chart/circle-packing/circle-packing.d.ts

@@ -0,0 +1,12 @@
+import type { ICirclePackingSeriesSpec } from '../../series/circle-packing/interface';
+import { BaseChart } from '../base-chart';
+import type { ICirclePackingChartSpec } from './interface';
+export declare class CirclePackingChart extends BaseChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected getDefaultSeriesSpec(spec: ICirclePackingChartSpec): ICirclePackingSeriesSpec;
+    transformSpec(spec: ICirclePackingChartSpec): void;
+}
+export declare const registerCirclePackingChart: () => void;

package/types/chart/circle-packing/index.d.ts

@@ -0,0 +1,2 @@
+export * from './interface';
+export * from './circle-packing';

package/types/chart/circle-packing/interface.d.ts

@@ -0,0 +1,6 @@
+import type { ICirclePackingSeriesSpec } from '../../series/circle-packing/interface';
+import type { IChartExtendsSeriesSpec, IChartSpec } from '../../typings/spec/common';
+export interface ICirclePackingChartSpec extends IChartSpec, IChartExtendsSeriesSpec<ICirclePackingSeriesSpec> {
+    type: 'circlePacking';
+    series?: ICirclePackingSeriesSpec[];
+}

package/types/chart/common/common.d.ts

@@ -0,0 +1,10 @@
+import { BaseChart } from '../base-chart';
+export declare class CommonChart extends BaseChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    protected _canStack: boolean;
+    protected _getDefaultSeriesSpec(spec: any): any;
+    transformSpec(spec: any): void;
+}
+export declare const registerCommonChart: () => void;

package/types/chart/common/index.d.ts

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

package/types/chart/common/interface.d.ts

@@ -0,0 +1,41 @@
+import type { ILineSeriesSpec } from '../../series/line/interface';
+import type { IAreaSeriesSpec } from '../../series/area/interface';
+import type { IChartSpec } from '../../typings/spec/common';
+import type { IBar3dSeriesSpec, IBarSeriesSpec } from '../../series/bar/interface';
+import type { IRangeColumnChartSpec } from '../range-column';
+import type { IRangeAreaChartSpec } from '../range-area';
+import type { IDotSeriesSpec } from '../../series/dot/interface';
+import type { IMapSeriesSpec } from '../../series/map/interface';
+import type { IPie3dSeriesSpec, IPieSeriesSpec } from '../../series/pie/interface';
+import type { ILinkSeriesSpec } from '../../series/link/interface';
+import type { IRadarSeriesSpec } from '../../series/radar/interface';
+import type { IRoseSeriesSpec } from '../../series/rose/interface';
+import type { IScatterSeriesSpec } from '../../series/scatter/interface';
+import type { IWordCloud3dSeriesSpec, IWordCloudSeriesSpec } from '../../series/word-cloud/interface';
+import type { IGaugePointerSeriesSpec, IGaugeSeriesSpec } from '../../series/gauge';
+import type { IBoxPlotSeriesSpec } from '../../series/box-plot/interface';
+import type { ICirclePackingSeriesSpec } from '../../series/circle-packing/interface';
+import type { IFunnelSeriesSpec, IFunnel3dSeriesSpec } from '../../series/funnel/interface';
+import type { IHeatmapSeriesSpec } from '../../series/heatmap/interface';
+import type { ICircularProgressSeriesSpec } from '../../series/progress/circular/interface';
+import type { ILinearProgressSeriesSpec } from '../../series/progress/linear/interface';
+import type { ISankeySeriesSpec } from '../../series/sankey/interface';
+import type { ISunburstSeriesSpec } from '../../series/sunburst/interface';
+import type { ITreemapSeriesSpec } from '../../series/treemap/interface';
+import type { IWaterfallSeriesSpec } from '../../series/waterfall/interface';
+import type { ICorrelationSeriesSpec } from '../../series/correlation/interface';
+import type { ICartesianAxisSpec, IPolarAxisSpec } from '../../component';
+import type { ICartesianCrosshairSpec, IPolarCrosshairSpec } from '../../component/crosshair/interface';
+import type { IMarkLineSpec } from '../../component/marker/mark-line/interface';
+import type { IMarkAreaSpec } from '../../component/marker/mark-area/interface';
+import type { IMarkPointSpec } from '../../component/marker/mark-point/interface';
+export interface ICommonChartSpec extends Omit<IChartSpec, 'series'> {
+    type: 'common';
+    seriesField?: string;
+    series?: (IAreaSeriesSpec | ILineSeriesSpec | IBar3dSeriesSpec | IBarSeriesSpec | IRangeColumnChartSpec | IRangeAreaChartSpec | IDotSeriesSpec | IMapSeriesSpec | IPie3dSeriesSpec | IPieSeriesSpec | ILinkSeriesSpec | IRadarSeriesSpec | IRoseSeriesSpec | IScatterSeriesSpec | ICircularProgressSeriesSpec | ILinearProgressSeriesSpec | IWordCloudSeriesSpec | IWordCloud3dSeriesSpec | IFunnelSeriesSpec | IFunnel3dSeriesSpec | IBoxPlotSeriesSpec | IGaugeSeriesSpec | ISankeySeriesSpec | ITreemapSeriesSpec | ISunburstSeriesSpec | ICirclePackingSeriesSpec | IWaterfallSeriesSpec | IHeatmapSeriesSpec | IGaugePointerSeriesSpec | ICorrelationSeriesSpec)[];
+    axes?: ICartesianAxisSpec[] | IPolarAxisSpec[];
+    crosshair?: ICartesianCrosshairSpec | ICartesianCrosshairSpec[] | IPolarCrosshairSpec | IPolarCrosshairSpec[];
+    markLine?: IMarkLineSpec | IMarkLineSpec[];
+    markArea?: IMarkAreaSpec;
+    markPoint?: IMarkPointSpec;
+}

package/types/chart/correlation/correlation.d.ts

@@ -0,0 +1,11 @@
+import { BaseChart } from '../base-chart';
+import type { ICorrelationChartSpec } from './interface';
+export declare class CorrelationChart extends BaseChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _getDefaultSeriesSpec(spec: ICorrelationChartSpec): any;
+    transformSpec(spec: ICorrelationChartSpec): void;
+}
+export declare const registerCorrelationChart: () => void;

package/types/chart/correlation/index.d.ts

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

package/types/chart/correlation/interface.d.ts

@@ -0,0 +1,6 @@
+import type { ICorrelationSeriesSpec } from '../../series/correlation/interface';
+import type { IChartExtendsSeriesSpec, IChartSpec } from '../../typings/spec/common';
+export interface ICorrelationChartSpec extends Omit<IChartSpec, 'padding'>, IChartExtendsSeriesSpec<ICorrelationSeriesSpec> {
+    type: 'correlation';
+    series?: ICorrelationSeriesSpec[];
+}

package/types/chart/funnel/base.d.ts

@@ -0,0 +1,9 @@
+import type { IFunnelSeriesSpec } from '../../series/funnel/interface';
+import type { IFunnelChartSpec } from './interface';
+import { BaseChart } from '../base-chart';
+export declare class BaseFunnelChart extends BaseChart {
+    seriesType: string;
+    protected needAxes(): boolean;
+    protected _getDefaultSeriesSpec(spec: IFunnelChartSpec): IFunnelSeriesSpec;
+    transformSpec(spec: IFunnelChartSpec): void;
+}

package/types/chart/funnel/funnel-3d.d.ts

@@ -0,0 +1,8 @@
+import { BaseFunnelChart } from './base';
+export declare class Funnel3dChart extends BaseFunnelChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerFunnel3dChart: () => void;

package/types/chart/funnel/funnel.d.ts

@@ -0,0 +1,8 @@
+import { BaseFunnelChart } from './base';
+export declare class FunnelChart extends BaseFunnelChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerFunnelChart: () => void;

package/types/chart/funnel/index.d.ts

@@ -0,0 +1,3 @@
+export * from './funnel';
+export * from './funnel-3d';
+export * from './interface';

package/types/chart/funnel/interface.d.ts

@@ -0,0 +1,9 @@
+import type { IChartExtendsSeriesSpec } from '../..';
+import type { IFunnelSeriesSpec, IFunnel3dSeriesSpec } from '../../series/funnel/interface';
+import type { IChartSpec } from '../../typings/spec';
+export interface IFunnelChartSpec extends IChartSpec, IChartExtendsSeriesSpec<IFunnelSeriesSpec> {
+    type: 'funnel';
+}
+export interface IFunnel3dChartSpec extends IChartSpec, IChartExtendsSeriesSpec<IFunnel3dSeriesSpec> {
+    type: 'funnel3d';
+}

package/types/chart/gauge/gauge.d.ts

@@ -0,0 +1,12 @@
+import { ProgressLikeChart } from '../polar/progress-like';
+export declare class GaugeChart extends ProgressLikeChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _getDefaultSeriesSpec(spec: any): any;
+    protected _getDefaultCircularProgressSeriesSpec(spec: any): any;
+    transformSpec(spec: any): void;
+    protected _transformGaugeAxisSpec(spec: any): void;
+}
+export declare const registerGaugeChart: () => void;

package/types/chart/gauge/index.d.ts

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

package/types/chart/gauge/interface.d.ts

@@ -0,0 +1,10 @@
+import type { IChartSpec } from '../../typings/spec/common';
+import type { IPolarAxisSpec } from '../../component/axis/polar/interface';
+import type { IGaugePointerSeriesSpec, IGaugeSeriesSpec } from '../../series/gauge';
+import type { ILinearAxisSpec } from '../../component/axis/interface';
+import type { ICircularProgressSeriesSpec } from '../../series/progress/circular/interface';
+export interface IGaugeChartSpec extends IChartSpec, Omit<IGaugePointerSeriesSpec, 'data' | 'type' | 'morph'> {
+    type: 'gauge';
+    gauge?: Omit<IGaugeSeriesSpec, 'data'> | Omit<ICircularProgressSeriesSpec, 'data'>;
+    axes?: (IPolarAxisSpec | ILinearAxisSpec)[];
+}

package/types/chart/heatmap/heatmap.d.ts

@@ -0,0 +1,9 @@
+import { CartesianChart } from '../cartesian/cartesian';
+export declare class HeatmapChart extends CartesianChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _getDefaultSeriesSpec(spec: any): any;
+}
+export declare const registerHeatmapChart: () => void;