@visactor/vchart-types 2.0.0-alpha.0 → 2.0.0-alpha.1

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

@@ -1,10 +0,0 @@
-import { StateManager } from '../compile/state-manager';
-import type { IAnimate, IAnimateState } from './interface';
-import { AnimationStateEnum } from './interface';
-import type { StateValueMap } from '../compile/interface/compilable-item';
-export declare class AnimateManager extends StateManager implements IAnimate {
-    protected _stateMap: IAnimateState & StateValueMap;
-    readonly id: number;
-    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,6 +1,7 @@
-import type { ACustomAnimate, EasingType, IGraphic } from '@visactor/vrender-core';
-import type { ICompilable } from '../compile/interface';
-import type { IMark } from '../mark/interface/common';
+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",
@@ -17,10 +18,6 @@ export interface IAnimateState {
         callback: (datum: any, element: any) => AnimationStateEnum;
     };
 }
-export interface IAnimate extends ICompilable {
-    id: number;
-    updateAnimateState: (state: AnimationStateEnum, noRender?: boolean) => void;
-}
 export interface ICartesianGroupAnimationParams {
     direction: () => 'x' | 'y';
     orient: () => 'positive' | 'negative';
@@ -104,6 +101,7 @@ export interface IAnimationTimeline {
 }
 export type IAnimationConfig = IAnimationTimeline | IAnimationTypeConfig;
 export interface MarkAnimationSpec {
+    disappear?: IAnimationConfig | IAnimationConfig[];
     appear?: IAnimationConfig | IAnimationConfig[];
     enter?: IAnimationConfig | IAnimationConfig[];
     exit?: IAnimationConfig | IAnimationConfig[];
@@ -111,3 +109,12 @@ export interface MarkAnimationSpec {
     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/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

@@ -9,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" | "update" | "exit" | "disappear" | "appear", 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" | "update" | "exit" | "disappear" | "appear", 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

@@ -7,7 +7,7 @@ import type { IChart, IChartRenderOption, IChartOption, IChartEvaluateOption, Di
 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';
@@ -38,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>;
@@ -54,6 +56,7 @@ export declare class BaseChart<T extends IChartSpec> extends CompilableBase impl
     protected _canvasRect: ILayoutRect;
     protected _backgroundMark: IRectMark;
     protected _interaction: IInteraction;
+    protected _setModelOption(): void;
     constructor(spec: T, option: IChartOption);
     created(transformer: Maybe<IChartSpecTransformer>): void;
     _initInteractions(): void;
@@ -149,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;
+    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/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 };

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

@@ -3,7 +3,7 @@ import type { LayoutCallBack } from '../../layout/interface';
 import type { IParserOptions } from '@visactor/vdataset';
 import type { IComponent, IComponentConstructor } from '../../component/interface';
 import type { IMark } from '../../mark/interface';
-import type { IModel, IModelConstructor, IModelSpecInfo, IUpdateSpecResult } from '../../model/interface';
+import type { IModel, IModelConstructor, IModelOption, IModelSpecInfo, IUpdateSpecResult } from '../../model/interface';
 import type { IRegion, IRegionConstructor } from '../../region/interface';
 import type { ISeries, ISeriesConstructor } from '../../series/interface';
 import type { IChartEvaluateOption, IChartLayoutOption, IChartOption, IChartRenderOption, IChartSpecInfo, IChartSpecTransformerOption } from './common';
@@ -13,6 +13,7 @@ import type { IRegionQuerier, MaybeArray, Datum, IMarkStateSpec, StringOrNumber,
 import type { DataView } from '@visactor/vdataset';
 import type { IGlobalScale } from '../../scale/interface';
 import type { IMorphConfig } from '../../animation/spec';
+import type { IMarkGraphic } from '../../mark/interface/common';
 export type DimensionIndexOption = {
     filter?: (cmp: IComponent) => boolean;
     tooltip?: boolean;
@@ -36,12 +37,14 @@ export interface IChart extends ICompilable {
     getCanvasRect: () => ILayoutRect;
     getViewRect: () => ILayoutRect;
     getOption: () => IChartOption;
+    getModelOption: () => IModelOption;
     getEvent: () => IEvent;
     getGlobalScale: () => IGlobalScale;
     setLayout: (layout: LayoutCallBack) => void;
     layout: () => void;
     getLayoutTag: () => boolean;
     setLayoutTag: (tag: boolean, morphConfig?: IMorphConfig, renderNextTick?: boolean) => boolean;
+    resetLayoutItemTag: () => void;
     updateData: (id: StringOrNumber, data: unknown, updateGlobalScale?: boolean, options?: IParserOptions) => void;
     updateFullData: (data: IDataValues | IDataValues[]) => void;
     updateGlobalScaleDomain: () => void;
@@ -92,6 +95,13 @@ export interface IChart extends ICompilable {
     setCurrentTheme: () => void;
     getSeriesData: (id: StringOrNumber | undefined, index: number | undefined) => DataView | undefined;
     setDimensionIndex: (value: StringOrNumber, opt: DimensionIndexOption) => 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[];
 }
 export interface IChartSpecTransformer {
     readonly type: string;

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

@@ -4,15 +4,11 @@ export declare const enum ChartTypeEnum {
     area = "area",
     line = "line",
     bar = "bar",
-    bar3d = "bar3d",
     histogram = "histogram",
-    histogram3d = "histogram3d",
     rangeColumn = "rangeColumn",
-    rangeColumn3d = "rangeColumn3d",
     rangeArea = "rangeArea",
     map = "map",
     pie = "pie",
-    pie3d = "pie3d",
     radar = "radar",
     rose = "rose",
     scatter = "scatter",
@@ -20,9 +16,7 @@ export declare const enum ChartTypeEnum {
     circularProgress = "circularProgress",
     linearProgress = "linearProgress",
     wordCloud = "wordCloud",
-    wordCloud3d = "wordCloud3d",
     funnel = "funnel",
-    funnel3d = "funnel3d",
     waterfall = "waterfall",
     boxPlot = "boxPlot",
     gauge = "gauge",
@@ -34,6 +28,5 @@ export declare const enum ChartTypeEnum {
     correlation = "correlation",
     liquid = "liquid",
     venn = "venn",
-    mosaic = "mosaic",
-    pictogram = "pictogram"
+    mosaic = "mosaic"
 }

package/types/chart/line/line.d.ts

@@ -8,5 +8,6 @@ export declare class LineChart<T extends ILineChartSpec> extends BaseChart<T> {
     readonly transformerConstructor: typeof LineChartSpecTransformer;
     readonly type: string;
     readonly seriesType: string;
+    protected _setModelOption(): void;
 }
 export declare const registerLineChart: () => void;

package/types/chart/mosaic/mosaic.d.ts

@@ -17,5 +17,6 @@ export declare class MosaicChart<T extends IMosaicChartSpec = IMosaicChartSpec>
     handleAfterStackRegion: (region: IRegion, stackValueGroup: {
         [key: string]: IStackCacheRoot;
     }) => void;
+    protected _setModelOption(): void;
 }
 export declare const registerMosaicChart: () => void;

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

@@ -1,4 +1,4 @@
-import { IPictogramSeriesSpec } from '../../series/pictogram/interface';
+import type { IPictogramSeriesSpec } from '../../series/pictogram/interface';
 import type { IChartExtendsSeriesSpec, IChartSpec } from '../../typings/spec/common';
 export interface IPictogramChartSpec extends IChartSpec, IChartExtendsSeriesSpec<any> {
     type: 'pictogram';

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

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

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

@@ -1,11 +1,7 @@
-import type { IPieSeriesSpec, IPie3dSeriesSpec } from '../../series/pie/interface';
+import type { IPieSeriesSpec } from '../../series/pie/interface';
 import type { IIndicatorSpec } from '../../component/indicator/interface';
 import type { IChartExtendsSeriesSpec, IChartSpec } from '../../typings/spec/common';
 export interface IPieChartSpec extends IChartSpec, IChartExtendsSeriesSpec<IPieSeriesSpec> {
     type: 'pie';
     indicator?: IIndicatorSpec | IIndicatorSpec[];
 }
-export interface IPie3dChartSpec extends IChartSpec, IChartExtendsSeriesSpec<IPie3dSeriesSpec> {
-    type: 'pie3d';
-    indicator?: IIndicatorSpec | IIndicatorSpec[];
-}

package/types/chart/progress/circular/circular.d.ts

@@ -9,5 +9,6 @@ export declare class CircularProgressChart<T extends ICircularProgressChartSpec
     readonly transformerConstructor: typeof CircularProgressChartSpecTransformer;
     readonly type: string;
     readonly seriesType: string;
+    protected _setModelOption(): void;
 }
 export declare const registerCircularProgressChart: () => void;

package/types/chart/progress/linear/linear.d.ts

@@ -8,5 +8,6 @@ export declare class LinearProgressChart<T extends ILinearProgressChartSpec = IL
     readonly transformerConstructor: typeof LinearProgressChartSpecTransformer;
     readonly type: string;
     readonly seriesType: string;
+    protected _setModelOption(): void;
 }
 export declare const registerLinearProgressChart: () => void;

package/types/chart/radar/radar.d.ts

@@ -8,5 +8,6 @@ export declare class RadarChart<T extends IRoseChartSpec = IRoseChartSpec> exten
     readonly transformerConstructor: typeof RadarChartSpecTransformer;
     readonly type: string;
     readonly seriesType: string;
+    protected _setModelOption(): void;
 }
 export declare const registerRadarChart: () => void;

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

@@ -8,5 +8,6 @@ export declare class RangeAreaChart<T extends IRangeAreaChartSpec = IRangeAreaCh
     readonly transformerConstructor: typeof RangeAreaChartSpecTransformer;
     readonly type: string;
     readonly seriesType: string;
+    protected _setModelOption(): void;
 }
 export declare const registerRangeAreaChart: () => void;

package/types/chart/range-column/index.d.ts

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