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

package/types/component/brush/brush.d.ts

@@ -6,13 +6,16 @@ import type { IModelRenderOption, IModelSpecInfo } from '../../model/interface';
 import type { IRegion } from '../../region/interface';
 import type { IGraphic } from '@visactor/vrender-core';
 import type { ISeries } from '../../series/interface';
-import type { IElement } from '@visactor/vgrammar-core';
+import type { IMark, IMarkGraphic } from '../../mark/interface';
 import type { BrushInteractiveRangeAttr, IBrush, IBrushSpec } from './interface';
 export declare class Brush<T extends IBrushSpec = IBrushSpec> extends BaseComponent<T> implements IBrush {
     layoutType: 'none';
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
     name: string;
+    static readonly builtInTheme: {
+        brush: import("./interface").IBrushTheme;
+    };
     static specKey: string;
     specKey: string;
     layoutZIndex: number;
@@ -23,59 +26,37 @@ export declare class Brush<T extends IBrushSpec = IBrushSpec> extends BaseCompon
     private _linkedItemMap;
     protected _inBrushElementsMap: {
         [brushName: string]: {
-            [elementKey: string]: IElement;
+            [elementKey: string]: IMarkGraphic;
         };
     };
     protected _outOfBrushElementsMap: {
-        [elementKey: string]: IElement;
+        [elementKey: string]: IMarkGraphic;
     };
     protected _linkedInBrushElementsMap: {
         [brushName: string]: {
-            [elementKey: string]: IElement;
+            [elementKey: string]: IMarkGraphic;
         };
     };
     protected _linkedOutOfBrushElementsMap: {
-        [elementKey: string]: IElement;
+        [elementKey: string]: IMarkGraphic;
     };
-    private _needInitOutState;
     private _cacheInteractiveRangeAttrs;
     private _needDisablePickable;
     private _releatedAxes;
     private _regionAxisMap;
     private _axisDataZoomMap;
     private _zoomRecord;
-    init(): void;
     static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
+    init(): void;
+    private _initNeedOperatedItem;
     created(): void;
-    protected _extendDataInBrush(elementsMap: {
-        [brushName: string]: {
-            [elementKey: string]: IElement;
-        };
-    }): any[];
-    protected _extendDatumOutOfBrush(elementsMap: {
-        [elementKey: string]: IElement;
-    }): any[];
-    protected _getBrushInteractiveAttr(region: IRegion): BrushInteractiveRangeAttr;
-    protected _updateBrushComponent(region: IRegion, componentIndex: number): void;
-    protected _createBrushComponent(region: IRegion, componentIndex: number): void;
-    private _handleBrushChange;
-    private _emitEvent;
-    private _transformBrushedMarkAttr;
-    private _reconfigItem;
-    private _reconfigLinkedItem;
-    private _isBrushContainItem;
-    private _stateClamp;
-    private _setAxisAndDataZoom;
     protected _bindRegions(): void;
     protected _bindLinkedSeries(): void;
     private _initRegionAxisMap;
     private _initAxisDataZoomMap;
-    private _initNeedOperatedItem;
-    protected _initMarkBrushState(componentIndex: number, stateName: string): void;
     protected initEvent(): void;
     onRender(ctx: IModelRenderOption): void;
     changeRegions(regions: IRegion[]): void;
-    protected _getNeedClearVRenderComponents(): IGraphic[];
     _compareSpec(spec: T, prevSpec: T): {
         change: boolean;
         reMake: boolean;
@@ -83,7 +64,31 @@ export declare class Brush<T extends IBrushSpec = IBrushSpec> extends BaseCompon
         reSize: boolean;
         reCompile: boolean;
     };
-    onLayoutEnd(ctx: any): void;
+    onLayoutEnd(): void;
+    protected _updateBrushComponent(region: IRegion, componentIndex: number): void;
+    protected _createBrushComponent(region: IRegion, componentIndex: number): void;
+    protected _getBrushInteractiveAttr(region: IRegion): BrushInteractiveRangeAttr;
+    private _transformBrushedMarkAttr;
+    private _handleBrushChange;
+    protected _extendDataInBrush(elementsMap: {
+        [brushName: string]: {
+            [elementKey: string]: IMarkGraphic;
+        };
+    }): {
+        [x: string]: any;
+    }[];
+    protected _extendDatumOutOfBrush(elementsMap: {
+        [elementKey: string]: IMarkGraphic;
+    }): import("../..").Datum[];
+    private _emitEvent;
+    private _reconfigItem;
+    private _reconfigLinkedItem;
+    private _isBrushContainItem;
+    protected _initItemMap(itemMap: Record<string, IMark[]>, elementMap: Record<string, IMarkGraphic>, stateName: string): void;
+    protected _initMarkBrushState(componentIndex: number, stateName: string): void;
+    private _stateClamp;
+    private _setAxisAndDataZoom;
+    protected _getNeedClearVRenderComponents(): IGraphic[];
     clearGraphic(): void;
     clear(): void;
 }

package/types/component/brush/interface.d.ts

@@ -27,6 +27,8 @@ export interface IBrushTheme {
     delayType?: IDelayType;
     delayTime?: number;
     sizeThreshold?: number;
+    markTypeFilter?: string[];
+    onBrushEnd?: (e: any) => boolean;
 }
 export interface IBrushSpec extends IBrushTheme, IBrushDataBindSpec {
     id?: string;

package/types/component/common/trigger/desktop.d.ts

@@ -1,10 +1,8 @@
 import type { IZoomTrigger } from './interface';
 export declare class DeskTopTrigger implements IZoomTrigger {
-    pointerId: number;
     parserScrollEvent(e: any): any;
     parserZoomEvent(e: any): any;
     clearZoom(): void;
     clearScroll(): void;
     clearDrag(): void;
-    parserDragEvent(): boolean;
 }

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

@@ -1,7 +1,5 @@
 export interface IZoomTrigger {
-    pointerId: number;
     parserZoomEvent: (e: any) => any;
-    parserDragEvent: (event: any) => boolean;
     parserScrollEvent: (event: any) => any;
     clearZoom: () => void;
     clearScroll: () => void;

package/types/component/common/trigger/mobile.d.ts

@@ -1,9 +1,7 @@
 import type { IZoomTrigger } from './interface';
 export declare class MobileTrigger implements IZoomTrigger {
     private _lastScale;
-    pointerId: number;
     clearZoom(): void;
-    parserDragEvent(event: any): boolean;
     parserZoomEvent(event: any): any;
     parserScrollEvent(event: any): any;
     clearScroll(): void;

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

@@ -1,39 +1,13 @@
-import type { Dict, IBoundsLike } from '@visactor/vutils';
-import type { IModelLayoutOption, IModelRenderOption } from '../../model/interface';
+import type { IBoundsLike } from '@visactor/vutils';
+import { Tag } from '@visactor/vrender-components';
+import type { IGraphic } from '@visactor/vrender-core';
+import type { IModelRenderOption } from '../../model/interface';
 import type { IRegion } from '../../region/interface';
 import { BaseComponent } from '../base/base-component';
-import type { IPadding, StringOrNumber, TooltipActiveType, TooltipData } from '../../typings';
+import type { IPoint, StringOrNumber, TooltipActiveType, TooltipData } from '../../typings';
 import type { IComponentOption } from '../interface';
-import type { ICrossHair, CrossHairTrigger, ICartesianCrosshairSpec, IPolarCrosshairSpec, ICrosshairCategoryFieldSpec } from './interface';
+import type { ICrossHair, CrossHairTrigger, ICartesianCrosshairSpec, IPolarCrosshairSpec, ICrosshairCategoryFieldSpec, IAxisInfo, CrossHairStateByField } from './interface';
 import type { IAxis } from '../axis/interface';
-export type IBound = {
-    x1: number;
-    y1: number;
-    x2: number;
-    y2: number;
-};
-export type IAxisInfo<T> = Map<number, IBound & {
-    axis: T;
-}>;
-export interface IHair {
-    visible: boolean;
-    type: 'rect' | 'line';
-    style?: Dict<any>;
-    label?: {
-        visible: boolean;
-        formatMethod?: (text: StringOrNumber | string[], position: string) => string | string[];
-        formatter?: string | string[];
-        textStyle?: Dict<any>;
-        minWidth?: number;
-        maxWidth?: number;
-        padding?: IPadding | number | number[];
-        panel?: Dict<any>;
-        zIndex?: number;
-    };
-}
-export interface IHairRadius extends IHair {
-    smooth?: boolean;
-}
 export declare abstract class BaseCrossHair<T extends ICartesianCrosshairSpec | IPolarCrosshairSpec> extends BaseComponent<T> implements ICrossHair {
     static specKey: string;
     specKey: string;
@@ -44,6 +18,7 @@ export declare abstract class BaseCrossHair<T extends ICartesianCrosshairSpec |
     enable: boolean;
     showDefault: boolean;
     triggerOff: 'none' | number;
+    protected _stateByField: CrossHairStateByField;
     private _timer?;
     private _clickLock?;
     private _hasActive?;
@@ -51,11 +26,20 @@ export declare abstract class BaseCrossHair<T extends ICartesianCrosshairSpec |
     get enableRemain(): boolean;
     private _limitBounds;
     constructor(spec: T, options: IComponentOption);
-    protected abstract _showDefaultCrosshairBySpec(): void;
     protected abstract _layoutCrosshair(x: number, y: number, tooltipData?: TooltipData, activeType?: TooltipActiveType): void;
-    protected abstract _parseFieldInfo(): void;
-    abstract hide(): void;
+    abstract setAxisValue(v: StringOrNumber, axis: IAxis): void;
+    abstract layoutByValue(enableRemain?: boolean): void;
+    protected abstract _getDatumAtPoint(axis: IAxis, point: IPoint): number | string;
+    protected _setAllAxisValues(axisMap: IAxisInfo<IAxis>, point: IPoint, field: string): boolean;
+    clearAxisValue(): void;
+    hideCrosshair(): void;
+    showCrosshair(dimInfo: {
+        axis: IAxis;
+        value: string | number;
+    }[]): void;
     protected _getLimitBounds(): IBoundsLike;
+    protected _showDefaultCrosshairBySpec(): void;
+    protected _updateVisibleCrosshair(): void;
     protected _showDefaultCrosshair(): void;
     setAttrFromSpec(): void;
     created(): void;
@@ -84,11 +68,16 @@ export declare abstract class BaseCrossHair<T extends ICartesianCrosshairSpec |
     private _handleTooltipHideOrRelease;
     protected _getAxisInfoByField<T = IAxis>(field: 'x' | 'y' | 'category' | 'value'): IAxisInfo<T>;
     changeRegions(regions: IRegion[]): void;
-    onLayoutEnd(ctx: IModelLayoutOption): void;
+    onLayoutEnd(): void;
     onRender(ctx: IModelRenderOption): void;
     protected _releaseEvent(): void;
+    protected _parseFieldInfo(): void;
     protected _parseCrosshairSpec(): void;
     protected _parseField(field: ICrosshairCategoryFieldSpec, fieldName: string): any;
     protected _filterAxisByPoint<T>(axisMap: IAxisInfo<T>, relativeX: number, relativeY: number): IAxisInfo<T>;
+    protected _updateCrosshairLabel(label: Tag, labelAttrs: any, callback: (label: Tag) => void): void;
     protected clearOutEvent(): void;
+    protected _hideByField(field: string): void;
+    hide(): void;
+    protected _getNeedClearVRenderComponents(): IGraphic[];
 }

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

@@ -3,45 +3,25 @@ import type { IComponentOption } from '../interface';
 import { ComponentTypeEnum } from '../interface/type';
 import type { ICartesianCrosshairSpec } from './interface';
 import { BaseCrossHair } from './base';
-import type { IGraphic } from '@visactor/vrender-core';
 import type { IAxis } from '../axis/interface';
-import type { StringOrNumber, TooltipActiveType, TooltipData } from '../../typings';
+import type { IPoint, StringOrNumber, TooltipActiveType, TooltipData } from '../../typings';
 import type { IModelSpecInfo } from '../../model/interface';
 export declare class CartesianCrossHair<T extends ICartesianCrosshairSpec = ICartesianCrosshairSpec> extends BaseCrossHair<T> {
     static specKey: string;
+    static readonly builtInTheme: {
+        crosshair: import("./interface").ICrosshairTheme;
+    };
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
     name: string;
-    private _xHair;
-    private _yHair;
-    private _cacheXCrossHairInfo;
-    private _cacheYCrossHairInfo;
-    private _xCrosshair;
-    private _xTopLabel;
-    private _xBottomLabel;
-    private _yCrosshair;
-    private _yLeftLabel;
-    private _yRightLabel;
-    private _currValueX;
-    private _currValueY;
     static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
     constructor(spec: T, options: IComponentOption);
-    protected _showDefaultCrosshairBySpec(): void;
-    private _defaultCrosshair;
     private _findAllAxisContains;
-    private _getValueAt;
-    clearAxisValue(): void;
-    setAxisValue(value: StringOrNumber, axis: IAxis): void;
-    private _getAllAxisValues;
+    protected _getDatumAtPoint(axis: IAxis, point: IPoint): number | string;
+    setAxisValue(datum: StringOrNumber, axis: IAxis): void;
     protected _layoutCrosshair(relativeX: number, relativeY: number, tooltipData?: TooltipData, activeType?: TooltipActiveType): void;
-    hide(): void;
-    layoutByValue(tag?: number): void;
-    private _layoutVertical;
-    private _layoutHorizontal;
-    protected _parseFieldInfo(): void;
-    private _parseAndSetCrosshair;
-    private _updateCrosshair;
-    private _updateCrosshairLabel;
-    protected _getNeedClearVRenderComponents(): IGraphic[];
+    layoutByValue(enableRemain?: boolean): void;
+    private _layoutByField;
+    private _updateCrosshairByField;
 }
 export declare const registerCartesianCrossHair: () => void;

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

@@ -1,7 +1,72 @@
-import type { StringOrNumber } from '../../../typings';
+import type { Dict } from '@visactor/vutils';
+import type { IPadding, StringOrNumber } from '../../../typings';
 import type { IAxis } from '../../axis/interface';
+import type { LineCrosshair, RectCrosshair, Tag } from '@visactor/vrender-components';
+import type { IGroup, IRichTextGraphicAttribute, ITextGraphicAttribute } from '@visactor/vrender-core';
 export type AxisCurrentValueMap = Map<number, {
-    value: StringOrNumber;
+    datum: StringOrNumber;
     axis: IAxis;
     [key: string]: any;
 }>;
+export type IBound = {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+};
+export type IAxisInfo<T> = Map<number, IBound & {
+    axis: T;
+}>;
+export interface IHair {
+    visible: boolean;
+    type: 'rect' | 'line';
+    style?: Dict<any>;
+    label?: {
+        visible: boolean;
+        formatMethod?: (text: StringOrNumber | string[], position: string) => string | string[];
+        formatter?: string | string[];
+        textStyle?: Dict<any>;
+        minWidth?: number;
+        maxWidth?: number;
+        padding?: IPadding | number | number[];
+        panel?: Dict<any>;
+        zIndex?: number;
+    };
+    smooth?: boolean;
+}
+export interface IHairRadius extends IHair {
+    smooth?: boolean;
+}
+export interface ICrosshairLabelInfo {
+    visible: boolean;
+    text: StringOrNumber;
+    dx?: number;
+    dy?: number;
+    x?: number;
+    y?: number;
+    offset?: number;
+    defaultFormatter?: (value: StringOrNumber) => StringOrNumber;
+}
+export interface ICrosshairInfo {
+    coordRange: [number, number];
+    sizeRange: [number, number];
+    coord: number;
+    labels: Record<string, ICrosshairLabelInfo>;
+    labelsTextStyle?: Record<string, Partial<ITextGraphicAttribute> | Partial<IRichTextGraphicAttribute>>;
+    visible: boolean;
+    _isCache?: boolean;
+    axis: IAxis;
+    sides?: number;
+}
+export interface CrossHairStateItem {
+    coordKey: string;
+    anotherAxisKey: string;
+    currentValue: AxisCurrentValueMap;
+    attributes?: IHair | undefined;
+    cacheInfo?: ICrosshairInfo | undefined;
+    crosshairComp?: LineCrosshair | RectCrosshair | IGroup;
+    labelsComp?: Record<string, Tag>;
+    bandSize?: number;
+    offsetSize?: number;
+}
+export type CrossHairStateByField = Record<string, CrossHairStateItem>;

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

@@ -1,5 +1,3 @@
 export * from './spec';
 export * from './theme';
-export * from './cartesian';
-export * from './polar';
 export * from './common';

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

@@ -4,10 +4,14 @@ import type { IAxis } from '../../axis/interface';
 import type { IComponentSpec } from '../../base/interface';
 import type { IComponent } from '../../interface';
 export interface ICrossHair extends IComponent {
-    clearAxisValue?: () => void;
-    setAxisValue?: (v: StringOrNumber, axis: IAxis) => void;
-    layoutByValue?: (v?: number) => void;
-    hide?: () => void;
+    clearAxisValue: () => void;
+    setAxisValue: (v: StringOrNumber, axis: IAxis) => void;
+    layoutByValue: (enableRemain?: boolean) => void;
+    hideCrosshair: () => any;
+    showCrosshair: (dimInfo: {
+        axis: IAxis;
+        value: string | number;
+    }[]) => any;
 }
 export type CrossHairTrigger = 'click' | 'hover' | ['click', 'hover'];
 export interface ICommonCrosshairSpec extends IComponentSpec {

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

@@ -1,40 +1,27 @@
 import type { IComponentOption } from '../interface';
 import { ComponentTypeEnum } from '../interface/type';
 import type { IPolarCrosshairSpec } from './interface';
-import type { TooltipActiveType, TooltipData } from '../../typings';
+import type { IPolarAxis } from '../axis/polar/interface';
+import type { IPoint, StringOrNumber, TooltipActiveType, TooltipData } from '../../typings';
 import { BaseCrossHair } from './base';
 import type { Maybe } from '@visactor/vutils';
-import type { IGraphic } from '@visactor/vrender-core';
 import type { IModelSpecInfo } from '../../model/interface';
+import type { IAxis } from '../axis';
 export declare class PolarCrossHair<T extends IPolarCrosshairSpec = IPolarCrosshairSpec> extends BaseCrossHair<T> {
     static specKey: string;
+    static readonly builtInTheme: {
+        crosshair: import("./interface").ICrosshairTheme;
+    };
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
     name: string;
-    private _currValueAngle;
-    private _currValueRadius;
-    private _angleHair;
-    private _radiusHair;
-    private _cacheAngleCrossHairInfo;
-    private _cacheRadiusCrossHairInfo;
-    private _radiusCrosshair;
-    private _radiusLabelCrosshair;
-    private _angleCrosshair;
-    private _angleLabelCrosshair;
     static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
     constructor(spec: T, options: IComponentOption);
-    protected _showDefaultCrosshairBySpec(): void;
-    private _defaultCrosshair;
-    hide(): void;
+    setAxisValue(datum: StringOrNumber, axis: IAxis): void;
     private _findAllAxisContains;
-    private _getAllAxisValues;
-    private _getValueByAxis;
+    protected _getDatumAtPoint(axis: IPolarAxis, point: IPoint): any;
     protected _layoutCrosshair(relativeX: number, relativeY: number, tooltipData?: TooltipData, activeType?: TooltipActiveType): void;
-    layoutByValue(tag?: number): void;
-    private _layoutAngle;
-    private _layoutRadius;
-    protected _parseFieldInfo(): void;
-    private _updateCrosshairLabel;
-    protected _getNeedClearVRenderComponents(): IGraphic[];
+    layoutByValue(enableRemain?: boolean): void;
+    private _layoutByField;
 }
 export declare const registerPolarCrossHair: () => void;

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

@@ -1,34 +1,23 @@
 import type { ICartesianSeries } from '../../../series';
-import type { ILayoutPoint } from '../../../typings';
-import type { IHair } from '../base';
-import type { AxisCurrentValueMap, ICrosshairInfoX, ICrosshairInfoY } from '../interface';
-export declare const layoutByValue: (tag: number, series: ICartesianSeries, layoutStartPoint: ILayoutPoint, currValueX: AxisCurrentValueMap, currValueY: AxisCurrentValueMap, xHair: IHair, yHair: IHair, enableRemain?: boolean, cacheXCrossHairInfo?: ICrosshairInfoX, cacheYCrossHairInfo?: ICrosshairInfoY) => {
-    x: ICrosshairInfoX;
-    y: ICrosshairInfoY;
-    offsetWidth: number;
-    offsetHeight: number;
-    bandWidth: number;
-    bandHeight: number;
-};
-export declare const layoutVerticalCrosshair: (xHair: IHair, crosshairInfo: ICrosshairInfoX, bandWidth: number, offsetWidth: number) => {
+import { type ILayoutPoint } from '../../../typings';
+import type { CrossHairStateByField, CrossHairStateItem } from '../interface';
+import type { IDimensionData } from '../../../event/events/dimension/interface';
+export declare const layoutByValue: (stateByField: CrossHairStateByField, series: ICartesianSeries, layoutStartPoint: ILayoutPoint, enableRemain?: boolean) => CrossHairStateByField;
+export declare const layoutCrosshair: (stateItem: CrossHairStateItem) => {
     visible: boolean;
     start: {
-        x: number;
-        y: number;
+        [x: string]: number;
     };
     end: {
-        x: number;
-        y: number;
+        [x: string]: number;
     };
 };
-export declare const layoutHorizontalCrosshair: (yHair: IHair, crosshairInfo: ICrosshairInfoY, bandHeight: number, offsetHeight: number) => {
+export declare const getCartesianCrosshairRect: (dimensionData: IDimensionData, layoutStartPoint: ILayoutPoint) => {
     visible: boolean;
     start: {
-        x: number;
-        y: number;
+        [x: string]: number;
     };
     end: {
-        x: number;
-        y: number;
+        [x: string]: number;
     };
 };

package/types/component/crosshair/utils/common.d.ts

@@ -2,8 +2,7 @@ import type { Tag } from '@visactor/vrender-components';
 import type { IBoundsLike } from '@visactor/vutils';
 import type { Datum } from '../../../typings';
 import type { ICrosshairTheme } from '../interface';
-import type { ITheme } from '../../../theme';
 export declare function limitTagInBounds(shape: Tag, bounds: IBoundsLike): void;
 export declare function getDatumByValue(data: Datum[], value: number, startField: string, endField?: string): Datum | null;
-export declare const getCartesianCrosshairTheme: (chartTheme: ITheme, chartSpec: any) => ICrosshairTheme;
-export declare const getPolarCrosshairTheme: (chartTheme: ITheme, chartSpec: any) => ICrosshairTheme;
+export declare const getCartesianCrosshairTheme: (getTheme: (...keys: string[]) => any, chartSpec: any) => ICrosshairTheme;
+export declare const getPolarCrosshairTheme: (getTheme: (...keys: string[]) => any, chartSpec: any) => ICrosshairTheme;

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

@@ -1,18 +1,19 @@
 import type { IPolarSeries } from '../../../series';
-import type { IHair, IHairRadius } from '../base';
-import type { AxisCurrentValueMap, IPolarCrosshairInfo } from '../interface';
-export declare const layoutByValue: (series: IPolarSeries, currValueAngle: AxisCurrentValueMap, currValueRadius: AxisCurrentValueMap, angleHair: IHair, radiusHair: IHair, enableRemain?: boolean, cacheAngleCrossHairInfo?: IPolarCrosshairInfo, cacheRadiusCrossHairInfo?: IPolarCrosshairInfo) => {
-    angle: IPolarCrosshairInfo;
-    radius: IPolarCrosshairInfo;
-};
-export declare const layoutAngleCrosshair: (angleHair: IHair, crosshairInfo: IPolarCrosshairInfo) => {
-    center: import("../../../typings").IPoint;
+import type { CrossHairStateByField, CrossHairStateItem } from '../interface';
+import type { ILayoutPoint } from '../../../typings/layout';
+export declare const layoutByValue: (stateByField: CrossHairStateByField, series: IPolarSeries, enableRemain?: boolean) => void;
+export declare const layoutCrosshair: (stateItem: CrossHairStateItem, layoutStartPoint: ILayoutPoint, smooth?: boolean) => {
+    center: {
+        x: number;
+        y: number;
+    };
     innerRadius: number;
     radius: number;
     startAngle: number;
     endAngle: number;
     start?: undefined;
     end?: undefined;
+    sides?: undefined;
 } | {
     start: {
         x: number;
@@ -27,11 +28,17 @@ export declare const layoutAngleCrosshair: (angleHair: IHair, crosshairInfo: IPo
     radius?: undefined;
     startAngle?: undefined;
     endAngle?: undefined;
-};
-export declare const layoutRadiusCrosshair: (radiusHair: IHairRadius, crosshairInfo: IPolarCrosshairInfo) => {
-    center: import("../../../typings").IPoint;
+    sides?: undefined;
+} | {
+    center: {
+        x: number;
+        y: number;
+    };
     startAngle: number;
     endAngle: number;
     radius: number;
     sides: number;
+    innerRadius?: undefined;
+    start?: undefined;
+    end?: undefined;
 };

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

@@ -39,5 +39,6 @@ export declare class CustomMark extends BaseComponent<ICustomMarkSpec<EnableMark
         x2: number;
         y2: number;
     };
+    getVRenderComponents(): any[];
 }
 export declare const registerCustomMark: () => void;

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

@@ -79,7 +79,7 @@ export declare abstract class DataFilterBaseComponent<T extends IDataFilterCompo
     protected _initEvent(): void;
     protected _initData(): void;
     setAttrFromSpec(): void;
-    protected _statePointToData(state: number): any;
+    statePointToData(state: number): any;
     dataToStatePoint(data: number | string): number;
     protected _modeCheck(statePoint: 'start' | 'end', mode: string): any;
     protected _setStateFromSpec(): void;
@@ -105,7 +105,7 @@ export declare abstract class DataFilterBaseComponent<T extends IDataFilterCompo
         zoomDelta: number;
         zoomX?: number;
         zoomY?: number;
-    }) => void;
+    }, e?: BaseEventParams['event']) => void;
     protected _handleChartScroll: (params: {
         scrollX: number;
         scrollY: number;
@@ -115,8 +115,8 @@ export declare abstract class DataFilterBaseComponent<T extends IDataFilterCompo
     protected _initCommonEvent(): void;
     updateLayoutAttribute(): void;
     protected _autoVisible(isShown: boolean): void;
-    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect, ctx: any): void;
-    onLayoutEnd(ctx: any): void;
+    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect): void;
+    onLayoutEnd(): void;
     getBoundsInRect(rect: ILayoutRect): IBoundsLike;
     hide(): void;
     show(): void;

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

@@ -13,6 +13,9 @@ export declare class DataZoom<T extends IDataZoomSpec = IDataZoomSpec> extends D
     type: ComponentTypeEnum;
     name: string;
     readonly transformerConstructor: typeof DataZoomSpecTransformer;
+    static readonly builtInTheme: {
+        dataZoom: import("./interface").IDataZoomTheme;
+    };
     static specKey: string;
     specKey: string;
     layoutZIndex: number;
@@ -28,7 +31,7 @@ export declare class DataZoom<T extends IDataZoomSpec = IDataZoomSpec> extends D
     constructor(spec: T, options: IComponentOption);
     created(): void;
     setAttrFromSpec(): void;
-    onLayoutEnd(ctx: any): void;
+    onLayoutEnd(): void;
     protected _initValueScale(): void;
     protected _updateScaleRange(): void;
     protected _computeDomainOfValueScale(): unknown[];

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

@@ -1,4 +1,3 @@
-import type { IMarkSpec } from '../../../typings/spec';
 import type { IAreaMarkSpec, ILineMarkSpec, IRectMarkSpec, ISymbolMarkSpec, ITextMarkSpec } from '../../../typings/visual';
 import type { IComponentSpec } from '../../base/interface';
 import type { ComponentThemeWithDirection, IComponent } from '../../interface';
@@ -41,13 +40,13 @@ export interface IDataZoomSpec extends IDataZoomStyle, IDataFilterComponentSpec
     valueField?: string;
     startText?: {
         padding?: number;
-        style?: IMarkSpec<ITextMarkSpec>;
+        style?: ITextMarkSpec;
         formatMethod?: (text: string | number) => string | string[];
         formatter?: string | string[];
     };
     endText?: {
         padding?: number;
-        style?: IMarkSpec<ITextMarkSpec>;
+        style?: ITextMarkSpec;
         formatMethod?: (text: string | number) => string | string[];
         formatter?: string | string[];
     };