@visactor/vchart-types 1.11.0-alpha.2 → 1.11.0

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: IModelMarkAttributeContext): Partial<Record<"none" | "normal" | "state" | "exit" | "update" | "appear" | "enter" | "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" | "appear" | "enter" | "exit" | "disappear" | "update", 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" | "exit" | "update" | "appear" | "enter" | "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" | "appear" | "enter" | "exit" | "disappear" | "update", boolean | IAnimationConfig | IAnimationConfig[] | IStateAnimateSpec<Preset>>>;
 export declare function isAnimationEnabledForSeries(series: ISeries): boolean;

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

@@ -39,9 +39,10 @@ export declare class BaseChart<T extends IChartSpec> extends CompilableBase impl
     protected _viewBox: IBoundsLike;
     protected _layoutTag: boolean;
     getLayoutTag(): boolean;
-    setLayoutTag(tag: boolean, morphConfig?: IMorphConfig, reLayout?: boolean): boolean;
+    setLayoutTag(tag: boolean, morphConfig?: IMorphConfig, renderNextTick?: boolean): boolean;
     protected _modelOption: IModelOption;
     protected _globalScale: IGlobalScale;
+    getGlobalScale(): IGlobalScale;
     protected _idMap: Map<number, IModel | IMark>;
     protected _event: IEvent;
     getEvent(): IEvent;
@@ -120,13 +121,14 @@ export declare class BaseChart<T extends IChartSpec> extends CompilableBase impl
         reCompile: boolean;
     };
     updateChartConfig(result: IUpdateSpecResult, oldSpec: IChartSpec): void;
-    updateDataSpec(result: IUpdateSpecResult): void;
+    updateDataSpec(): void;
     updateRegionSpec(result: IUpdateSpecResult): void;
     updateComponentSpec(result: IUpdateSpecResult): void;
     updateSeriesSpec(result: IUpdateSpecResult): void;
     getCanvas(): HTMLCanvasElement;
     private _updateLayoutRect;
     setCurrentTheme(): void;
+    reInit(): void;
     clear(): void;
     compile(): void;
     afterCompile(): void;
@@ -140,6 +142,9 @@ export declare class BaseChart<T extends IChartSpec> extends CompilableBase impl
     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;
+    clearState(state: string): void;
+    clearSelected(): void;
+    clearHovered(): void;
     private _initEvent;
     protected _enableMarkAnimation(states: string | string[]): void;
     protected _disableMarkAnimation(states: string | string[]): void;

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

@@ -36,6 +36,6 @@ export interface ICommonChartSpec extends Omit<IChartSpec, 'series'> {
     axes?: ICartesianAxisSpec[] | IPolarAxisSpec[];
     crosshair?: ICartesianCrosshairSpec | ICartesianCrosshairSpec[] | IPolarCrosshairSpec | IPolarCrosshairSpec[];
     markLine?: IMarkLineSpec | IMarkLineSpec[];
-    markArea?: IMarkAreaSpec;
-    markPoint?: IMarkPointSpec;
+    markArea?: IMarkAreaSpec | IMarkAreaSpec[];
+    markPoint?: IMarkPointSpec | IMarkPointSpec[];
 }

package/types/chart/index.d.ts

@@ -51,10 +51,12 @@ 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, registerWordCloud3dChart } from './word-cloud';
+import { WordCloudChart, WordCloud3dChart, registerWordCloudChart, registerWordCloudShapeChart, registerWordCloud3dChart } from './word-cloud';
 import { BaseChart } from './base/base-chart';
 import type { ICartesianChartSpec } from './cartesian';
 import type { IPolarChartSpec } from './polar';
-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, BaseChart };
-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 };
-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 };
+import type { IVennChartSpec } from './venn';
+import { VennChart, registerVennChart } from './venn';
+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 };
+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 };
+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 };

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

@@ -12,6 +12,8 @@ import type { IBoundsLike, IPadding } from '@visactor/vutils';
 import type { ICompilable } from '../../compile/interface';
 import type { IRegionQuerier, MaybeArray, Datum, IMarkStateSpec, StringOrNumber, IShowTooltipOption, IDataValues, ILayoutRect, IData } from '../../typings';
 import type { DataView } from '@visactor/vdataset';
+import type { IGlobalScale } from '../../scale/interface';
+import type { IMorphConfig } from '../../animation/spec';
 export type DimensionIndexOption = {
     filter?: (cmp: IComponent) => boolean;
     tooltip?: boolean;
@@ -33,12 +35,14 @@ export interface IChart extends ICompilable {
     reDataFlow: () => void;
     setCanvasRect: (width: number, height: number) => void;
     getCanvasRect: () => ILayoutRect;
+    getViewRect: () => ILayoutRect;
     getOption: () => IChartOption;
     getEvent: () => IEvent;
+    getGlobalScale: () => IGlobalScale;
     setLayout: (layout: LayoutCallBack) => void;
     layout: (context: ILayoutParams) => void;
     getLayoutTag: () => boolean;
-    setLayoutTag: (tag: boolean) => boolean;
+    setLayoutTag: (tag: boolean, morphConfig?: IMorphConfig, renderNextTick?: boolean) => boolean;
     updateData: (id: StringOrNumber, data: unknown, updateGlobalScale?: boolean, options?: IParserOptions) => void;
     updateFullData: (data: IDataValues | IDataValues[]) => void;
     updateGlobalScaleDomain: () => void;
@@ -50,6 +54,7 @@ export interface IChart extends ICompilable {
     onRender: (ctx: IChartRenderOption) => void;
     onResize: (width: number, height: number, reRender: boolean) => void;
     onLayout: (view: IView) => void;
+    reInit: () => void;
     getAllSeries: () => ISeries[];
     getRegionsInIndex: (index?: number[]) => IRegion[];
     getRegionsInIds: (ids: number[]) => IRegion[];
@@ -78,6 +83,9 @@ export interface IChart extends ICompilable {
     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;
+    clearState: (state: string) => void;
+    clearSelected: () => void;
+    clearHovered: () => void;
     updateViewBox: (viewBox: IBoundsLike, reLayout: boolean) => void;
     getCanvas: () => HTMLCanvasElement | undefined;
     setCurrentTheme: () => void;

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

@@ -32,5 +32,6 @@ export declare const enum ChartTypeEnum {
     circlePacking = "circlePacking",
     heatmap = "heatmap",
     correlation = "correlation",
-    liquid = "liquid"
+    liquid = "liquid",
+    venn = "venn"
 }

package/types/chart/sankey/sankey.d.ts

@@ -1,6 +1,10 @@
 import { BaseChart } from '../base/base-chart';
 import type { ISankeyChartSpec } from './interface';
 import { SankeyChartSpecTransformer } from './sankey-transformer';
+import type { Datum, MaybeArray } from '../../typings/common';
+import type { ISeries } from '../../series/interface';
+import type { IMark } from '../../mark/interface/common';
+import type { IRegionQuerier } from '../../typings/params';
 export declare class SankeyChart<T extends ISankeyChartSpec = ISankeyChartSpec> extends BaseChart<T> {
     static readonly type: string;
     static readonly seriesType: string;
@@ -9,5 +13,6 @@ export declare class SankeyChart<T extends ISankeyChartSpec = ISankeyChartSpec>
     readonly transformerConstructor: typeof SankeyChartSpecTransformer;
     readonly type: string;
     readonly seriesType: string;
+    protected _setStateInDatum(stateKey: string, checkReverse: boolean, datum: MaybeArray<Datum> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier): void;
 }
 export declare const registerSankeyChart: () => void;

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

@@ -0,0 +1,3 @@
+export * from './interface';
+export * from './venn';
+export * from './venn-transformer';

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

@@ -0,0 +1,6 @@
+import type { IVennSeriesSpec } from '../../series/venn/interface';
+import type { IChartSpec } from '../../typings/spec/common';
+export interface IVennChartSpec extends Omit<IChartSpec, 'data' | 'series'>, IVennSeriesSpec {
+    type: 'venn';
+    series?: IVennSeriesSpec[];
+}

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

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

package/types/chart/venn/venn.d.ts

@@ -0,0 +1,14 @@
+import { BaseChart } from '../base/base-chart';
+import type { IVennChartSpec } from './interface';
+import type { AdaptiveSpec } from '../../typings';
+import { VennChartSpecTransformer } from './venn-transformer';
+export declare class VennChart<T extends IVennChartSpec = IVennChartSpec> extends BaseChart<AdaptiveSpec<T, 'data' | 'series'>> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof VennChartSpecTransformer;
+    readonly transformerConstructor: typeof VennChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerVennChart: () => void;

package/types/compile/compiler.d.ts

@@ -3,9 +3,9 @@ import type { CompilerListenerParameters, CompilerModel, IGrammarItem, IRenderCo
 import type { IBoundsLike } from '@visactor/vutils';
 import type { EventSourceType } from '../event/interface';
 import type { IChart } from '../chart/interface';
-import { VChart } from '../core/vchart';
 import type { IColor, Stage } from '@visactor/vrender-core';
 import type { IMorphConfig } from '../animation/spec';
+import type { IVChart } from '../core/interface';
 type EventListener = {
     type: string;
     callback: (...args: any[]) => void;
@@ -40,11 +40,11 @@ export declare class Compiler {
     compileInteractions(): void;
     compile(ctx: {
         chart: IChart;
-        vChart: VChart;
+        vChart: IVChart;
     }, option: any): void;
     clear(ctx: {
         chart: IChart;
-        vChart: VChart;
+        vChart: IVChart;
     }, removeGraphicItems?: boolean): void;
     renderNextTick(morphConfig?: IMorphConfig): void;
     render(morphConfig?: IMorphConfig): void;

package/types/compile/interface/compiler.d.ts

@@ -36,6 +36,7 @@ export interface IRenderOption {
     enableHtmlAttribute?: boolean;
     supportsTouchEvents?: boolean;
     supportsPointerEvents?: boolean;
+    ReactDOM?: any;
 }
 export type CompilerListenerParameters = {
     type: EventType;

package/types/compile/mark/compilable-mark.d.ts

@@ -1,4 +1,4 @@
-import type { IGroupMark, IMark, MarkAnimationSpec, MarkFunctionCallback, Nil, TransformSpec } from '@visactor/vgrammar-core';
+import type { IElement, IGroupMark, IMark, MarkAnimationSpec, MarkFunctionCallback, Nil, TransformSpec } from '@visactor/vgrammar-core';
 import type { DataView } from '@visactor/vdataset';
 import { GrammarItem } from '../grammar-item';
 import type { Maybe, Datum, StringOrNumber } from '../../typings';
@@ -115,5 +115,6 @@ export declare abstract class CompilableMark extends GrammarItem implements ICom
     stopAnimationByState(state?: string): import("@visactor/vgrammar-core").IAnimate;
     pauseAnimationByState(state?: string): import("@visactor/vgrammar-core").IAnimate;
     resumeAnimationByState(state?: string): import("@visactor/vgrammar-core").IAnimate;
+    getProductElements(): IElement[];
     release(): void;
 }

package/types/compile/mark/interface.d.ts

@@ -66,6 +66,7 @@ export interface ICompilableMark extends IGrammarItem {
     setClip: (clip: MarkClip) => void;
     compile: (option?: IMarkCompileOption) => void;
     getProduct: () => Maybe<IMark>;
+    getProductElements: () => Maybe<IMark['elements']>;
     getMarks: () => ICompilableMark[];
     setSkipBeforeLayouted: (skip: boolean) => void;
     getSkipBeforeLayouted: () => boolean;
@@ -120,7 +121,9 @@ export declare enum STATE_VALUE_ENUM {
     STATE_DIMENSION_HOVER = "dimension_hover",
     STATE_DIMENSION_HOVER_REVERSE = "dimension_hover_reverse",
     STATE_SELECTED = "selected",
-    STATE_SELECTED_REVERSE = "selected_reverse"
+    STATE_SELECTED_REVERSE = "selected_reverse",
+    STATE_SANKEY_EMPHASIS = "selected",
+    STATE_SANKEY_EMPHASIS_REVERSE = "blur"
 }
 export declare enum STATE_VALUE_ENUM_REVERSE {
     STATE_HOVER_REVERSE = "hover_reverse",

package/types/component/axis/base-axis.d.ts

@@ -41,6 +41,7 @@ export declare abstract class AxisComponent<T extends ICommonAxisSpec & Record<s
     protected abstract updateSeriesScale(): void;
     protected abstract collectSeriesField(depth: number, series: ISeries): string | string[];
     abstract transformScaleDomain(): void;
+    protected abstract updateScaleRange(): boolean;
     protected _dataFieldText: string;
     protected _axisMark: IComponentMark;
     protected _gridMark: IComponentMark;
@@ -66,6 +67,7 @@ export declare abstract class AxisComponent<T extends ICommonAxisSpec & Record<s
     protected initEvent(): void;
     protected updateScaleDomain(): void;
     protected _clearRawDomain(): void;
+    onLayoutEnd(ctx: any): void;
     protected computeData(updateType?: 'domain' | 'range' | 'force'): void;
     protected initScales(): void;
     _compareSpec(spec: T, prevSpec: T): {

package/types/component/axis/cartesian/axis.d.ts

@@ -80,7 +80,6 @@ export declare abstract class CartesianAxis<T extends ICartesianAxisCommonSpec =
     protected _tickTransformOption(): ICartesianTickDataOpt;
     protected axisHelper(): IAxisHelper;
     afterCompile(): void;
-    onLayoutEnd(ctx: any): void;
     onRender(ctx: any): void;
     changeRegions(regions: IRegion[]): void;
     update(ctx: IComponentOption): void;
@@ -94,11 +93,11 @@ export declare abstract class CartesianAxis<T extends ICartesianAxisCommonSpec =
     };
     _transformLayoutRect: (result: ILayoutRect) => ILayoutRect;
     getBoundsInRect(rect: ILayoutRect): IBoundsLike;
-    updateLayoutAttribute(): void;
     private _getTitleLimit;
     private _getUpdateAttribute;
     protected getLabelItems(length: number): any[];
     protected initEvent(): void;
+    protected _updateAxisLayout: () => void;
     protected _getNormalizedValue(values: any[], length: number): number;
     private _fixAxisOnZero;
     protected _layoutCacheProcessing(rect: ILayoutRect): ILayoutRect;

package/types/component/axis/cartesian/interface/common.d.ts

@@ -23,6 +23,7 @@ export interface ILinearAxis extends IAxis {
     readonly zero: boolean;
     readonly nice: boolean;
     setExtendDomain: (key: string, value: number | undefined) => void;
+    niceLabelFormatter?: (value: StringOrNumber) => StringOrNumber;
 }
 export interface IAxisHelper {
     isContinuous: boolean;

package/types/component/axis/interface/spec.d.ts

@@ -18,6 +18,8 @@ export interface ICommonAxisSpec extends Omit<IComponentSpec, 'orient' | 'center
 export interface ILinearAxisSpec {
     min?: number;
     max?: number;
+    softMin?: number | ((domain: number[]) => number);
+    softMax?: number | ((domain: number[]) => number);
     range?: {
         min?: number;
         max?: number;

package/types/component/axis/mixin/linear-axis-mixin.d.ts

@@ -3,6 +3,7 @@ import type { IAxisLocationCfg, ITick } from '../interface';
 import type { IEvent } from '../../../event/interface';
 import type { IOrientType } from '../../../typings/space';
 import type { IComponentOption } from '../../interface/common';
+import type { StringOrNumber } from '../../../typings';
 export declare const e10: number;
 export declare const e5: number;
 export declare const e2: number;
@@ -16,6 +17,9 @@ export interface LinearAxisMixin {
         min?: number;
         max?: number;
     };
+    _domainAfterSpec: number[];
+    _softMinValue?: number;
+    _softMaxValue?: number;
     _expand?: {
         max?: number;
         min?: number;
@@ -31,16 +35,18 @@ export interface LinearAxisMixin {
     event: IEvent;
     _orient: IOrientType;
     _option: IComponentOption;
+    niceLabelFormatter: (value: StringOrNumber) => StringOrNumber;
 }
 export declare class LinearAxisMixin {
     protected _extend: {
         [key: string]: number;
     };
+    niceLabelFormatter: (value: StringOrNumber) => StringOrNumber;
     setExtraAttrFromSpec(): void;
     transformScaleDomain(): void;
-    setLinearScaleNice(): void;
-    setLogScaleNice(): void;
-    setScaleNice(): void;
+    setLinearScaleNice(): false | LinearScale;
+    setLogScaleNice(): false | LinearScale;
+    setScaleNice(): false | LinearScale;
     dataToPosition(values: any[], cfg?: IAxisLocationCfg): number;
     valueToPosition(value: any): number;
     computeLinearDomain(data: {
@@ -58,7 +64,10 @@ export declare class LinearAxisMixin {
         max?: number;
     };
     protected setDomainMinMax(domain: number[]): void;
+    protected setSoftDomainMinMax(domain: number[]): void;
     setZero(zero: boolean): void;
     protected updateScaleDomain(): void;
     protected updateScaleDomainByModel(domain?: number[]): void;
+    getDomainAfterSpec(): number[];
+    protected _updateNiceLabelFormatter(domain: number[]): void;
 }

package/types/component/axis/polar/axis.d.ts

@@ -38,7 +38,6 @@ export declare abstract class PolarAxis<T extends IPolarAxisCommonSpec = IPolarA
     effect: IEffect;
     setAttrFromSpec(): void;
     _transformLayoutPosition: (pos: Partial<IPoint>) => Partial<IPoint>;
-    onLayoutEnd(ctx: any): void;
     onRender(ctx: any): void;
     changeRegions(): void;
     protected _tickTransformOption(): IPolarTickDataOpt;

package/types/component/axis/polar/interface/common.d.ts

@@ -14,6 +14,7 @@ export interface IPolarAxisHelper {
     getScale: (depth?: number) => IBaseScale;
     getBandwidth?: (depth?: number) => number;
     getAxisId: () => number;
+    setExtendDomain?: (key: string, value: number | undefined) => void;
 }
 export interface IPolarAxis extends IAxis {
     startAngle: number;

package/types/component/axis/polar/linear-axis.d.ts

@@ -3,7 +3,7 @@ import { ComponentTypeEnum } from '../../interface/type';
 import { PolarAxis } from './axis';
 import type { IPolarLinearAxisSpec } from './interface/spec';
 import { LinearAxisMixin } from '../mixin/linear-axis-mixin';
-export interface PolarLinearAxis<T extends IPolarLinearAxisSpec = IPolarLinearAxisSpec> extends Pick<LinearAxisMixin, 'setExtraAttrFromSpec' | 'transformScaleDomain' | 'valueToPosition' | 'computeLinearDomain' | 'setScaleNice'>, PolarAxis<T> {
+export interface PolarLinearAxis<T extends IPolarLinearAxisSpec = IPolarLinearAxisSpec> extends Pick<LinearAxisMixin, 'setExtraAttrFromSpec' | 'transformScaleDomain' | 'valueToPosition' | 'computeLinearDomain' | 'setScaleNice' | 'setExtendDomain'>, PolarAxis<T> {
 }
 export declare class PolarLinearAxis<T extends IPolarLinearAxisSpec = IPolarLinearAxisSpec> extends PolarAxis<T> {
     static type: ComponentTypeEnum;
@@ -11,6 +11,9 @@ export declare class PolarLinearAxis<T extends IPolarLinearAxisSpec = IPolarLine
     static specKey: string;
     protected _zero: boolean;
     protected _nice: boolean;
+    protected _extend: {
+        [key: string]: number;
+    };
     protected _scale: LinearScale;
     protected _groupScales: LinearScale[];
     setAttrFromSpec(): void;
@@ -20,5 +23,6 @@ export declare class PolarLinearAxis<T extends IPolarLinearAxisSpec = IPolarLine
         max: number;
         values: any[];
     }[]): number[];
+    protected axisHelper(): any;
 }
 export declare const registerPolarLinearAxis: () => void;

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

@@ -42,6 +42,7 @@ export declare class BaseComponent<T extends IComponentSpec = IComponentSpec> ex
     clear(): void;
     compile(): void;
     compileMarks(group?: string | IGroupMark): void;
+    reAppendComponents(): void;
     protected _delegateEvent: (component: IGraphic, event: any, type: string, item?: any, datum?: Datum) => void;
     getBoundsInRect(rect: ILayoutRect, fullRect: ILayoutRect): IBoundsLike;
 }

package/types/component/crosshair/base.d.ts

@@ -82,6 +82,5 @@ export declare abstract class BaseCrossHair<T extends ICartesianCrosshairSpec |
     protected _parseCrosshairSpec(): void;
     protected _parseField(field: ICrosshairCategoryFieldSpec, fieldName: string): any;
     protected _filterAxisByPoint<T>(axisMap: IAxisInfo<T>, relativeX: number, relativeY: number): IAxisInfo<T>;
-    protected clearEvent(): void;
-    clear(): void;
+    protected clearOutEvent(): void;
 }

package/types/component/crosshair/interface/cartesian.d.ts

@@ -1,23 +1,20 @@
 import type { StringOrNumber } from '../../../typings';
 import type { IAxis } from '../../axis';
+export interface ICrosshairLabelInfo {
+    visible: boolean;
+    text: StringOrNumber;
+    dx: number;
+    dy: number;
+    defaultFormatter?: (value: StringOrNumber) => StringOrNumber;
+}
 export interface ICrosshairInfoX {
     height: number;
     leftPos: number;
     rightPos: number;
     topPos: number;
     x: number;
-    bottom: {
-        visible: boolean;
-        text: StringOrNumber;
-        dx: number;
-        dy: number;
-    };
-    top: {
-        visible: boolean;
-        text: StringOrNumber;
-        dx: number;
-        dy: number;
-    };
+    bottom: ICrosshairLabelInfo;
+    top: ICrosshairLabelInfo;
     visible: boolean;
     _isCache?: boolean;
     axis: IAxis;
@@ -28,18 +25,8 @@ export interface ICrosshairInfoY {
     topPos: number;
     bottomPos: number;
     y: number;
-    left: {
-        visible: boolean;
-        text: StringOrNumber;
-        dx: number;
-        dy: number;
-    };
-    right: {
-        visible: boolean;
-        text: StringOrNumber;
-        dx: number;
-        dy: number;
-    };
+    left: ICrosshairLabelInfo;
+    right: ICrosshairLabelInfo;
     visible: boolean;
     _isCache?: boolean;
     axis: IAxis;

package/types/component/crosshair/interface/polar.d.ts

@@ -14,10 +14,12 @@ export interface IPolarCrosshairInfo {
     angle: number;
     point: IPoint;
     _isCache?: boolean;
-    label?: {
-        visible: boolean;
-        text: StringOrNumber;
-        offset: number;
-    };
+    label?: IPolarCrosshairLabelInfo;
     axis?: IPolarAxis;
 }
+export interface IPolarCrosshairLabelInfo {
+    visible: boolean;
+    text: StringOrNumber;
+    offset: number;
+    defaultFormatter?: (value: StringOrNumber) => StringOrNumber;
+}

package/types/component/custom-mark/custom-mark.d.ts

@@ -2,11 +2,11 @@ import { BaseComponent } from '../base/base-component';
 import { ComponentTypeEnum } from '../interface/type';
 import type { IRegion } from '../../region/interface';
 import type { IModelRenderOption, IModelSpecInfo } from '../../model/interface';
-import type { EnableMarkType, ICustomMarkGroupSpec, ICustomMarkSpec } from '../../typings';
+import type { EnableMarkType, ICustomMarkGroupSpec, ICustomMarkSpec, ILayoutRect } from '../../typings';
 import type { Maybe } from '@visactor/vutils';
 import type { IGraphic } from '@visactor/vrender-core';
 import type { IModelMarkAttributeContext } from '../../compile/mark/interface';
-export declare class CustomMark<T = any> extends BaseComponent<any> {
+export declare class CustomMark extends BaseComponent<ICustomMarkSpec<EnableMarkType>> {
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
     static specKey: string;
@@ -14,7 +14,7 @@ export declare class CustomMark<T = any> extends BaseComponent<any> {
     layoutType: 'none';
     layoutZIndex: number;
     layoutLevel: number;
-    protected _spec: (ICustomMarkSpec<Exclude<EnableMarkType, 'group'>> | ICustomMarkGroupSpec)[];
+    protected _spec: ICustomMarkSpec<Exclude<EnableMarkType, 'group'>> | ICustomMarkGroupSpec;
     static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
     created(): void;
     protected _markAttributeContext: IModelMarkAttributeContext;
@@ -23,7 +23,7 @@ export declare class CustomMark<T = any> extends BaseComponent<any> {
     protected initMarks(): void;
     private _createExtensionMark;
     initEvent(): void;
-    _compareSpec(spec: T, prevSpec: T): {
+    _compareSpec(spec: ICustomMarkSpec<EnableMarkType>, prevSpec: ICustomMarkSpec<EnableMarkType>): {
         change: boolean;
         reMake: boolean;
         reRender: boolean;
@@ -35,5 +35,12 @@ export declare class CustomMark<T = any> extends BaseComponent<any> {
     onRender(ctx: IModelRenderOption): void;
     afterCompile(): void;
     private _getMarkAttributeContext;
+    private _getLayoutRect;
+    getBoundsInRect(rect: ILayoutRect): {
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+    };
 }
 export declare const registerCustomMark: () => void;

package/types/component/data-zoom/data-filter-base-component.d.ts

@@ -5,7 +5,7 @@ import type { AdaptiveSpec, ILayoutRect, ILayoutType, IOrientType, IRect, String
 import type { IBaseScale } from '@visactor/vscale';
 import type { ICartesianBandAxisSpec } from '../axis/cartesian';
 import type { IBoundsLike } from '@visactor/vutils';
-import { IFilterMode } from './interface';
+import type { IFilterMode } from './interface';
 import type { IDataFilterComponent, IDataFilterComponentSpec, IRoamDragSpec, IRoamScrollSpec, IRoamZoomSpec } from './interface';
 import type { BaseEventParams } from '../../event/interface';
 import type { AbstractComponent } from '@visactor/vrender-components';
@@ -19,6 +19,7 @@ export declare abstract class DataFilterBaseComponent<T extends IDataFilterCompo
     protected _fixedBandSize?: number;
     protected _cacheRect?: ILayoutRect;
     protected _cacheVisibility?: boolean;
+    protected _dataUpdating: boolean;
     protected _stateScale: IBaseScale;
     protected _relatedAxisComponent: IComponent;
     protected _originalStateFields: Record<number, string | number>;
@@ -110,7 +111,7 @@ export declare abstract class DataFilterBaseComponent<T extends IDataFilterCompo
         scrollY: number;
     }, e: BaseEventParams['event']) => boolean;
     protected _handleChartDrag: (delta: [number, number], e: BaseEventParams['event']) => void;
-    protected _handleChartMove: (value: number, rate: number) => void;
+    protected _handleChartMove: (value: number, rate: number) => boolean;
     protected _initCommonEvent(): void;
     updateLayoutAttribute(): void;
     onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect, ctx: any): void;

package/types/component/data-zoom/interface.d.ts

@@ -59,7 +59,4 @@ export interface IDataFilterComponent extends IComponent {
         y: number;
     }) => void;
 }
-export declare const enum IFilterMode {
-    filter = "filter",
-    axis = "axis"
-}
+export type IFilterMode = 'filter' | 'axis';

package/types/component/index.d.ts

@@ -27,22 +27,22 @@ import { CartesianCrossHair, PolarCrossHair, registerCartesianCrossHair, registe
 import type { IPlayerSpec, IPlayerTheme } from './player';
 import { Player, registerPlayer } from './player';
 import type { IMarkLineSpec, IStepMarkLineSpec, IMarkLineTheme } from './marker/mark-line';
-import { MarkLine, registerMarkLine } from './marker/mark-line';
+import { CartesianMarkLine, PolarMarkLine, registerMarkLine, registerPolarMarkLine } from './marker/mark-line';
 import type { IMarkAreaSpec, IMarkAreaTheme } from './marker/mark-area';
-import { MarkArea, registerMarkArea } from './marker/mark-area';
+import { CartesianMarkArea, PolarMarkArea, registerMarkArea, registerPolarMarkArea } from './marker/mark-area';
 import type { IMarkPointSpec, IMarkPointTheme } from './marker/mark-point';
-import { MarkPoint, registerMarkPoint } from './marker/mark-point';
+import { CartesianMarkPoint, PolarMarkPoint, GeoMarkPoint, registerMarkPoint, registerPolarMarkPoint, registerGeoMarkPoint } from './marker/mark-point';
 import type { ITooltipSpec, ITooltipTheme } from './tooltip';
 import { Tooltip, registerTooltip } from './tooltip';
-import type { ILabelSpec, ITotalLabelTheme } from './label';
+import type { ILabelSpec, ITotalLabelTheme, ITotalLabelSpec } from './label';
 import { Label, registerLabel } from './label';
 import { TotalLabel, registerTotalLabel } from './label/total-label';
 import { registerPoptip } from './poptip/index';
 import type { IComponentTheme } from './interface';
 import type { IAxisCommonTheme, IAxisItemTheme, IBandAxisTheme } from './axis/interface';
 import type { IPoptipTheme } from './poptip/interface';
-export { ScrollBar, DataZoom, CustomMark, Brush, MapLabelComponent, CartesianAxis, CartesianBandAxis, CartesianLinearAxis, CartesianTimeAxis, CartesianLogAxis, CartesianSymlogAxis, PolarAxis, PolarBandAxis, PolarLinearAxis, DiscreteLegend, ContinuousLegend, Indicator, Title, GeoCoordinate, CartesianCrossHair, PolarCrossHair, Player, MarkArea, MarkLine, MarkPoint, Tooltip, Label, TotalLabel };
-export { registerBrush, registerScrollBar, registerTitle, registerTooltip, registerCartesianBandAxis, registerCartesianCrossHair, registerCartesianLinearAxis, registerCartesianLogAxis, registerCartesianSymlogAxis, registerCartesianTimeAxis, registerContinuousLegend, registerCustomMark, registerDataZoom, registerDiscreteLegend, registerGeoCoordinate, registerIndicator, registerLabel, registerTotalLabel, registerMapLabel, registerMarkArea, registerMarkLine, registerMarkPoint, registerPlayer, registerPolarBandAxis, registerPolarCrossHair, registerPolarLinearAxis, registerPoptip };
-export type { IComponent, IScrollBarSpec, IBrushSpec, ICartesianAxisSpec, ICartesianBandAxisSpec, ICartesianCrosshairSpec, ICartesianLinearAxisSpec, ICartesianTimeAxisSpec, ICartesianLogAxisSpec, IContinuousLegendSpec, IDataZoomSpec, IDiscreteLegendSpec, IGeoCoordinateSpec, IIndicatorSpec, ILabelSpec, IMapLabelSpec, IMarkAreaSpec, IMarkLineSpec, IStepMarkLineSpec, IMarkPointSpec, IPlayerSpec, IPolarAxisSpec, IPolarBandAxisSpec, IPolarCrosshairSpec, IPolarLinearAxisSpec, ITitleSpec, ITooltipSpec };
+export { ScrollBar, DataZoom, CustomMark, Brush, MapLabelComponent, CartesianAxis, CartesianBandAxis, CartesianLinearAxis, CartesianTimeAxis, CartesianLogAxis, CartesianSymlogAxis, PolarAxis, PolarBandAxis, PolarLinearAxis, DiscreteLegend, ContinuousLegend, Indicator, Title, GeoCoordinate, CartesianCrossHair, PolarCrossHair, Player, CartesianMarkLine, CartesianMarkArea, CartesianMarkPoint, PolarMarkLine, PolarMarkArea, PolarMarkPoint, GeoMarkPoint, Tooltip, Label, TotalLabel };
+export { registerBrush, registerScrollBar, registerTitle, registerTooltip, registerCartesianBandAxis, registerCartesianCrossHair, registerCartesianLinearAxis, registerCartesianLogAxis, registerCartesianSymlogAxis, registerCartesianTimeAxis, registerContinuousLegend, registerCustomMark, registerDataZoom, registerDiscreteLegend, registerGeoCoordinate, registerIndicator, registerLabel, registerTotalLabel, registerMapLabel, registerMarkLine, registerMarkArea, registerMarkPoint, registerPolarMarkLine, registerPolarMarkArea, registerPolarMarkPoint, registerGeoMarkPoint, registerPlayer, registerPolarBandAxis, registerPolarCrossHair, registerPolarLinearAxis, registerPoptip };
+export type { IComponent, IScrollBarSpec, IBrushSpec, ICartesianAxisSpec, ICartesianBandAxisSpec, ICartesianCrosshairSpec, ICartesianLinearAxisSpec, ICartesianTimeAxisSpec, ICartesianLogAxisSpec, IContinuousLegendSpec, IDataZoomSpec, IDiscreteLegendSpec, IGeoCoordinateSpec, IIndicatorSpec, ILabelSpec, ITotalLabelSpec, IMapLabelSpec, IMarkAreaSpec, IMarkLineSpec, IStepMarkLineSpec, IMarkPointSpec, IPlayerSpec, IPolarAxisSpec, IPolarBandAxisSpec, IPolarCrosshairSpec, IPolarLinearAxisSpec, ITitleSpec, ITooltipSpec };
 export type { IComponentTheme, ICrosshairTheme, IAxisItemTheme, IAxisCommonTheme, IBandAxisTheme, IPolarAxisCommonTheme, ICartesianAxisCommonTheme, IBrushTheme, IDataZoomTheme, IScrollBarTheme, IIndicatorTheme, IMapLabelTheme, ITotalLabelTheme, ISizeLegendTheme, IColorLegendTheme, IDiscreteLegendTheme, IContinuousLegendTheme, IMarkAreaTheme, IMarkLineTheme, IMarkPointTheme, IPlayerTheme, IPoptipTheme, ITitleTheme, ITooltipTheme };
 export * from './tooltip/interface';