@visactor/vchart-types 2.0.8-alpha.5 → 2.0.9

package/types/animation/config.d.ts

@@ -63,3 +63,4 @@ export declare const registerRectAnimation: () => void;
 export declare const registerArcAnimation: () => void;
 export declare const registerLineOrAreaAnimation: () => void;
 export declare const registerPolygonAnimation: () => void;
+export declare const registerStageAnimation: () => void;

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

@@ -15,7 +15,6 @@ import type { IParserOptions } from '@visactor/vdataset';
 import type { IBoundsLike, Maybe } from '@visactor/vutils';
 import { CompilableBase } from '../../compile/compilable-base';
 import type { IGlobalScale } from '../../scale/interface';
-import type { IAxis } from '../../component/axis/interface/common';
 import type { IMorphConfig } from '../../animation/spec';
 import type { IInteraction } from '../../interaction/interface/common';
 export declare class BaseChart<T extends IChartSpec> extends CompilableBase implements IChart {
@@ -162,6 +161,5 @@ export declare class BaseChart<T extends IChartSpec> extends CompilableBase impl
     }): IMarkGraphic[];
     protected _setStateInDatum(stateKey: string, d: MaybeArray<Datum> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier): void;
     setDimensionIndex(value: StringOrNumber, opt: DimensionIndexOption): void;
-    showCrosshair(cb: (axis: IAxis) => false | string | number): void;
     getColorScheme(): any;
 }

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

@@ -14,7 +14,6 @@ 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';
-import type { IAxis } from '../../component/axis/interface';
 export type DimensionIndexOption = {
     filter?: (cmp: IComponent) => boolean;
     tooltip?: boolean;
@@ -96,7 +95,6 @@ export interface IChart extends ICompilable {
     setCurrentTheme: () => void;
     getSeriesData: (id: StringOrNumber | undefined, index: number | undefined) => DataView | undefined;
     setDimensionIndex: (value: StringOrNumber, opt: DimensionIndexOption) => void;
-    showCrosshair: (cb: (axis: IAxis) => false | string | number) => void;
     filterGraphicsByDatum: (datum: MaybeArray<Datum> | null, opt?: {
         filter?: (series: ISeries, mark: IMark) => boolean;
         region?: IRegionQuerier;

package/types/compile/compiler.d.ts

@@ -8,6 +8,7 @@ import type { IMorphConfig } from '../animation/spec';
 import type { IVChart, IVChartRenderOption } from '../core/interface';
 import { type IMark } from '../mark/interface';
 import type { Gesture } from '@visactor/vrender-kits';
+import type { MarkAnimationSpec } from '../animation/interface';
 type EventListener = {
     type: string;
     callback: (...args: any[]) => void;
@@ -19,6 +20,7 @@ export declare class Compiler implements ICompiler {
     private _progressiveRafId?;
     protected _rootMarks: IMark[];
     protected _stage: IStage;
+    protected _stateAnimationConfig: Partial<MarkAnimationSpec>;
     protected _rootGroup: IGroup;
     getRootGroup(): IGroup;
     protected _viewListeners: Map<(...args: any[]) => any, EventListener>;
@@ -61,6 +63,9 @@ export declare class Compiler implements ICompiler {
     renderMarks(): void;
     reuseOrMorphing(morphConfig?: IMorphConfig): void;
     render(morphConfig?: IMorphConfig): void;
+    setStageAnimationConfig(config: Partial<MarkAnimationSpec>): void;
+    updateStateAnimation(): void;
+    runStageAnimation(): void;
     updateViewBox(viewBox: IBoundsLike, reRender?: boolean): void;
     resize(width: number, height: number, reRender?: boolean): void;
     setBackground(color: IColor): void;

package/types/compile/interface/compilable-item.d.ts

@@ -7,6 +7,7 @@ import type { IBoundsLike } from '@visactor/vutils';
 import type { EventSourceType, EventType } from '../../event/interface';
 import type { IMark, IMarkGraphic } from '../../mark/interface';
 import type { LayoutState } from '../interface/compiler';
+import type { MarkAnimationSpec } from '../../animation/interface';
 export type CompilerListenerParameters = {
     type: EventType;
     event: Event;
@@ -39,6 +40,7 @@ export interface ICompiler {
     }, removeGraphicItems?: boolean) => void;
     renderNextTick: (morphConfig?: IMorphConfig) => void;
     render: (morphConfig?: IMorphConfig) => void;
+    setStageAnimationConfig: (config: Partial<MarkAnimationSpec>) => void;
     updateViewBox: (viewBox: IBoundsLike, reRender?: boolean) => void;
     resize: (width: number, height: number, reRender?: boolean) => void;
     setBackground: (color: IColor) => void;

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

@@ -43,7 +43,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;
+    abstract updateScaleRange(): boolean;
     protected abstract getDefaultInteractive(): boolean;
     protected _dataFieldText: string;
     protected _axisMark: IComponentMark;

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

@@ -64,7 +64,7 @@ export declare abstract class CartesianAxis<T extends ICartesianAxisCommonSpec =
     }[]): StringOrNumber[];
     abstract valueToPosition(value: any): number;
     protected getNewScaleRange(): number[];
-    protected updateScaleRange(): boolean;
+    updateScaleRange(): boolean;
     init(option: IModelInitOption): void;
     setAttrFromSpec(): void;
     onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect): void;

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

@@ -23,7 +23,7 @@ export declare class CartesianBandAxis<T extends ICartesianBandAxisSpec = ICarte
         max: number;
         values: any[];
     }[]): StringOrNumber[];
-    protected updateScaleRange(): boolean;
+    updateScaleRange(): boolean;
     protected initScales(): void;
     protected axisHelper(): {
         isContinuous: boolean;

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

@@ -18,6 +18,7 @@ export interface IAxis extends IComponent {
     getCoordinateType: () => CoordinateType;
     visible: boolean;
     directionStr?: 'l2r' | 'r2l' | 't2b' | 'b2t';
+    updateScaleRange?: () => void;
 }
 export interface IAxisItem<T> {
     visible?: boolean;

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

@@ -42,6 +42,8 @@ export declare class BandAxisMixin {
     protected _rawDomainIndex: {
         [key: string | number | symbol]: number;
     }[];
+    protected _rawDomain: StringOrNumber[][];
+    getRawDomain(): StringOrNumber[][];
     dataToPosition(values: any[], cfg?: IAxisLocationCfg): number;
     valueToPosition(value: any): number;
     updateGroupScaleRange(): void;

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

@@ -27,7 +27,7 @@ export interface LinearAxisMixin {
     _tick: ITick | undefined;
     isSeriesDataEnable: any;
     computeDomain: any;
-    collectData: (depth?: number) => {
+    collectData: (depth?: number, rawData?: boolean) => {
         min: number;
         max: number;
         values: any[];
@@ -47,6 +47,8 @@ export declare class LinearAxisMixin {
     protected _extend: {
         [key: string]: number;
     };
+    protected _rawDomain: StringOrNumber[];
+    getRawDomain(): StringOrNumber[];
     niceLabelFormatter: (value: StringOrNumber) => StringOrNumber;
     setExtraAttrFromSpec(): void;
     transformScaleDomain(): void;
@@ -76,4 +78,6 @@ export declare class LinearAxisMixin {
     protected updateScaleDomainByModel(domain?: number[]): void;
     getDomainAfterSpec(): number[];
     protected _updateNiceLabelFormatter(domain: number[]): void;
+    protected _updateRawDomain(): void;
+    protected _clearRawDomain(): void;
 }

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

@@ -46,7 +46,7 @@ export declare abstract class PolarAxis<T extends IPolarAxisCommonSpec = IPolarA
     setAttrFromSpec(): void;
     _transformLayoutPosition: (pos: Partial<IPoint>) => Partial<IPoint>;
     protected _tickTransformOption(): IPolarTickDataOpt;
-    protected updateScaleRange(): boolean;
+    updateScaleRange(): boolean;
     protected collectSeriesField(depth: number, series: IPolarSeries): string | string[];
     protected abstract computeDomain(data: {
         min: number;

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

@@ -23,7 +23,7 @@ export declare class PolarBandAxis<T extends IPolarBandAxisSpec = IPolarBandAxis
         max: number;
         values: any[];
     }[]): StringOrNumber[];
-    protected updateScaleRange(): boolean;
+    updateScaleRange(): boolean;
     protected axisHelper(): {
         getBandwidth: (depth: number) => number;
         isContinuous: boolean;

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

@@ -1,34 +1,37 @@
 import { BaseComponent } from '../base/base-component';
 import type { IEffect, IModelInitOption } from '../../model/interface';
 import { type IComponent, type IComponentOption } from '../interface';
-import type { AdaptiveSpec, ILayoutRect, ILayoutType, IOrientType, IRect, StringOrNumber } from '../../typings';
-import type { IBaseScale } from '@visactor/vscale';
-import type { ICartesianBandAxisSpec } from '../axis/cartesian';
-import type { IBoundsLike } from '@visactor/vutils';
-import type { IFilterMode } from './interface';
-import type { IDataFilterComponent, IDataFilterComponentSpec, IRoamDragSpec, IRoamScrollSpec, IRoamZoomSpec } from './interface';
-import type { BaseEventParams } from '../../event/interface';
+import type { AdaptiveSpec, ILayoutPoint, ILayoutRect, ILayoutType, IOrientType, IRect, StringOrNumber } from '../../typings';
+import { type IBaseScale } from '@visactor/vscale';
+import { type IBoundsLike } from '@visactor/vutils';
+import type { IDataFilterComponent, IDataFilterComponentSpec, IFilterMode } from './interface';
 import type { AbstractComponent } from '@visactor/vrender-components';
 import type { IGraphic } from '@visactor/vrender-core';
+import { DataFilterEvent } from './data-filter-event';
 export declare abstract class DataFilterBaseComponent<T extends IDataFilterComponentSpec = IDataFilterComponentSpec> extends BaseComponent<AdaptiveSpec<T, 'width' | 'height'>> implements IDataFilterComponent {
+    protected _dataFilterEvent: DataFilterEvent;
     layoutType: ILayoutType | 'none';
     protected _component: AbstractComponent;
     protected _orient: IOrientType;
     protected _isHorizontal: boolean;
-    protected _throttledHide: () => void;
+    get isHorizontal(): boolean;
     protected _auto?: boolean;
     protected _fixedBandSize?: number;
     protected _cacheRect?: ILayoutRect;
+    protected _cacheLayoutStartPoint?: ILayoutPoint;
     protected _cacheVisibility?: boolean;
     protected _dataUpdating: boolean;
     protected _stateScale: IBaseScale;
-    protected _relatedAxisComponent: IComponent;
-    protected _originalStateFields: Record<number, string | number>;
+    get stateScale(): IBaseScale;
+    protected _hasInitStateScale: boolean;
     protected _seriesUserId?: StringOrNumber[];
     protected _seriesIndex?: number[];
     protected _regionUserId: string[];
     protected _regionIndex: number[];
     protected _newDomain: any[];
+    protected _relatedAxisComponent: IComponent;
+    get relatedAxisComponent(): IComponent;
+    protected _originalStateFields: Record<number, string | number>;
     protected _startValue: number | string;
     protected _endValue: number | string;
     protected _start: number;
@@ -44,11 +47,6 @@ export declare abstract class DataFilterBaseComponent<T extends IDataFilterCompo
     protected _width: number;
     protected _height: number;
     protected _filterMode: IFilterMode;
-    protected _activeRoam: boolean;
-    protected _zoomAttr: IRoamZoomSpec;
-    protected _dragAttr: IRoamDragSpec;
-    protected _scrollAttr: IRoamScrollSpec;
-    get relatedAxisComponent(): IComponent;
     setStartAndEnd(start: number | string, end: number | string, rangeMode?: ['percent' | 'value', 'percent' | 'value']): void;
     enableInteraction(): void;
     disableInteraction(): void;
@@ -64,30 +62,18 @@ export declare abstract class DataFilterBaseComponent<T extends IDataFilterCompo
     protected abstract _computeWidth(): number;
     protected abstract _computeHeight(): number;
     protected abstract _handleDataCollectionChange(): void;
+    protected abstract _updateScaleRange(): void;
+    protected _initEvent(): void;
     protected _handleChange(start: number, end: number, updateComponent?: boolean): void;
-    protected _isReverse(): boolean;
     protected _updateRangeFactor(tag?: 'startHandler' | 'endHandler'): void;
+    protected _handleStateChange: (startValue: number, endValue: number, tag?: string) => boolean;
     effect: IEffect;
     protected _visible: boolean;
     get visible(): boolean;
     constructor(spec: T, options: IComponentOption);
     created(): void;
     initLayout(): void;
-    protected _setAxisFromSpec(): void;
-    protected _setRegionsFromSpec(): void;
-    onDataUpdate(): void;
-    protected _computeDomainOfStateScale(isContinuous?: boolean): any;
-    protected _initEvent(): void;
-    protected _initData(): void;
-    setAttrFromSpec(): void;
-    statePointToData(state: number): any;
-    dataToStatePoint(data: number | string): number;
-    protected _modeCheck(statePoint: 'start' | 'end', mode: string): any;
-    protected _setStateFromSpec(): void;
-    private _parseFieldOfSeries;
-    protected _initStateScale(): void;
     init(option: IModelInitOption): void;
-    protected _addTransformToSeries(): void;
     _compareSpec(spec: AdaptiveSpec<T, 'width' | 'height'>, prevSpec: AdaptiveSpec<T, 'width' | 'height'>): {
         change: boolean;
         reMake: boolean;
@@ -96,33 +82,26 @@ export declare abstract class DataFilterBaseComponent<T extends IDataFilterCompo
         reCompile: boolean;
     };
     reInit(spec?: AdaptiveSpec<T, 'width' | 'height'>): void;
-    protected _parseDomainFromState(startValue: number | string, endValue: number | string): any;
-    protected _handleStateChange: (startValue: number, endValue: number, tag?: string) => boolean;
-    protected _handleChartZoom: (params: {
-        zoomDelta: number;
-        zoomX?: number;
-        zoomY?: number;
-    }, e?: BaseEventParams['event']) => void;
-    protected _handleChartScroll: (params: {
-        scrollX: number;
-        scrollY: number;
-    }, e: BaseEventParams['event']) => boolean;
-    protected _handleChartDrag: (delta: [number, number], e: BaseEventParams['event']) => void;
-    protected _handleChartMove: (value: number, rate: number) => boolean;
-    protected _initCommonEvent(): void;
-    updateLayoutAttribute(): void;
-    protected _autoVisible(isShown: boolean): void;
     onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect): void;
+    updateLayoutAttribute(): void;
+    protected _initAfterLayout(): void;
+    protected _beforeLayoutEnd(): void;
     onLayoutEnd(): void;
     getBoundsInRect(rect: ILayoutRect): IBoundsLike;
+    setAttrFromSpec(): void;
+    protected _setAxisFromSpec(): void;
+    protected _setRegionsFromSpec(): void;
+    protected _initData(): void;
+    protected _addTransformToSeries(): void;
+    onDataUpdate(): void;
+    private _parseFieldOfSeries;
+    protected _setStateFromSpec(): void;
+    protected _setStateFromAxis(): void;
+    protected _initStateScale(): void;
+    protected _computeDomainOfStateScale(isContinuous?: boolean): any;
+    protected _autoVisible(isShown: boolean): void;
     hide(): void;
     show(): void;
-    protected _getAxisBandSize(axisSpec?: ICartesianBandAxisSpec): {
-        bandSize: number;
-        maxBandSize: number;
-        minBandSize: number;
-    };
     protected _autoUpdate(rect?: ILayoutRect): boolean;
     protected _getNeedClearVRenderComponents(): IGraphic[];
-    clear(): void;
 }

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

@@ -0,0 +1,53 @@
+import type { IRoamDragSpec, IRoamScrollSpec, IRoamZoomSpec } from './interface';
+import type { BaseEventParams, IEvent } from '../../event/interface';
+import type { IDataZoomSpec } from './data-zoom/interface';
+import type { IRegion } from '../../region';
+import { type ILayoutRect } from '../../typings';
+import type { IComponentOption } from '../interface';
+export declare class DataFilterEvent {
+    protected _type: 'dataZoom' | 'scrollBar';
+    protected _spec: IDataZoomSpec;
+    protected _option: IComponentOption;
+    protected _handleChange: (start: number, end: number, updateComponent?: boolean) => void;
+    protected getLayoutRect: () => ILayoutRect;
+    protected getState: () => {
+        start: number;
+        end: number;
+    };
+    protected getRegions: () => IRegion[];
+    protected getOption: () => IComponentOption;
+    protected getEvent: () => IEvent;
+    protected _isHorizontal: boolean;
+    protected _regions: IRegion[];
+    protected _activeRoam: boolean;
+    protected _zoomAttr: IRoamZoomSpec;
+    protected _dragAttr: IRoamDragSpec;
+    protected _scrollAttr: IRoamScrollSpec;
+    enableInteraction(): void;
+    disableInteraction(): void;
+    zoomIn(location?: {
+        x: number;
+        y: number;
+    }): void;
+    zoomOut(location?: {
+        x: number;
+        y: number;
+    }): void;
+    constructor(type: 'dataZoom' | 'scrollBar', spec: IDataZoomSpec, handleChange: (start: number, end: number, updateComponent?: boolean) => void, getLayoutRect: () => ILayoutRect, getState: () => {
+        start: number;
+        end: number;
+    }, getRegions: () => IRegion[], getOption: () => IComponentOption, getEvent: () => IEvent);
+    setEventAttrFromSpec(): void;
+    initZoomEvent: () => void;
+    handleChartZoom: (params: {
+        zoomDelta: number;
+        zoomX?: number;
+        zoomY?: number;
+    }, e?: BaseEventParams['event']) => void;
+    handleChartScroll: (params: {
+        scrollX: number;
+        scrollY: number;
+    }, e: BaseEventParams['event']) => boolean;
+    handleChartDrag: (delta: [number, number], e: BaseEventParams['event']) => void;
+    handleChartMove: (value: number, rate: number) => boolean;
+}

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

@@ -1,10 +1,10 @@
-import type { IComponentOption } from '../../interface';
-import { ComponentTypeEnum } from '../../interface/type';
+import { type IBoundsLike } from '@visactor/vutils';
+import { ComponentTypeEnum, type IComponentOption } from '../../interface';
 import { DataFilterBaseComponent } from '../data-filter-base-component';
 import { DataZoom as DataZoomComponent } from '@visactor/vrender-components';
 import type { IRectGraphicAttribute, ISymbolGraphicAttribute, IGraphic } from '@visactor/vrender-core';
-import type { Datum, ILayoutType } from '../../../typings';
-import type { ILinearScale, IBaseScale } from '@visactor/vscale';
+import type { Datum, ILayoutRect, ILayoutType } from '../../../typings';
+import { type ILinearScale, type IBaseScale } from '@visactor/vscale';
 import type { IDataZoomSpec } from './interface';
 import { DataZoomSpecTransformer } from './data-zoom-transformer';
 export declare class DataZoom<T extends IDataZoomSpec = IDataZoomSpec> extends DataFilterBaseComponent<T> {
@@ -28,25 +28,35 @@ export declare class DataZoom<T extends IDataZoomSpec = IDataZoomSpec> extends D
     protected _startHandlerSize: number;
     protected _endHandlerSize: number;
     protected _isReverseCache: boolean;
+    protected _cacheRect?: ILayoutRect;
+    protected _previewStateScale: IBaseScale;
     constructor(spec: T, options: IComponentOption);
+    protected _handleChange(start: number, end: number, updateComponent?: boolean, tag?: string): void;
+    protected _handleDataCollectionChange(): void;
     created(): void;
+    updateLayoutAttribute(): void;
+    protected _beforeLayoutEnd(): void;
+    clear(): void;
+    getBoundsInRect(rect: ILayoutRect): IBoundsLike;
     setAttrFromSpec(): void;
-    onLayoutEnd(): void;
     protected _initValueScale(): void;
     protected _updateScaleRange(): void;
+    protected _updateStateScaleRange(): void;
+    protected _updateValueScaleRange(): void;
     protected _computeDomainOfValueScale(): unknown[];
-    protected _computeMiddleHandlerSize(): number;
-    protected _computeWidth(): number;
-    protected _computeHeight(): number;
     protected _isScaleValid(scale: IBaseScale | ILinearScale): boolean;
+    protected _getXScale(): IBaseScale | ILinearScale;
+    protected _getYScale(): IBaseScale | ILinearScale;
     protected _dataToPositionX: (datum: Datum) => number;
     protected _dataToPositionX2: (datum: Datum) => number;
     protected _dataToPositionY: (datum: Datum) => number;
     protected _dataToPositionY2: (datum: Datum) => number;
+    protected _computeMiddleHandlerSize(): number;
+    protected _computeWidth(): number;
+    protected _computeHeight(): number;
     private _getAttrs;
-    protected _createOrUpdateComponent(): void;
-    protected _handleChange(start: number, end: number, updateComponent?: boolean, tag?: string): void;
-    protected _handleDataCollectionChange(): void;
+    private _getLayoutAttrs;
+    protected _createOrUpdateComponent(changeData?: boolean): void;
     protected _getComponentAttrs(isNeedPreview: boolean): {
         backgroundStyle: IRectGraphicAttribute;
         startHandlerStyle: ISymbolGraphicAttribute;
@@ -76,6 +86,7 @@ export declare class DataZoom<T extends IDataZoomSpec = IDataZoomSpec> extends D
     };
     protected _getHandlerTextFormatMethod(spec: IDataZoomSpec['startText']): (text: any) => any;
     protected _getNeedClearVRenderComponents(): IGraphic[];
-    clear(): void;
+    onDataUpdate(): void;
+    protected _getPreviewStateScale(): IBaseScale;
 }
 export declare const registerDataZoom: () => void;

package/types/component/data-zoom/scroll-bar/scroll-bar.d.ts

@@ -20,15 +20,16 @@ export declare class ScrollBar<T extends IScrollBarSpec = IScrollBarSpec> extend
     layoutType: ILayoutType;
     protected _component: ScrollBarComponent;
     constructor(spec: T, options: IComponentOption);
-    setAttrFromSpec(): void;
+    protected _handleChange(start: number, end: number, updateComponent?: boolean): void;
+    protected _handleDataCollectionChange(): void;
+    protected _beforeLayoutEnd(): void;
     onLayoutEnd(): void;
     protected _updateScaleRange(): void;
+    protected _updateComponentBounds(): void;
     protected _computeWidth(): number;
     protected _computeHeight(): number;
     private _getAttrs;
     protected _createOrUpdateComponent(): void;
-    protected _handleChange(start: number, end: number, updateComponent?: boolean): void;
-    protected _handleDataCollectionChange(): void;
     protected _getComponentAttrs(): Partial<ScrollBarAttributes>;
     protected _getNeedClearVRenderComponents(): IGraphic[];
 }

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

@@ -1,3 +1,5 @@
+import type { IBaseScale } from '@visactor/vscale';
+import type { CartesianAxis, ICartesianBandAxisSpec } from '../axis/cartesian';
 export interface IDataFilterWithNewDomainOption {
     getNewDomain: () => any[];
     isContinuous: () => boolean;
@@ -13,6 +15,7 @@ export interface IDataFilterComputeDomainOption {
         stateFields: string[];
         valueFields: string[];
         isCategoryState?: boolean;
+        seriesCollection: any[];
         method: 'sum';
     };
     output: {
@@ -21,3 +24,14 @@ export interface IDataFilterComputeDomainOption {
     };
 }
 export declare const dataFilterComputeDomain: (data: Array<any>, op: IDataFilterComputeDomainOption) => any[];
+export declare const statePointToData: (state: number, scale: IBaseScale, reverse: boolean) => any;
+export declare const dataToStatePoint: (data: number | string, scale: IBaseScale, isHorizontal: boolean) => number;
+export declare const isReverse: (axisComponent: CartesianAxis<any>, isHorizontal: boolean) => boolean;
+export declare const getAxisBandSize: (axisSpec?: ICartesianBandAxisSpec) => {
+    bandSize: number;
+    maxBandSize: number;
+    minBandSize: number;
+};
+export declare const modeCheck: (statePoint: 'start' | 'end', mode: string, spec: any) => any;
+export declare const parseDomainFromState: (startValue: number | string, endValue: number | string, scale: IBaseScale) => any;
+export declare const parseDomainFromStateAndValue: (start: number, startValue: number | string, end: number, endValue: number | string, scale: IBaseScale) => any;

package/types/constant/event.d.ts

@@ -66,6 +66,7 @@ export declare enum ChartEvent {
     markDeltaYUpdate = "markDeltaYUpdate",
     viewDataLabelUpdate = "viewDataLabelUpdate",
     scaleDomainUpdate = "scaleDomainUpdate",
+    scaleRawDomainUpdate = "scaleRawDomainUpdate",
     scaleUpdate = "scaleUpdate",
     dataZoomChange = "dataZoomChange",
     drill = "drill",

package/types/core/vchart.d.ts

@@ -22,7 +22,6 @@ import { Compiler } from '../compile/compiler';
 import type { IMorphConfig } from '../animation/spec';
 import type { DataLinkAxis, DataLinkSeries, IGlobalConfig, IVChart, IVChartRenderOption } from './interface';
 import { InstanceManager } from './instance-manager';
-import type { IAxis } from '../component/axis';
 export declare class VChart implements IVChart {
     readonly id: number;
     static useRegisters(comps: (() => void)[]): void;
@@ -181,7 +180,6 @@ export declare class VChart implements IVChart {
     getComponents(): import("../component/interface").IComponent[];
     getScale(scaleId: string): import("@visactor/vscale").IBaseScale;
     setDimensionIndex(value: StringOrNumber, opt?: DimensionIndexOption): void;
-    showCrosshair(cb: (axis: IAxis) => false | string | number): void;
     stopAnimation(): void;
     reRunNormalAnimation(): void;
     pauseAnimation(): void;

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

@@ -9,7 +9,7 @@ import type { IGroupGraphicAttribute, IGroup, IGraphic } from '@visactor/vrender
 import { GrammarItem } from '../../compile/grammar-item';
 import type { IModel } from '../../model/interface';
 import type { ICompilableData } from '../../compile/data/interface';
-import { type MarkAnimationSpec } from '../../animation/interface';
+import { AnimationStateEnum, type MarkAnimationSpec } from '../../animation/interface';
 export type ExChannelCall = (key: string | number | symbol, datum: Datum, states: StateValueType, baseValue: unknown) => unknown;
 export declare class BaseMark<T extends ICommonSpec> extends GrammarItem implements IMarkRaw<T> {
     readonly type: MarkType;
@@ -139,6 +139,7 @@ export declare class BaseMark<T extends ICommonSpec> extends GrammarItem impleme
     getGraphics(): IMarkGraphic[];
     protected _createGraphic(attrs?: any): IGraphic;
     protected _runGroupData(data: Datum[]): void;
+    getAnimationState(): AnimationStateEnum.appear | AnimationStateEnum.disappear | AnimationStateEnum.none | AnimationStateValues;
     protected createAnimationStateList(type: string, animationConfig: Partial<MarkAnimationSpec>): any;
     protected tryRunMorphing(graphics: IMarkGraphic[]): boolean;
     protected _runStateAnimation(graphics: IMarkGraphic[]): void;

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

@@ -95,6 +95,7 @@ export interface IMarkRaw<T extends ICommonSpec> extends ICompilableMark {
     renderProgressive: () => void;
     canAnimateAfterProgressive: () => boolean;
     runAnimation: () => void;
+    getAnimationState: () => AnimationStateValues;
     needClear?: boolean;
     disableAnimationByState: (state: string | string[]) => void;
     enableAnimationByState: (state: string | string[]) => void;

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

@@ -158,6 +158,7 @@ export declare abstract class BaseSeries<T extends ISeriesSpec> extends BaseMode
         marks: IMark[];
     }[];
     initAnimation(): void;
+    initStageAnimation(): void;
     initMarkState(): void;
     initSeriesStyleState(): void;
     afterInitMark(): void;