@visactor/vchart-types 1.7.5 → 1.8.0-beta.0

package/types/animation/config.d.ts

@@ -53,4 +53,8 @@ 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;
+export declare const registerVGrammarCommonAnimation: () => void;
+export declare const registerVGrammarRectAnimation: () => void;
+export declare const registerVGrammarArcAnimation: () => void;
+export declare const registerVGrammarLineOrAreaAnimation: () => void;
+export declare const registerVGrammarPolygonAnimation: () => void;

package/types/animation/utils.d.ts

@@ -10,9 +10,9 @@ export declare function animationConfig<Preset extends string>(defaultConfig?: M
     dataIndex: (datum: any) => number;
     dataCount: () => number;
 }): MarkAnimationSpec;
-export declare function userAnimationConfig<M extends string, Preset extends string>(markName: SeriesMarkNameEnum | string, spec: IAnimationSpec<M, Preset>, ctx: ISeriesMarkAttributeContext): Partial<Record<"none" | "normal" | "state" | "update" | "appear" | "enter" | "exit" | "disappear", boolean | IAnimationConfig | IAnimationConfig[] | IStateAnimateSpec<string>>>;
+export declare function userAnimationConfig<M extends string, Preset extends string>(markName: SeriesMarkNameEnum | string, spec: IAnimationSpec<M, Preset>, ctx: ISeriesMarkAttributeContext): Partial<Record<"none" | "normal" | "state" | "exit" | "update" | "appear" | "enter" | "disappear", boolean | IAnimationConfig | IStateAnimateSpec<string> | IAnimationConfig[]>>;
 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" | "normal" | "state" | "update" | "appear" | "enter" | "exit" | "disappear", boolean | IAnimationConfig | IAnimationConfig[] | IStateAnimateSpec<Preset>>>;
+export declare function uniformAnimationConfig<Preset extends string>(config: Partial<Record<IAnimationState, boolean | IStateAnimateSpec<Preset> | IAnimationConfig | IAnimationConfig[]>>, ctx: ISeriesMarkAttributeContext): Partial<Record<"none" | "normal" | "state" | "exit" | "update" | "appear" | "enter" | "disappear", boolean | IAnimationConfig | IAnimationConfig[] | IStateAnimateSpec<Preset>>>;
 export declare function isAnimationEnabledForSeries(series: ISeries): boolean;

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

@@ -0,0 +1,6 @@
+import { CartesianChartSpecTransformer } from '../cartesian';
+import type { IAreaChartSpec } from './interface';
+export declare class AreaChartSpecTransformer<T extends IAreaChartSpec = IAreaChartSpec> extends CartesianChartSpecTransformer<T> {
+    protected _getDefaultSeriesSpec(spec: T): any;
+    transformSpec(spec: T): void;
+}

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

@@ -1,12 +1,14 @@
-import { CartesianChart } from '../cartesian/cartesian';
 import type { IAreaChartSpec } from './interface';
-export declare class AreaChart extends CartesianChart {
+import { AreaChartSpecTransformer } from './area-transformer';
+import { BaseChart } from '../base';
+export declare class AreaChart<T extends IAreaChartSpec = IAreaChartSpec> extends BaseChart<T> {
     static readonly type: string;
+    static readonly seriesType: string;
     static readonly view: string;
+    static readonly transformerConstructor: typeof AreaChartSpecTransformer;
+    readonly transformerConstructor: typeof AreaChartSpecTransformer;
     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

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

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

@@ -0,0 +1,6 @@
+import type { AdaptiveSpec } from '../../../typings';
+import type { IBar3dChartSpec } from '../interface';
+import { BarChartSpecTransformer } from '../bar-transformer';
+export declare class Bar3dChartSpecTransformer<T extends IBar3dChartSpec = IBar3dChartSpec> extends BarChartSpecTransformer<AdaptiveSpec<T, 'type' | 'series'>> {
+    protected _getDefaultSeriesSpec(spec: AdaptiveSpec<T, 'type' | 'series'>): any;
+}

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

@@ -0,0 +1,14 @@
+import type { IBar3dChartSpec } from '../interface';
+import { BarChart } from '../bar';
+import type { AdaptiveSpec } from '../../../typings';
+import { Bar3dChartSpecTransformer } from './bar-3d-transformer';
+export declare class Bar3dChart<T extends IBar3dChartSpec = IBar3dChartSpec> extends BarChart<AdaptiveSpec<T, 'type' | 'series'>> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof Bar3dChartSpecTransformer;
+    readonly transformerConstructor: typeof Bar3dChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerBar3dChart: () => void;

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

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

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

@@ -0,0 +1,6 @@
+import { CartesianChartSpecTransformer } from '../cartesian';
+import type { IBarChartSpec } from './interface';
+export declare class BarChartSpecTransformer<T extends IBarChartSpec = IBarChartSpec> extends CartesianChartSpecTransformer<T> {
+    protected _getDefaultSeriesSpec(spec: T): any;
+    transformSpec(spec: T): void;
+}

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

@@ -1,11 +1,14 @@
-import { CartesianChart } from '../cartesian/cartesian';
-export declare class BarChart extends CartesianChart {
+import type { IBarChartSpec } from './interface';
+import { BarChartSpecTransformer } from './bar-transformer';
+import { BaseChart } from '../base';
+export declare class BarChart<T extends IBarChartSpec = IBarChartSpec> extends BaseChart<T> {
     static readonly type: string;
+    static readonly seriesType: string;
     static readonly view: string;
+    static readonly transformerConstructor: typeof BarChartSpecTransformer;
+    readonly transformerConstructor: typeof BarChartSpecTransformer;
     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

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

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

@@ -0,0 +1,21 @@
+import type { IChartSpec } from '../../typings';
+import type { IChartSpecInfo, IChartSpecTransformer, IChartSpecTransformerOption } from '../interface';
+import type { IModelConstructor, IModelSpecInfo } from '../../model/interface';
+import type { IRegionConstructor } from '../../region/interface';
+import type { ISeriesConstructor } from '../../series';
+import type { IComponentConstructor } from '../../component/interface/common';
+export declare class BaseChartSpecTransformer<T extends IChartSpec> implements IChartSpecTransformer {
+    readonly type: string;
+    readonly seriesType: string;
+    protected _option: IChartSpecTransformerOption;
+    constructor(option: IChartSpecTransformerOption);
+    initChartSpec(chartSpec: T): IChartSpecInfo;
+    transformSpec(chartSpec: T): void;
+    transformModelSpec(chartSpec: T): IChartSpecInfo;
+    createSpecInfo(chartSpec: T, transform?: (constructor: IModelConstructor, specInfo: IModelSpecInfo, chartSpecInfo?: IChartSpecInfo) => void): IChartSpecInfo;
+    protected _isValidSeries(seriesType: string): boolean;
+    protected _getDefaultSeriesSpec(chartSpec: any): any;
+    forEachRegionInSpec<K>(chartSpec: T, callbackfn: (constructor: IRegionConstructor, specInfo: IModelSpecInfo, chartSpecInfo?: IChartSpecInfo) => K, chartSpecInfo?: IChartSpecInfo): K[];
+    forEachSeriesInSpec<K>(chartSpec: T, callbackfn: (constructor: ISeriesConstructor, specInfo: IModelSpecInfo, chartSpecInfo?: IChartSpecInfo) => K, chartSpecInfo?: IChartSpecInfo): K[];
+    forEachComponentInSpec<K>(chartSpec: T, callbackfn: (constructor: IComponentConstructor, specInfo: IModelSpecInfo, chartSpecInfo?: IChartSpecInfo) => K, chartSpecInfo?: IChartSpecInfo): K[];
+}

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

@@ -0,0 +1,148 @@
+import type { IRegionConstructor } from '../../region/interface';
+import { ChartData } from '../chart-meta/data';
+import type { Datum, IMarkStateSpec, IRegionQuerier, MaybeArray, IPadding, IRect, StringOrNumber, IChartSpec, IDataValues, ILayoutRect, ILayoutOrientPadding } from '../../typings';
+import type { ILayoutItem, LayoutCallBack } from '../../layout/interface';
+import type { ILayoutModelState, IModel, IModelOption, IModelSpecInfo, IUpdateSpecResult } from '../../model/interface';
+import type { IChart, IChartLayoutOption, IChartRenderOption, IChartOption, IChartEvaluateOption, ILayoutParams, DimensionIndexOption, IChartSpecTransformerOption, IChartSpecTransformer } from '../interface';
+import type { ISeries, ISeriesConstructor } from '../../series/interface';
+import type { IRegion } from '../../region/interface';
+import type { IComponent, IComponentConstructor } 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<T extends IChartSpec> extends CompilableBase implements IChart {
+    readonly type: string;
+    readonly seriesType: string;
+    readonly transformerConstructor: new (option: IChartSpecTransformerOption) => IChartSpecTransformer;
+    readonly id: number;
+    protected _transformer: IChartSpecTransformer;
+    protected _spec: T;
+    getSpec(): T;
+    setSpec(s: T): 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: T, option: IChartOption);
+    created(): void;
+    init(): void;
+    reDataFlow(): void;
+    onResize(width: number, height: number, reRender?: boolean): void;
+    updateViewBox(viewBox: IBoundsLike, reLayout: boolean): void;
+    private _createBackground;
+    protected _createRegion(constructor: IRegionConstructor, specInfo: IModelSpecInfo): void;
+    protected _createSeries(constructor: ISeriesConstructor, specInfo: IModelSpecInfo): void;
+    getAllSeries: () => ISeries[];
+    getSeriesById(id: number): ISeries | undefined;
+    protected _createComponent(constructor: IComponentConstructor, specInfo: IModelSpecInfo): void;
+    getAllComponents(): IComponent[];
+    getAllModels(): IModel[];
+    getModelInFilter(filter: string | {
+        type: string;
+        index: number;
+    } | ((model: IModel) => boolean)): IModel;
+    private _createLayout;
+    setLayout(layout: LayoutCallBack): void;
+    private _initLayoutFunc;
+    layout(params: ILayoutParams): void;
+    onLayoutStart(option: IChartLayoutOption): void;
+    onLayoutEnd(option: IChartLayoutOption): void;
+    onEvaluateEnd(option: IChartEvaluateOption): void;
+    getLayoutElements(): ILayoutItem[];
+    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;
+    private _createGlobalScale;
+    updateGlobalScaleDomain(): void;
+    updateGlobalScale(result: IUpdateSpecResult): void;
+    updateGlobalScaleTheme(): void;
+    updateSpec(spec: T): {
+        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;
+    private _updateLayoutRect;
+    setCurrentTheme(): 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;
+    private _initEvent;
+    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("../..").IThemeColorScheme;
+}

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

@@ -0,0 +1,2 @@
+export * from './base-chart';
+export * from './base-chart-transformer';

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

@@ -0,0 +1,6 @@
+import { CartesianChartSpecTransformer } from '../cartesian';
+import type { IBoxPlotChartSpec } from './interface';
+export declare class BoxPlotChartSpecTransformer<T extends IBoxPlotChartSpec = IBoxPlotChartSpec> extends CartesianChartSpecTransformer<T> {
+    protected _getDefaultSeriesSpec(spec: T): any;
+    transformSpec(spec: T): void;
+}

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

@@ -1,11 +1,13 @@
-import { CartesianChart } from '../cartesian/cartesian';
 import type { IBoxPlotChartSpec } from './interface';
-export declare class BoxPlotChart extends CartesianChart {
+import { BoxPlotChartSpecTransformer } from './box-plot-transformer';
+import { BaseChart } from '../base';
+export declare class BoxPlotChart<T extends IBoxPlotChartSpec = IBoxPlotChartSpec> extends BaseChart<T> {
     static readonly type: string;
+    static readonly seriesType: string;
     static readonly view: string;
+    static readonly transformerConstructor: typeof BoxPlotChartSpecTransformer;
+    readonly transformerConstructor: typeof BoxPlotChartSpecTransformer;
     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

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

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

@@ -0,0 +1,8 @@
+import { BaseChartSpecTransformer } from '../base';
+import type { ICartesianChartSpec } from './interface';
+export declare class CartesianChartSpecTransformer<T extends ICartesianChartSpec> extends BaseChartSpecTransformer<T> {
+    protected needAxes(): boolean;
+    protected _isValidSeries(type: string): boolean;
+    protected _getDefaultSeriesSpec(spec: any): any;
+    transformSpec(spec: T): void;
+}

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

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

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

@@ -0,0 +1,7 @@
+import type { ICirclePackingSeriesSpec } from '../../series/circle-packing/interface';
+import { BaseChartSpecTransformer } from '../base';
+import type { ICirclePackingChartSpec } from './interface';
+export declare class CirclePackingChartSpecTransformer<T extends ICirclePackingChartSpec = ICirclePackingChartSpec> extends BaseChartSpecTransformer<T> {
+    protected _getDefaultSeriesSpec(spec: ICirclePackingChartSpec): ICirclePackingSeriesSpec;
+    transformSpec(spec: T): void;
+}

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

@@ -1,12 +1,13 @@
-import type { ICirclePackingSeriesSpec } from '../../series/circle-packing/interface';
-import { BaseChart } from '../base-chart';
+import { BaseChart } from '../base/base-chart';
 import type { ICirclePackingChartSpec } from './interface';
-export declare class CirclePackingChart extends BaseChart {
+import { CirclePackingChartSpecTransformer } from './circle-packing-transformer';
+export declare class CirclePackingChart<T extends ICirclePackingChartSpec = ICirclePackingChartSpec> extends BaseChart<T> {
     static readonly type: string;
+    static readonly seriesType: string;
     static readonly view: string;
+    static readonly transformerConstructor: typeof CirclePackingChartSpecTransformer;
+    readonly transformerConstructor: typeof CirclePackingChartSpecTransformer;
     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

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

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

@@ -0,0 +1,7 @@
+import type { AdaptiveSpec } from '../../typings';
+import { BaseChartSpecTransformer } from '../base';
+import type { ICommonChartSpec } from './interface';
+export declare class CommonChartSpecTransformer<T extends ICommonChartSpec = ICommonChartSpec> extends BaseChartSpecTransformer<AdaptiveSpec<T, 'series'>> {
+    protected _getDefaultSeriesSpec(spec: AdaptiveSpec<T, 'series'>): any;
+    transformSpec(spec: AdaptiveSpec<T, 'series'>): void;
+}

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

@@ -1,10 +1,13 @@
-import { BaseChart } from '../base-chart';
-export declare class CommonChart extends BaseChart {
+import { BaseChart } from '../base/base-chart';
+import type { ICommonChartSpec } from './interface';
+import type { AdaptiveSpec } from '../../typings';
+import { CommonChartSpecTransformer } from './common-transformer';
+export declare class CommonChart<T extends ICommonChartSpec = ICommonChartSpec> extends BaseChart<AdaptiveSpec<T, 'series'>> {
     static readonly type: string;
     static readonly view: string;
+    static readonly transformerConstructor: typeof CommonChartSpecTransformer;
+    readonly transformerConstructor: typeof CommonChartSpecTransformer;
     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

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

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

@@ -0,0 +1,6 @@
+import { BaseChartSpecTransformer } from '../base';
+import type { ICorrelationChartSpec } from './interface';
+export declare class CorrelationChartSpecTransformer<T extends ICorrelationChartSpec = ICorrelationChartSpec> extends BaseChartSpecTransformer<T> {
+    protected _getDefaultSeriesSpec(spec: T): any;
+    transformSpec(spec: T): void;
+}

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

@@ -1,11 +1,13 @@
-import { BaseChart } from '../base-chart';
+import { BaseChart } from '../base/base-chart';
 import type { ICorrelationChartSpec } from './interface';
-export declare class CorrelationChart extends BaseChart {
+import { CorrelationChartSpecTransformer } from './correlation-transformer';
+export declare class CorrelationChart<T extends ICorrelationChartSpec = ICorrelationChartSpec> extends BaseChart<T> {
     static readonly type: string;
+    static readonly seriesType: string;
     static readonly view: string;
+    static readonly transformerConstructor: typeof CorrelationChartSpecTransformer;
+    readonly transformerConstructor: typeof CorrelationChartSpecTransformer;
     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

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

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

@@ -0,0 +1,14 @@
+import type { IFunnel3dChartSpec } from '../interface';
+import type { AdaptiveSpec } from '../../../typings';
+import { FunnelChartSpecTransformer } from '../funnel-transformer';
+import { BaseChart } from '../../base';
+export declare class Funnel3dChart<T extends IFunnel3dChartSpec = IFunnel3dChartSpec> extends BaseChart<AdaptiveSpec<T, 'type'>> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof FunnelChartSpecTransformer;
+    readonly transformerConstructor: typeof FunnelChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerFunnel3dChart: () => void;

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

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

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

@@ -0,0 +1,8 @@
+import type { IFunnelSeriesSpec } from '../../series';
+import { BaseChartSpecTransformer } from '../base';
+import type { IFunnelChartSpec } from './interface';
+export declare class FunnelChartSpecTransformer<T extends IFunnelChartSpec> extends BaseChartSpecTransformer<T> {
+    protected needAxes(): boolean;
+    protected _getDefaultSeriesSpec(spec: T): IFunnelSeriesSpec;
+    transformSpec(spec: T): void;
+}

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

@@ -1,7 +1,12 @@
-import { BaseFunnelChart } from './base';
-export declare class FunnelChart extends BaseFunnelChart {
+import type { IFunnelChartSpec } from './interface';
+import { FunnelChartSpecTransformer } from './funnel-transformer';
+import { BaseChart } from '../base';
+export declare class FunnelChart<T extends IFunnelChartSpec = IFunnelChartSpec> extends BaseChart<T> {
     static readonly type: string;
+    static readonly seriesType: string;
     static readonly view: string;
+    static readonly transformerConstructor: typeof FunnelChartSpecTransformer;
+    readonly transformerConstructor: typeof FunnelChartSpecTransformer;
     readonly type: string;
     readonly seriesType: string;
 }

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

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

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

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

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

@@ -0,0 +1,9 @@
+import type { AdaptiveSpec } from '../../typings';
+import { ProgressLikeChartSpecTransformer } from '../polar';
+import type { IGaugeChartSpec } from './interface';
+export declare class GaugeChartSpecTransformer<T extends IGaugeChartSpec = IGaugeChartSpec> extends ProgressLikeChartSpecTransformer<AdaptiveSpec<T, 'axes'>> {
+    protected _getDefaultSeriesSpec(spec: T): any;
+    protected _getDefaultCircularProgressSeriesSpec(spec: T): any;
+    transformSpec(spec: AdaptiveSpec<T, 'axes'>): void;
+    protected _transformGaugeAxisSpec(spec: AdaptiveSpec<T, 'axes'>): void;
+}

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

@@ -1,12 +1,14 @@
-import { ProgressLikeChart } from '../polar/progress-like';
-export declare class GaugeChart extends ProgressLikeChart {
+import type { IGaugeChartSpec } from './interface';
+import { GaugeChartSpecTransformer } from './gauge-transformer';
+import type { AdaptiveSpec } from '../../typings';
+import { BaseChart } from '../base';
+export declare class GaugeChart<T extends IGaugeChartSpec = IGaugeChartSpec> extends BaseChart<AdaptiveSpec<T, 'axes'>> {
     static readonly type: string;
+    static readonly seriesType: string;
     static readonly view: string;
+    static readonly transformerConstructor: typeof GaugeChartSpecTransformer;
+    readonly transformerConstructor: typeof GaugeChartSpecTransformer;
     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

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

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

@@ -1,9 +1,9 @@
-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'> {
+import type { IPolarChartSpec } from '../polar';
+export interface IGaugeChartSpec extends Omit<IPolarChartSpec, 'axes'>, Omit<IGaugePointerSeriesSpec, 'data' | 'type' | 'morph'> {
     type: 'gauge';
     gauge?: Omit<IGaugeSeriesSpec, 'data'> | Omit<ICircularProgressSeriesSpec, 'data'>;
     axes?: (IPolarAxisSpec | ILinearAxisSpec)[];

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

@@ -0,0 +1,5 @@
+import { CartesianChartSpecTransformer } from '../cartesian';
+import type { IHeatmapChartSpec } from './interface';
+export declare class HeatmapChartSpecTransformer<T extends IHeatmapChartSpec = IHeatmapChartSpec> extends CartesianChartSpecTransformer<T> {
+    protected _getDefaultSeriesSpec(spec: T): any;
+}

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

@@ -1,9 +1,13 @@
-import { CartesianChart } from '../cartesian/cartesian';
-export declare class HeatmapChart extends CartesianChart {
+import type { IHeatmapChartSpec } from './interface';
+import { HeatmapChartSpecTransformer } from './heatmap-transformer';
+import { BaseChart } from '../base';
+export declare class HeatmapChart<T extends IHeatmapChartSpec = IHeatmapChartSpec> extends BaseChart<T> {
     static readonly type: string;
+    static readonly seriesType: string;
     static readonly view: string;
+    static readonly transformerConstructor: typeof HeatmapChartSpecTransformer;
+    readonly transformerConstructor: typeof HeatmapChartSpecTransformer;
     readonly type: string;
     readonly seriesType: string;
-    protected _getDefaultSeriesSpec(spec: any): any;
 }
 export declare const registerHeatmapChart: () => void;

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

@@ -1,2 +1,3 @@
 export * from './heatmap';
 export * from './interface';
+export * from './heatmap-transformer';

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

@@ -0,0 +1,14 @@
+import { BaseHistogramChart } from '../base/base';
+import type { IHistogram3dChartSpec } from '../interface';
+import type { AdaptiveSpec } from '../../../typings';
+import { HistogramChartSpecTransformer } from '../histogram-transformer';
+export declare class Histogram3dChart<T extends IHistogram3dChartSpec> extends BaseHistogramChart<AdaptiveSpec<T, 'type'>> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof HistogramChartSpecTransformer;
+    readonly transformerConstructor: typeof HistogramChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerHistogram3dChart: () => void;

package/types/chart/histogram/3d/index.d.ts

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

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

@@ -0,0 +1,8 @@
+import { BaseChart } from '../../base';
+import type { IHistogramChartSpec } from '../interface';
+import { BaseHistogramChartSpecTransformer } from './histogram-base-transformer';
+export declare class BaseHistogramChart<T extends IHistogramChartSpec> extends BaseChart<T> {
+    static readonly transformerConstructor: typeof BaseHistogramChartSpecTransformer;
+    readonly transformerConstructor: typeof BaseHistogramChartSpecTransformer;
+    protected _canStack: boolean;
+}