@visactor/vchart-types 1.15.5-alpha.8 → 2.0.0-alpha.1

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

@@ -1,12 +0,0 @@
-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/animation-planner.d.ts

@@ -0,0 +1,13 @@
+import type { IMarkGraphic } from '../mark/interface';
+import type { IAnimationConfig } from './interface';
+import type { IGroup } from '@visactor/vrender-core';
+export declare class AnimationPlanner {
+    state: string;
+    graphics: IMarkGraphic[];
+    private config;
+    private beforeExecute?;
+    private afterExecute?;
+    constructor(state: string, graphics: IMarkGraphic[], config: IAnimationConfig[], beforeExecute?: (graphics: IMarkGraphic[]) => void, afterExecute?: (graphics: IMarkGraphic[]) => void);
+    execute(product?: IGroup, onComplete?: () => void): void;
+    executeOnGroup(product: IGroup, onComplete?: () => void): void;
+}

package/types/animation/config.d.ts

@@ -58,8 +58,8 @@ export declare const registerFadeInOutAnimation: () => void;
 export declare const registerCartesianGroupClipAnimation: () => void;
 export declare const registerLineAnimation: () => void;
 export declare const registerAreaAnimation: () => 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;
+export declare const registerBuiltInAnimation: () => void;
+export declare const registerRectAnimation: () => void;
+export declare const registerArcAnimation: () => void;
+export declare const registerLineOrAreaAnimation: () => void;
+export declare const registerPolygonAnimation: () => void;

package/types/animation/grammar-dector.d.ts

@@ -0,0 +1,22 @@
+import { AnimationPlanner } from './animation-planner';
+import type { IMarkGraphic } from '../mark/interface';
+import type { IAnimationConfig, IAnimationSplitStrategy } from './interface';
+import type { BaseMark } from '../mark';
+export interface IDetectionResult {
+    hasExit: boolean;
+    hasUpdate: boolean;
+    hasEnter: boolean;
+    hasAppear: boolean;
+    exitGraphics: IMarkGraphic[];
+    updateGraphics: IMarkGraphic[];
+    enterGraphics: IMarkGraphic[];
+    appearGraphics: IMarkGraphic[];
+}
+export declare class GrammarDetector {
+    private mark;
+    private splitStrategies;
+    constructor(mark: BaseMark<any>);
+    registerStrategy(strategy: IAnimationSplitStrategy): void;
+    detect(graphics: IMarkGraphic[], graphicMap: Map<string, IMarkGraphic>): IDetectionResult;
+    createPlanners(result: IDetectionResult, animationConfig: Record<string, IAnimationConfig[]>): AnimationPlanner[];
+}

package/types/animation/index.d.ts

@@ -0,0 +1,7 @@
+export { registerAnimate as registerVRenderAnimate, registerCustomAnimate } from '@visactor/vrender-animate';
+export { registerStateTransition } from './state-transition';
+export { registerSequentialAnimate } from './sequential-animate';
+export { registerPolygonAnimation, registerRectAnimation, registerArcAnimation, DEFAULT_ANIMATION_CONFIG } from './config';
+export { animationConfig, userAnimationConfig, shouldMarkDoMorph } from './utils';
+export type { IAnimationSpec } from './spec';
+export type { IAnimationTypeConfig, IAnimationConfig } from './interface';

package/types/animation/interface.d.ts

@@ -1,5 +1,7 @@
-export type { MarkAnimationSpec } from '@visactor/vgrammar-core';
-import type { ICompilable } from '../compile/interface';
+import type { ACustomAnimate } from '@visactor/vrender-animate';
+import type { IGraphic, EasingType } from '@visactor/vrender-core';
+import type { IMark, IMarkGraphic } from '../mark/interface/common';
+import type { BaseMark } from '../mark';
 export declare enum AnimationStateEnum {
     appear = "appear",
     disappear = "disappear",
@@ -16,14 +18,103 @@ export interface IAnimateState {
         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;
 }
+export interface IAnimationParameters {
+    width: number;
+    height: number;
+    mark: IMark;
+    group: IMark | null;
+    elementIndex: number;
+    elementCount: number;
+    view: any;
+}
+export type IAnimationChannelInterpolator = (ratio: number, from: any, to: any, nextAttributes: any, datum: any, g: IGraphic, parameters: IAnimationParameters) => boolean | void;
+export type GraphicFunctionCallback<T> = (datum: any, g: IGraphic, params: any) => T;
+export type GraphicFunctionValueType<T> = GraphicFunctionCallback<T> | T;
+export interface IStateAnimationConfig {
+    duration?: number;
+    easing?: EasingType;
+}
+export interface IAnimationControlOptions {
+    stopWhenStateChange?: boolean;
+    immediatelyApply?: boolean;
+    ignoreLoopFinalAttributes?: boolean;
+}
+export interface CommonAnimationConfigItem {
+    custom?: IAnimationChannelInterpolator | IAnimationCustomConstructor;
+    customParameters?: GraphicFunctionValueType<any>;
+    easing?: EasingType;
+    duration?: GraphicFunctionValueType<number>;
+    delay?: GraphicFunctionValueType<number>;
+    delayAfter?: GraphicFunctionValueType<number>;
+    oneByOne?: GraphicFunctionValueType<boolean | number>;
+    startTime?: GraphicFunctionValueType<number>;
+    totalTime?: GraphicFunctionValueType<number>;
+    loop?: boolean | number;
+    options?: GraphicFunctionValueType<any>;
+    controlOptions?: IAnimationControlOptions;
+}
+export interface TypeAnimationConfig extends CommonAnimationConfigItem {
+    type: string;
+}
+export type IAnimationChannelFunction = (datum: any, g: IGraphic, mark: IMark) => any;
+export type IAnimationChannelAttrs = Record<string, {
+    from?: any | IAnimationChannelFunction;
+    to?: any | IAnimationChannelFunction;
+}>;
+export interface ChannelAnimationConfig extends CommonAnimationConfigItem {
+    channel: IAnimationChannelAttrs | string[];
+}
+export type IAnimationTypeConfig = TypeAnimationConfig | ChannelAnimationConfig | CommonAnimationConfigItem;
+export interface IAnimationCustomConstructor {
+    new (from: any, to: any, duration: number, ease: EasingType, parameters?: any): ACustomAnimate<any>;
+}
+export type IAnimationEffect = {
+    type?: string;
+    channel?: IAnimationChannelAttrs | string[];
+    custom?: IAnimationChannelInterpolator | IAnimationCustomConstructor;
+    customParameters?: GraphicFunctionValueType<any>;
+    easing?: EasingType;
+    options?: GraphicFunctionValueType<any>;
+};
+export interface IAnimationTimeSlice {
+    effects: IAnimationEffect | IAnimationEffect[];
+    duration?: GraphicFunctionValueType<number>;
+    delay?: GraphicFunctionValueType<number>;
+    delayAfter?: GraphicFunctionValueType<number>;
+}
+export interface IAnimationTimeline {
+    id?: string;
+    timeSlices: IAnimationTimeSlice | IAnimationTimeSlice[];
+    startTime?: GraphicFunctionValueType<number>;
+    totalTime?: GraphicFunctionValueType<number>;
+    oneByOne?: GraphicFunctionValueType<number | boolean>;
+    loop?: GraphicFunctionValueType<number | boolean>;
+    partitioner?: GraphicFunctionCallback<boolean>;
+    sort?: (datumA: any, datumB: any, graphicA: IGraphic, graphicB: IGraphic) => number;
+    controlOptions?: IAnimationControlOptions;
+}
+export type IAnimationConfig = IAnimationTimeline | IAnimationTypeConfig;
+export interface MarkAnimationSpec {
+    disappear?: IAnimationConfig | IAnimationConfig[];
+    appear?: IAnimationConfig | IAnimationConfig[];
+    enter?: IAnimationConfig | IAnimationConfig[];
+    exit?: IAnimationConfig | IAnimationConfig[];
+    update?: IAnimationConfig | IAnimationConfig[];
+    normal?: IAnimationConfig | IAnimationConfig[];
+    state?: IStateAnimationConfig;
+}
+export type MarkAnimationType = keyof MarkAnimationSpec;
+export interface IAnimationSplitStrategy {
+    name: string;
+    shouldApply: (mark: BaseMark<any>, graphic: IMarkGraphic) => boolean;
+    split: (mark: BaseMark<any>, graphic: IMarkGraphic) => Array<{
+        attrs: Record<string, any>;
+        order: number;
+    }>;
+}

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

@@ -0,0 +1 @@
+export declare function registerSequentialAnimate(): void;

package/types/animation/spec.d.ts

@@ -1,6 +1,5 @@
-import type { IAnimationConfig, IStateAnimationConfig } from '@visactor/vgrammar-core';
-import type { EasingType } from '@visactor/vrender-core';
-export type { IRunningConfig as IMorphConfig, IMorphAnimationConfig } from '@visactor/vgrammar-core';
+import type { EasingType, IGraphic } from '@visactor/vrender-core';
+import type { IAnimationConfig, IStateAnimationConfig } from './interface';
 export interface ICommonStateAnimateSpec {
     duration?: number;
     delay?: number;
@@ -25,3 +24,28 @@ export interface IMorphSeriesSpec {
     morphKey?: string;
     morphElementKey?: string;
 }
+export type MorphData = {
+    prev: any[];
+    next: any[];
+};
+export type MorphElements = {
+    prev: IGraphic[];
+    next: IGraphic[];
+};
+export type MorphFunctionCallback<T> = (datum: MorphData, element: MorphElements, parameters: any) => T;
+export type MorphFunctionType<T> = T | MorphFunctionCallback<T>;
+export type MorphFunctionValueType<T> = MorphFunctionType<T> | T;
+export interface IMorphAnimationConfig {
+    easing?: EasingType;
+    delay?: MorphFunctionValueType<number>;
+    duration?: MorphFunctionValueType<number>;
+    oneByOne?: MorphFunctionValueType<boolean | number>;
+    splitPath?: MorphFunctionValueType<'clone' | null | undefined>;
+}
+export interface IMorphConfig {
+    reuse?: boolean;
+    morph?: boolean;
+    morphAll?: boolean;
+    animation?: IMorphAnimationConfig;
+    enableExitAnimation?: boolean;
+}

package/types/animation/state-transition.d.ts

@@ -0,0 +1 @@
+export declare function registerStateTransition(): void;

package/types/animation/strategy/common.d.ts

@@ -0,0 +1,17 @@
+import type { IMarkGraphic } from '../../mark/interface';
+import type { BaseMark } from '../../mark';
+import type { IAnimationSplitStrategy } from '../interface';
+export declare class CustomSplitStrategy implements IAnimationSplitStrategy {
+    name: string;
+    private checkFn;
+    private splitFn;
+    constructor(name: string, checkFn: (mark: BaseMark<any>, graphic: IMarkGraphic) => boolean, splitFn: (mark: BaseMark<any>, graphic: IMarkGraphic) => Array<{
+        attrs: Record<string, any>;
+        order: number;
+    }>);
+    shouldApply(mark: BaseMark<any>, graphic: IMarkGraphic): boolean;
+    split(mark: BaseMark<any>, graphic: IMarkGraphic): Array<{
+        attrs: Record<string, any>;
+        order: number;
+    }>;
+}

package/types/animation/strategy/horizontal-bar-split.d.ts

@@ -0,0 +1,11 @@
+import type { IMarkGraphic } from '../../mark/interface';
+import type { BaseMark } from '../../mark';
+import type { IAnimationSplitStrategy } from '../interface';
+export declare class HorizontalBarSplitStrategy implements IAnimationSplitStrategy {
+    name: string;
+    shouldApply(mark: BaseMark<any>, graphic: IMarkGraphic): boolean;
+    split(mark: BaseMark<any>, graphic: IMarkGraphic): Array<{
+        attrs: Record<string, any>;
+        order: number;
+    }>;
+}

package/types/animation/strategy/vertical-bar-split.d.ts

@@ -0,0 +1,11 @@
+import type { IMarkGraphic } from '../../mark/interface';
+import type { BaseMark } from '../../mark';
+import type { IAnimationSplitStrategy } from '../interface';
+export declare class VerticalBarSplitStrategy implements IAnimationSplitStrategy {
+    name: string;
+    shouldApply(mark: BaseMark<any>, graphic: IMarkGraphic): boolean;
+    split(mark: BaseMark<any>, graphic: IMarkGraphic): Array<{
+        attrs: Record<string, any>;
+        order: number;
+    }>;
+}

package/types/animation/utils.d.ts

@@ -1,5 +1,4 @@
-import type { IAnimationConfig } from '@visactor/vgrammar-core';
-import type { MarkAnimationSpec, IAnimationState } from './interface';
+import type { MarkAnimationSpec, IAnimationState, IAnimationConfig } from './interface';
 import type { IStateAnimateSpec, IAnimationSpec } from './spec';
 import type { SeriesMarkNameEnum } from '../series/interface/type';
 import type { ISeries } from '../series';
@@ -10,9 +9,9 @@ export declare function animationConfig<Preset extends string>(defaultConfig?: M
     dataIndex: (datum: any, params: any) => number;
     dataCount: () => number;
 }): MarkAnimationSpec;
-export declare function userAnimationConfig<M extends string, Preset extends string>(markName: SeriesMarkNameEnum | string, spec: IAnimationSpec<M, Preset>, ctx: IModelMarkAttributeContext): Partial<Record<"none" | "normal" | "state" | "enter" | "exit" | "update" | "appear" | "disappear", boolean | IAnimationConfig | IAnimationConfig[] | IStateAnimateSpec<Preset>>>;
+export declare function userAnimationConfig<M extends string, Preset extends string>(markName: SeriesMarkNameEnum | string, spec: IAnimationSpec<M, Preset>, ctx: IModelMarkAttributeContext): Partial<Record<"none" | "normal" | "state" | "update" | "appear" | "enter" | "exit" | "disappear", boolean | IAnimationConfig | IAnimationConfig[] | IStateAnimateSpec<Preset>>>;
 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: IModelMarkAttributeContext): Partial<Record<"none" | "normal" | "state" | "enter" | "exit" | "update" | "appear" | "disappear", boolean | IAnimationConfig | IAnimationConfig[] | IStateAnimateSpec<Preset>>>;
+export declare function uniformAnimationConfig<Preset extends string>(config: Partial<Record<IAnimationState, boolean | IStateAnimateSpec<Preset> | IAnimationConfig | IAnimationConfig[]>>, ctx: IModelMarkAttributeContext): Partial<Record<"none" | "normal" | "state" | "update" | "appear" | "enter" | "exit" | "disappear", boolean | IAnimationConfig | IAnimationConfig[] | IStateAnimateSpec<Preset>>>;
 export declare function isAnimationEnabledForSeries(series: ISeries): boolean;

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

@@ -8,5 +8,6 @@ export declare class AreaChart<T extends IAreaChartSpec = IAreaChartSpec> extend
     readonly transformerConstructor: typeof AreaChartSpecTransformer;
     readonly type: string;
     readonly seriesType: string;
+    protected _setModelOption(): void;
 }
 export declare const registerAreaChart: () => void;

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

@@ -8,5 +8,6 @@ export declare class BarChart<T extends IBarChartSpec = IBarChartSpec> extends B
     readonly transformerConstructor: typeof BarChartSpecTransformer;
     readonly type: string;
     readonly seriesType: string;
+    protected _setModelOption(): void;
 }
 export declare const registerBarChart: () => void;

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

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

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

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

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

@@ -3,19 +3,20 @@ 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 { IChart, IChartRenderOption, IChartOption, IChartEvaluateOption, 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, IRectMark } from '../../mark/interface';
+import type { IMark, IMarkGraphic, IRectMark } from '../../mark/interface';
 import type { IEvent } from '../../event/interface';
 import type { DataView } from '@visactor/vdataset';
 import type { DataSet } from '@visactor/vdataset';
 import type { IParserOptions } from '@visactor/vdataset';
 import type { IBoundsLike, Maybe } 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 { IMorphConfig } from '../../animation/spec';
+import type { IInteraction } from '../../interaction/interface/common';
 export declare class BaseChart<T extends IChartSpec> extends CompilableBase implements IChart {
     readonly type: string;
     readonly seriesType: string;
@@ -37,7 +38,9 @@ export declare class BaseChart<T extends IChartSpec> extends CompilableBase impl
     protected _layoutTag: boolean;
     getLayoutTag(): boolean;
     setLayoutTag(tag: boolean, morphConfig?: IMorphConfig, renderNextTick?: boolean): boolean;
+    resetLayoutItemTag(): void;
     protected _modelOption: IModelOption;
+    getModelOption(): IModelOption;
     protected _globalScale: IGlobalScale;
     getGlobalScale(): IGlobalScale;
     protected _idMap: Map<number, IModel | IMark>;
@@ -52,8 +55,11 @@ export declare class BaseChart<T extends IChartSpec> extends CompilableBase impl
     protected _paddingSpec: ILayoutOrientPadding;
     protected _canvasRect: ILayoutRect;
     protected _backgroundMark: IRectMark;
+    protected _interaction: IInteraction;
+    protected _setModelOption(): void;
     constructor(spec: T, option: IChartOption);
     created(transformer: Maybe<IChartSpecTransformer>): void;
+    _initInteractions(): void;
     init(): void;
     reDataFlow(): void;
     onResize(width: number, height: number, reRender?: boolean): void;
@@ -73,9 +79,9 @@ export declare class BaseChart<T extends IChartSpec> extends CompilableBase impl
     private _createLayout;
     setLayout(layout: LayoutCallBack): void;
     private _initLayoutFunc;
-    layout(params: ILayoutParams): void;
-    onLayoutStart(option: IChartLayoutOption): void;
-    onLayoutEnd(option: IChartLayoutOption): void;
+    layout(): void;
+    onLayoutStart(): void;
+    onLayoutEnd(): void;
     onEvaluateEnd(option: IChartEvaluateOption): void;
     getLayoutElements(): ILayoutItem[];
     getRegionsInIndex: (index?: number[]) => IRegion[];
@@ -135,7 +141,7 @@ export declare class BaseChart<T extends IChartSpec> extends CompilableBase impl
     compileSeries(): void;
     compileComponents(): void;
     release(): void;
-    onLayout(srView: IView): void;
+    onLayout(): 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;
@@ -146,7 +152,14 @@ export declare class BaseChart<T extends IChartSpec> extends CompilableBase impl
     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;
+    filterGraphicsByDatum(datum: MaybeArray<Datum> | null, opt?: {
+        filter?: (series: ISeries, mark: IMark) => boolean;
+        region?: IRegionQuerier;
+        getDatum?: (el: IMarkGraphic, mark: IMark, s: ISeries, r: IRegion) => Datum;
+        callback?: (el: IMarkGraphic, mark: IMark, s: ISeries, r: IRegion) => void;
+        regionCallback?: (pickElements: IMarkGraphic[], r: IRegion) => void;
+    }): IMarkGraphic[];
+    protected _setStateInDatum(stateKey: string, d: MaybeArray<Datum> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier): void;
     setDimensionIndex(value: StringOrNumber, opt: DimensionIndexOption): void;
-    getColorScheme(): import("../..").IThemeColorScheme;
+    getColorScheme(): any;
 }

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

@@ -8,5 +8,6 @@ export declare class BoxPlotChart<T extends IBoxPlotChartSpec = IBoxPlotChartSpe
     readonly transformerConstructor: typeof BoxPlotChartSpecTransformer;
     readonly type: string;
     readonly seriesType: string;
+    protected _setModelOption(): void;
 }
 export declare const registerBoxplotChart: () => void;

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

@@ -7,5 +7,6 @@ export declare class CommonChart<T extends ICommonChartSpec = ICommonChartSpec>
     static readonly transformerConstructor: typeof CommonChartSpecTransformer;
     readonly transformerConstructor: typeof CommonChartSpecTransformer;
     readonly type: string;
+    protected _setModelOption(): void;
 }
 export declare const registerCommonChart: () => void;

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

@@ -1,21 +1,21 @@
 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 { IBarSeriesSpec } from '../../series/bar/interface';
 import type { IRangeColumnChartSpec } from '../range-column/interface';
 import type { IRangeAreaChartSpec } from '../range-area/interface';
 import type { IDotSeriesSpec } from '../../series/dot/interface';
 import type { IMapSeriesSpec } from '../../series/map/interface';
-import type { IPie3dSeriesSpec, IPieSeriesSpec } from '../../series/pie/interface';
+import type { 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 { IWordCloudSeriesSpec } from '../../series/word-cloud/interface';
 import type { IGaugePointerSeriesSpec, IGaugeSeriesSpec } from '../../series/gauge/interface';
 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 { IFunnelSeriesSpec } 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';
@@ -33,7 +33,7 @@ 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)[];
+    series?: (IAreaSeriesSpec | ILineSeriesSpec | IBarSeriesSpec | IRangeColumnChartSpec | IRangeAreaChartSpec | IDotSeriesSpec | IMapSeriesSpec | IPieSeriesSpec | ILinkSeriesSpec | IRadarSeriesSpec | IRoseSeriesSpec | IScatterSeriesSpec | ICircularProgressSeriesSpec | ILinearProgressSeriesSpec | IWordCloudSeriesSpec | IFunnelSeriesSpec | IBoxPlotSeriesSpec | IGaugeSeriesSpec | ISankeySeriesSpec | ITreemapSeriesSpec | ISunburstSeriesSpec | ICirclePackingSeriesSpec | IWaterfallSeriesSpec | IHeatmapSeriesSpec | IGaugePointerSeriesSpec | ICorrelationSeriesSpec)[];
     axes?: ICartesianAxisSpec[] | IPolarAxisSpec[];
     crosshair?: ICartesianCrosshairSpec | ICartesianCrosshairSpec[] | IPolarCrosshairSpec | IPolarCrosshairSpec[];
     markLine?: IMarkLineSpec | IMarkLineSpec[];

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

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

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

@@ -1,9 +1,6 @@
 import type { IChartExtendsSeriesSpec } from '../../typings';
-import type { IFunnelSeriesSpec, IFunnel3dSeriesSpec } from '../../series/funnel/interface';
+import type { IFunnelSeriesSpec } 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/funnel/util.d.ts

@@ -0,0 +1,2 @@
+import type { IMark } from '../../mark/interface';
+export declare const modifyOuterLabels: (marks: IMark[]) => void;

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

@@ -8,5 +8,6 @@ export declare class HistogramChart<T extends IHistogramChartSpec = IHistogramCh
     readonly transformerConstructor: typeof HistogramChartSpecTransformer;
     readonly type: string;
     readonly seriesType: string;
+    protected _setModelOption(): void;
 }
 export declare const registerHistogramChart: () => void;

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

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

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

@@ -1,9 +1,6 @@
-import type { IBarSeriesSpec, IBar3dSeriesSpec } from '../../series/bar/interface';
+import type { IBarSeriesSpec } from '../../series/bar/interface';
 import type { IChartExtendsSeriesSpec } from '../../typings';
 import type { ICartesianChartSpec } from '../cartesian/interface';
 export interface IHistogramChartSpec extends ICartesianChartSpec, Omit<IChartExtendsSeriesSpec<IBarSeriesSpec>, 'type'> {
     type: 'histogram';
 }
-export interface IHistogram3dChartSpec extends ICartesianChartSpec, Omit<IChartExtendsSeriesSpec<IBar3dSeriesSpec>, 'type'> {
-    type: 'histogram3d';
-}

package/types/chart/index.d.ts

@@ -1,27 +1,27 @@
 import type { IAreaChartSpec } from './area';
 import { AreaChart, registerAreaChart } from './area';
-import type { IBarChartSpec, IBar3dChartSpec } from './bar';
-import { BarChart, Bar3dChart, registerBarChart, registerBar3dChart } from './bar';
+import type { IBarChartSpec } from './bar';
+import { BarChart, registerBarChart, BarChartSpecTransformer } from './bar';
 import type { IBoxPlotChartSpec } from './box-plot';
 import { BoxPlotChart, registerBoxplotChart } from './box-plot';
 import type { ICirclePackingChartSpec } from './circle-packing';
 import { CirclePackingChart, registerCirclePackingChart } from './circle-packing';
 import type { ICommonChartSpec } from './common';
 import { CommonChart, registerCommonChart } from './common';
-import type { IFunnelChartSpec, IFunnel3dChartSpec } from './funnel';
-import { FunnelChart, Funnel3dChart, registerFunnelChart, registerFunnel3dChart } from './funnel';
+import type { IFunnelChartSpec } from './funnel';
+import { FunnelChart, registerFunnelChart, FunnelChartSpecTransformer } from './funnel';
 import type { IGaugeChartSpec } from './gauge';
 import { GaugeChart, registerGaugeChart } from './gauge';
 import type { IHeatmapChartSpec } from './heatmap';
 import { HeatmapChart, registerHeatmapChart } from './heatmap';
-import type { IHistogramChartSpec, IHistogram3dChartSpec } from './histogram';
-import { HistogramChart, Histogram3dChart, registerHistogramChart, registerHistogram3dChart } from './histogram';
+import type { IHistogramChartSpec } from './histogram';
+import { HistogramChartSpecTransformer, HistogramChart, registerHistogramChart } from './histogram';
 import type { ILineChartSpec } from './line';
 import { LineChart, registerLineChart } from './line';
 import type { IMapChartSpec } from './map';
 import { MapChart, registerMapChart } from './map';
-import type { IPieChartSpec, IPie3dChartSpec } from './pie';
-import { PieChart, Pie3dChart, registerPieChart, registerPie3dChart } from './pie';
+import type { IPieChartSpec } from './pie';
+import { BasePieChart, BasePieChartSpecTransformer, PieChart, registerPieChart } from './pie';
 import type { ICircularProgressChartSpec } from './progress/circular';
 import { CircularProgressChart, registerCircularProgressChart } from './progress/circular';
 import type { ILinearProgressChartSpec } from './progress/linear';
@@ -30,8 +30,8 @@ import type { IRadarChartSpec } from './radar';
 import { RadarChart, registerRadarChart } from './radar';
 import type { IRangeAreaChartSpec } from './range-area';
 import { RangeAreaChart, registerRangeAreaChart } from './range-area';
-import type { IRangeColumnChartSpec, IRangeColumn3dChartSpec } from './range-column';
-import { RangeColumnChart, RangeColumn3dChart, registerRangeColumnChart, registerRangeColumn3dChart } from './range-column';
+import type { IRangeColumnChartSpec } from './range-column';
+import { RangeColumnChart, registerRangeColumnChart } from './range-column';
 import type { IRoseChartSpec } from './rose';
 import { RoseChart, registerRoseChart } from './rose';
 import type { ISankeyChartSpec } from './sankey';
@@ -50,8 +50,8 @@ import type { ICorrelationChartSpec } from './correlation';
 import { CorrelationChart, registerCorrelationChart } from './correlation';
 import type { ILiquidChartSpec } from './liquid';
 import { LiquidChart, registerLiquidChart } from './liquid';
-import type { IWordCloudChartSpec, IWordCloud3dChartSpec } from './word-cloud';
-import { WordCloudChart, WordCloud3dChart, registerWordCloudChart, registerWordCloudShapeChart, registerWordCloud3dChart } from './word-cloud';
+import type { IWordCloudChartSpec } from './word-cloud';
+import { WordCloudChart, registerWordCloudChart, registerWordCloudShapeChart } from './word-cloud';
 import { BaseChart } from './base/base-chart';
 import type { ICartesianChartSpec } from './cartesian';
 import type { IPolarChartSpec } from './polar';
@@ -59,8 +59,10 @@ import type { IVennChartSpec } from './venn';
 import { VennChart, registerVennChart } from './venn';
 import type { IMosaicChartSpec } from './mosaic';
 import { MosaicChart, registerMosaicChart } from './mosaic';
-import { IPictogramChartSpec } from './pictogram/interface';
-import { PictogramChart, registerPictogramChart } from './pictogram/pictogram';
-export { AreaChart, BarChart, Bar3dChart, BoxPlotChart, CirclePackingChart, CommonChart, FunnelChart, Funnel3dChart, GaugeChart, HeatmapChart, HistogramChart, Histogram3dChart, LineChart, MapChart, PieChart, Pie3dChart, CircularProgressChart, LinearProgressChart, RadarChart, RangeColumnChart, RangeColumn3dChart, RangeAreaChart, RoseChart, SankeyChart, ScatterChart, SunburstChart, SequenceChart, WaterfallChart, CorrelationChart, LiquidChart, WordCloudChart, WordCloud3dChart, TreemapChart, VennChart, BaseChart, MosaicChart, PictogramChart };
-export { registerLineChart, registerAreaChart, registerBarChart, registerBar3dChart, registerBoxplotChart, registerCirclePackingChart, registerCircularProgressChart, registerCommonChart, registerFunnelChart, registerFunnel3dChart, registerGaugeChart, registerHeatmapChart, registerHistogramChart, registerHistogram3dChart, registerLinearProgressChart, registerMapChart, registerPie3dChart, registerPieChart, registerRadarChart, registerRangeAreaChart, registerRangeColumn3dChart, registerRangeColumnChart, registerRoseChart, registerSankeyChart, registerScatterChart, registerSequenceChart, registerSunburstChart, registerTreemapChart, registerWaterfallChart, registerWordCloud3dChart, registerWordCloudChart, registerCorrelationChart, registerLiquidChart, registerWordCloudShapeChart, registerVennChart, registerMosaicChart, registerPictogramChart };
-export type { IAreaChartSpec, IBarChartSpec, IBar3dChartSpec, IBoxPlotChartSpec, ICirclePackingChartSpec, ICommonChartSpec, IFunnelChartSpec, IFunnel3dChartSpec, IGaugeChartSpec, IHeatmapChartSpec, IHistogramChartSpec, IHistogram3dChartSpec, ILineChartSpec, IMapChartSpec, IPieChartSpec, IPie3dChartSpec, ICircularProgressChartSpec, ILinearProgressChartSpec, IRadarChartSpec, IRangeColumnChartSpec, IRangeColumn3dChartSpec, IRangeAreaChartSpec, IRoseChartSpec, IScatterChartSpec, ISankeyChartSpec, ISequenceChartSpec, ISunburstChartSpec, ITreemapChartSpec, IWaterfallChartSpec, ICorrelationChartSpec, ILiquidChartSpec, IWordCloud3dChartSpec, IWordCloudChartSpec, IPolarChartSpec, ICartesianChartSpec, IVennChartSpec, IMosaicChartSpec, IPictogramChartSpec };
+import type { IChart } from './interface/chart';
+import { BaseWordCloudChart } from './word-cloud/base/base';
+import { BaseWordCloudChartSpecTransformer } from './word-cloud/base/word-cloud-base-transformer';
+import { BaseHistogramChart } from './histogram/base/base';
+export { AreaChart, BarChart, BarChartSpecTransformer, BoxPlotChart, CirclePackingChart, CommonChart, FunnelChartSpecTransformer, FunnelChart, GaugeChart, HeatmapChart, HistogramChartSpecTransformer, BaseHistogramChart, HistogramChart, LineChart, MapChart, BasePieChartSpecTransformer, BasePieChart, PieChart, CircularProgressChart, LinearProgressChart, RadarChart, RangeColumnChart, RangeAreaChart, RoseChart, SankeyChart, ScatterChart, SunburstChart, SequenceChart, WaterfallChart, CorrelationChart, LiquidChart, BaseWordCloudChartSpecTransformer, BaseWordCloudChart, WordCloudChart, TreemapChart, VennChart, BaseChart, MosaicChart };
+export { registerLineChart, registerAreaChart, registerBarChart, registerBoxplotChart, registerCirclePackingChart, registerCircularProgressChart, registerCommonChart, registerFunnelChart, registerGaugeChart, registerHeatmapChart, registerHistogramChart, registerLinearProgressChart, registerMapChart, registerPieChart, registerRadarChart, registerRangeAreaChart, registerRangeColumnChart, registerRoseChart, registerSankeyChart, registerScatterChart, registerSequenceChart, registerSunburstChart, registerTreemapChart, registerWaterfallChart, registerWordCloudChart, registerCorrelationChart, registerLiquidChart, registerWordCloudShapeChart, registerVennChart, registerMosaicChart };
+export type { IChart, IAreaChartSpec, IBarChartSpec, IBoxPlotChartSpec, ICirclePackingChartSpec, ICommonChartSpec, IFunnelChartSpec, IGaugeChartSpec, IHeatmapChartSpec, IHistogramChartSpec, ILineChartSpec, IMapChartSpec, IPieChartSpec, ICircularProgressChartSpec, ILinearProgressChartSpec, IRadarChartSpec, IRangeColumnChartSpec, IRangeAreaChartSpec, IRoseChartSpec, IScatterChartSpec, ISankeyChartSpec, ISequenceChartSpec, ISunburstChartSpec, ITreemapChartSpec, IWaterfallChartSpec, ICorrelationChartSpec, ILiquidChartSpec, IWordCloudChartSpec, IPolarChartSpec, ICartesianChartSpec, IVennChartSpec, IMosaicChartSpec };