@visactor/vchart-types 1.6.0-beta.0

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

@@ -0,0 +1,85 @@
+import type { IBaseScale } from '@visactor/vscale';
+import type { LayoutItem } from '../../../model/layout-item';
+import type { IPolarAxis, IPolarAxisCommonSpec, IPolarAxisCommonTheme } from './interface';
+import type { IComponentOption } from '../../interface';
+import { ComponentTypeEnum } from '../../interface/type';
+import type { IPolarSeries } from '../../../series/interface';
+import type { IPoint, IPolarOrientType, IPolarPoint, StringOrNumber } from '../../../typings';
+import type { IEffect } from '../../../model/interface';
+import { AxisComponent } from '../base-axis';
+import type { ITick } from '../interface';
+export declare abstract class PolarAxis<T extends IPolarAxisCommonSpec = IPolarAxisCommonSpec> extends AxisComponent<T> implements IPolarAxis {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    protected readonly _defaultBandPosition = 0;
+    protected readonly _defaultBandInnerPadding = 0;
+    protected readonly _defaultBandOuterPadding = 0;
+    layoutType: LayoutItem['layoutType'];
+    layoutZIndex: number;
+    protected _tick: ITick | undefined;
+    protected _center: IPoint | null;
+    get center(): IPoint;
+    protected _startAngle: number;
+    get startAngle(): number;
+    protected _endAngle: number;
+    get endAngle(): number;
+    protected _theme: IPolarAxisCommonTheme;
+    protected _orient: IPolarOrientType;
+    getOrient(): IPolarOrientType;
+    protected _groupScales: IBaseScale[];
+    getGroupScales(): IBaseScale[];
+    protected _refAngleAxis: IPolarAxis;
+    setRefAngleAxis(axes: IPolarAxis): this;
+    private _axisStyle;
+    private _gridStyle;
+    static createAxis(spec: any, options: IComponentOption): IPolarAxis;
+    static createComponent(spec: any, options: IComponentOption): IPolarAxis | IPolarAxis[];
+    effect: IEffect;
+    setAttrFromSpec(): void;
+    setLayoutStartPosition(pos: Partial<IPoint>): void;
+    onLayoutEnd(ctx: any): void;
+    onRender(ctx: any): void;
+    changeRegions(): void;
+    protected _initData(): void;
+    afterCompile(): void;
+    protected updateScaleRange(): boolean;
+    protected collectData(depth: number): {
+        min: number;
+        max: number;
+        values: any[];
+    }[];
+    protected abstract computeDomain(data: {
+        min: number;
+        max: number;
+        values: any[];
+    }[]): StringOrNumber[];
+    protected updateSeriesScale(): void;
+    protected getSeriesStatisticsField(s: IPolarSeries): string[];
+    protected initGroupScales(): void;
+    protected axisHelper(): {
+        isContinuous: boolean;
+        dataToPosition: (values: any[]) => number;
+        coordToPoint: (point: IPolarPoint) => IPoint;
+        pointToCoord: (point: IPoint) => IPolarPoint;
+        center: () => IPoint;
+        getScale: (depth: number) => IBaseScale;
+        getAxisId: () => number;
+    };
+    positionToData(position: IPoint): number;
+    coordToPoint(point: IPolarPoint): IPoint;
+    pointToCoord(point: IPoint): IPolarPoint;
+    getCenter(): IPoint;
+    getOuterRadius(): number;
+    getInnerRadius(): number;
+    tickValues(): number[];
+    updateLayoutAttribute(): void;
+    private _layoutAngleAxis;
+    private _layoutRadiusAxis;
+    private computeLayoutOuterRadius;
+    private computeLayoutInnerRadius;
+    private getRefLayoutRect;
+    private getRefSeriesRadius;
+    private _update;
+    invert(value: number): number;
+}

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

@@ -0,0 +1,33 @@
+import { BandScale } from '@visactor/vscale';
+import { ComponentTypeEnum } from '../../interface/type';
+import { PolarAxis } from './axis';
+import { BandAxisMixin } from '../mixin/band-axis-mixin';
+import type { StringOrNumber } from '../../../typings';
+import type { IPolarBandAxisSpec } from './interface';
+export interface PolarBandAxis<T extends IPolarBandAxisSpec = IPolarBandAxisSpec> extends Pick<BandAxisMixin, 'valueToPosition' | 'updateGroupScaleRange' | 'getPosition' | 'calcScales' | 'computeBandDomain'>, PolarAxis<T> {
+}
+export declare class PolarBandAxis<T extends IPolarBandAxisSpec = IPolarBandAxisSpec> extends PolarAxis<T> {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    protected _scale: BandScale;
+    protected _scales: BandScale[];
+    protected computeDomain(data: {
+        min: number;
+        max: number;
+        values: any[];
+    }[]): StringOrNumber[];
+    protected updateScaleRange(): boolean;
+    protected axisHelper(): {
+        getBandwidth: (depth: number) => number;
+        isContinuous: boolean;
+        dataToPosition: (values: any[]) => number;
+        coordToPoint: (point: import("../../../typings").IPolarPoint) => import("../../../typings").IPoint;
+        pointToCoord: (point: import("../../../typings").IPoint) => import("../../../typings").IPolarPoint;
+        center: () => import("../../../typings").IPoint;
+        getScale: (depth: number) => import("@visactor/vscale").IBaseScale;
+        getAxisId: () => number;
+    };
+    protected initScales(): void;
+    transformScaleDomain(): void;
+}
+export declare const registerPolarBandAxis: () => void;

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

@@ -0,0 +1,3 @@
+export declare const DEFAULT_BAND_INNER_PADDING = 0;
+export declare const DEFAULT_BAND_OUTER_PADDING = 0;
+export declare const DEFAULT_BAND_POSITION = 0;

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

@@ -0,0 +1,4 @@
+export * from './axis';
+export * from './linear-axis';
+export * from './band-axis';
+export * from './interface';

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

@@ -0,0 +1,34 @@
+import type { IBaseScale } from '@visactor/vscale';
+import type { IComponent } from '../../../interface';
+import type { IPoint, IPolarOrientType, IPolarPoint } from '../../../../typings';
+import type { IGrid } from '../../interface';
+import type { ICompilableData } from '../../../../compile/data';
+export type IPolarGrid = IGrid & {
+    smooth?: boolean;
+};
+export interface IPolarAxisHelper {
+    isContinuous: boolean;
+    dataToPosition: (values: any, cfg?: any) => number;
+    coordToPoint: (point: IPolarPoint) => IPoint;
+    pointToCoord: (point: IPoint) => IPolarPoint;
+    center: () => IPoint;
+    getScale: (depth?: number) => IBaseScale;
+    getBandwidth?: (depth?: number) => number;
+    getAxisId: () => number;
+}
+export interface IPolarAxis extends IComponent {
+    startAngle: number;
+    endAngle: number;
+    getOrient: () => IPolarOrientType;
+    getScale: () => IBaseScale;
+    setRefAngleAxis: (axes: IPolarAxis) => this;
+    tickValues: () => number[];
+    getCenter: () => IPoint;
+    getOuterRadius: () => number;
+    getInnerRadius: () => number;
+    dataToPosition: (values: any[]) => number;
+    positionToData: (position: IPoint) => any;
+    getTickData: () => ICompilableData;
+    coordToPoint: (point: IPolarPoint) => IPoint;
+    pointToCoord: (point: IPoint) => IPolarPoint;
+}

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

@@ -0,0 +1,4 @@
+export * from './common';
+export * from './spec';
+export * from './theme';
+export * from '../../cartesian/interface/common';

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

@@ -0,0 +1,21 @@
+import type { IPoint, IPolarOrientType } from '../../../../typings';
+import type { IBandAxisSpec, IDomainLine, ILinearAxisSpec, ITitle, ILabel, ICommonAxisSpec } from '../../interface';
+import type { IPolarGrid } from './common';
+export type IPolarAxisSpec = IPolarLinearAxisSpec | IPolarBandAxisSpec;
+export type IPolarAxisCommonSpec = Omit<ICommonAxisSpec, 'center'> & {
+    inside?: boolean;
+    orient: IPolarOrientType;
+    grid?: IPolarGrid;
+    radius?: number;
+    subGrid?: IPolarGrid;
+    domainLine?: IDomainLine;
+    label?: ILabel;
+    title?: ITitle;
+    innerRadius?: number;
+    outerRadius?: number;
+    center?: IPoint;
+    startAngle?: number;
+    endAngle?: number;
+};
+export type IPolarLinearAxisSpec = IPolarAxisCommonSpec & ILinearAxisSpec;
+export type IPolarBandAxisSpec = IPolarAxisCommonSpec & IBandAxisSpec;

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

@@ -0,0 +1,11 @@
+import type { IDomainLine, ITick, ITitle, ILabel } from '../../interface';
+import type { IPolarGrid } from './common';
+export interface IPolarAxisCommonTheme {
+    grid?: IPolarGrid;
+    subGrid?: IPolarGrid;
+    domainLine?: IDomainLine;
+    label?: ILabel;
+    title?: ITitle;
+    tick?: ITick;
+    subTick?: ITick;
+}

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

@@ -0,0 +1,23 @@
+import { LinearScale } from '@visactor/vscale';
+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 declare class PolarLinearAxis<T extends IPolarLinearAxisSpec = IPolarLinearAxisSpec> extends PolarAxis<T> {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    protected _zero: boolean;
+    protected _nice: boolean;
+    protected _scale: LinearScale;
+    protected _groupScales: LinearScale[];
+    setAttrFromSpec(): void;
+    protected initScales(): void;
+    protected computeDomain(data: {
+        min: number;
+        max: number;
+        values: any[];
+    }[]): number[];
+}
+export declare const registerPolarLinearAxis: () => void;

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

@@ -0,0 +1,28 @@
+import type { IOrientType, IPolarOrientType } from '../../typings';
+import type { AxisType, ICommonAxisSpec, ILinearAxisSpec } from './interface';
+import type { IModelOption } from '../../model/interface';
+export declare const DEFAULT_TITLE_STYLE: {
+    left: {
+        textAlign: string;
+        textBaseline: string;
+    };
+    right: {
+        textAlign: string;
+        textBaseline: string;
+    };
+    radius: {};
+    angle: {};
+};
+export declare function transformAxisLineStyle(lineCfg: any): any;
+export declare function getAxisLabelOffset(axisSpec: ICommonAxisSpec): number;
+export declare function getLinearAxisSpecDomain(axisSpec: ILinearAxisSpec, defaultDomain?: {
+    min?: number;
+    max?: number;
+}): {
+    min: number;
+    max: number;
+};
+export declare function isValidCartesianAxis(spec: any): boolean;
+export declare function isValidPolarAxis(spec: any): boolean;
+export declare const getCartesianAxisTheme: (orient: IOrientType, type: AxisType, option: Partial<IModelOption>) => any;
+export declare const getPolarAxisTheme: (orient: IPolarOrientType, type: AxisType, option: Partial<IModelOption>) => any;

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

@@ -0,0 +1,45 @@
+import type { IGraphic, IGroup } from '@visactor/vrender-core';
+import { BaseModel } from '../../model/base-model';
+import type { IRegion } from '../../region/interface';
+import type { IComponent, IComponentOption } from '../interface';
+import type { BaseEventParams } from '../../event/interface';
+import type { IComponentPluginService, IComponentPlugin } from '../../plugin/components/interface';
+import type { IGroupMark } from '@visactor/vgrammar-core';
+import type { IAnimate } from '../../animation/interface';
+import type { Datum } from '../../typings';
+import type { IComponentSpec } from './interface';
+export declare abstract class BaseComponent<T extends IComponentSpec = IComponentSpec> extends BaseModel<T> implements IComponent {
+    name: string;
+    readonly modelType: string;
+    pluginService?: IComponentPluginService;
+    protected _option: IComponentOption;
+    protected _regions: IRegion[];
+    getRegions(): IRegion[];
+    protected _container: IGroup;
+    created(): void;
+    animate?: IAnimate;
+    constructor(spec: T, options: IComponentOption);
+    abstract changeRegions(regions: IRegion[]): void;
+    abstract getVRenderComponents(): IGraphic[];
+    protected callPlugin(cb: (plugin: IComponentPlugin) => void): void;
+    protected eventPos(markEventParams: BaseEventParams): {
+        x: number;
+        y: number;
+    };
+    protected _getTheme(): any;
+    protected _mergeThemeToSpec(): void;
+    protected getContainer(): IGroup;
+    _compareSpec(): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    release(): void;
+    clear(): void;
+    compile(): void;
+    compileMarks(group?: string | IGroupMark): void;
+    protected _delegateEvent: (component: IGraphic, event: any, type: string, item?: any, datum?: Datum) => void;
+    getGraphicBounds(): import("@visactor/vutils").IBoundsLike;
+}

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

@@ -0,0 +1 @@
+export * from './base-component';

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

@@ -0,0 +1,8 @@
+import type { IModelSpec } from '../../model/interface';
+import type { StringOrNumber } from '../../typings';
+export interface IComponentSpec extends IModelSpec {
+    regionIndex?: number | number[];
+    regionId?: StringOrNumber | StringOrNumber[];
+    seriesIndex?: number | number[];
+    seriesId?: StringOrNumber | StringOrNumber[];
+}

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

@@ -0,0 +1,3 @@
+import type { IModelOption } from '../../model/interface';
+import { ComponentTypeEnum } from '../interface/type';
+export declare function getComponentThemeFromGlobalTheme(type: ComponentTypeEnum, option: Partial<IModelOption>, componentSpec: any): any;

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

@@ -0,0 +1,79 @@
+import type { LayoutItem } from '../../model/layout-item';
+import { BaseComponent } from '../base/base-component';
+import type { IComponentOption } from '../interface';
+import { ComponentTypeEnum } from '../interface/type';
+import { Brush as BrushComponent } from '@visactor/vrender-components';
+import type { IModelRenderOption } 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 { BrushInteractiveRangeAttr, IBrush, IBrushSpec } from './interface';
+export declare class Brush extends BaseComponent<IBrushSpec> implements IBrush {
+    layoutType: LayoutItem['layoutType'];
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    layoutZIndex: LayoutItem['layoutZIndex'];
+    static speckey: string;
+    protected _brushComponents: BrushComponent[];
+    protected _relativeRegions: IRegion[];
+    protected _linkedSeries: ISeries[];
+    private _itemMap;
+    private _linkedItemMap;
+    protected _inBrushElementsMap: {
+        [brushName: string]: {
+            [elementKey: string]: IElement;
+        };
+    };
+    protected _outOfBrushElementsMap: {
+        [elementKey: string]: IElement;
+    };
+    protected _linkedInBrushElementsMap: {
+        [brushName: string]: {
+            [elementKey: string]: IElement;
+        };
+    };
+    protected _linkedOutOfBrushElementsMap: {
+        [elementKey: string]: IElement;
+    };
+    private _needInitOutState;
+    private _cacheInteractiveRangeAttrs;
+    private _needEnablePickable;
+    init(): void;
+    static createComponent(spec: any, options: IComponentOption): Brush[];
+    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 _transformBrushedMarkAttr;
+    private _reconfigItem;
+    private _reconfigLinkedItem;
+    private _isBrushContainItem;
+    protected _bindRegions(): void;
+    protected _bindLinkedSeries(): void;
+    private _initNeedOperatedItem;
+    protected _initMarkBrushState(componentIndex: number, stateName: string): void;
+    protected initEvent(): void;
+    onRender(ctx: IModelRenderOption): void;
+    changeRegions(regions: IRegion[]): void;
+    getVRenderComponents(): IGraphic[];
+    _compareSpec(): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    onLayoutEnd(ctx: any): void;
+    clear(): void;
+}
+export declare const registerBrush: () => void;

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

@@ -0,0 +1,2 @@
+export * from './brush';
+export * from './interface';

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

@@ -0,0 +1,48 @@
+import type { SymbolType } from '@visactor/vrender-core';
+import type { IPolygonMarkSpec } from '../../typings';
+import type { IComponent } from '../interface';
+import type { IDelayType } from '../../typings/event';
+export type IBrush = IComponent;
+interface IBrushDataBindSpec {
+    regionIndex?: number | number[];
+    regionId?: string | string[];
+    seriesIndex?: number | number[];
+    seriesId?: string | string[];
+    brushLinkSeriesIndex?: number | number[];
+    brushLinkSeriesId?: string | string[];
+}
+export interface IBrushTheme {
+    style?: Partial<IPolygonMarkSpec>;
+    inBrush?: selectedItemStyle;
+    outOfBrush?: selectedItemStyle;
+    brushMode?: IBrushMode;
+    brushType?: IBrushType;
+    brushMoved?: boolean;
+    removeOnClick?: boolean;
+    delayType?: IDelayType;
+    delayTime?: number;
+    sizeThreshold?: number;
+}
+export interface IBrushSpec extends IBrushTheme, IBrushDataBindSpec {
+    id?: string;
+    visible?: boolean;
+}
+export type IBrushType = 'x' | 'y' | 'rect' | 'polygon';
+export type IBrushMode = 'single' | 'multiple';
+export type selectedItemStyle = {
+    symbol?: SymbolType;
+    symbolSize?: number;
+    color?: string;
+    colorAlpha?: number;
+} & Partial<IPolygonMarkSpec>;
+export type BrushInteractiveRangeAttr = {
+    interactiveRange: {
+        minY: number;
+        maxY: number;
+        minX: number;
+        maxX: number;
+    };
+    xRange: [number, number];
+    yRange: [number, number];
+};
+export {};

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

@@ -0,0 +1,22 @@
+import type { RenderMode } from '../../../typings/spec';
+import { DeskTopTrigger } from './desktop';
+import { MobileTrigger } from './mobile';
+export declare function getDefaultTriggerEventByMode(mode: RenderMode): {
+    start: string;
+    move: string;
+    end: string;
+    zoom: string;
+    zoomEnd: string;
+    scroll: string;
+    trigger: typeof DeskTopTrigger;
+    scrollEnd?: undefined;
+} | {
+    start: string;
+    move: string;
+    end: string;
+    zoom: string;
+    zoomEnd: string;
+    scroll: string;
+    scrollEnd: string;
+    trigger: typeof MobileTrigger;
+};

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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,11 @@
+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;
+    clearDrag(): void;
+}

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

@@ -0,0 +1,77 @@
+import type { Dict, IBoundsLike } from '@visactor/vutils';
+import type { IModelLayoutOption, IModelRenderOption } from '../../model/interface';
+import type { IRegion } from '../../region/interface';
+import { BaseComponent } from '../base/base-component';
+import type { IPadding, Maybe, StringOrNumber } from '../../typings';
+import type { LayoutItem } from '../../model/layout-item';
+import type { IComponentOption } from '../interface';
+import type { ICrossHair, CrossHairTrigger, ICartesianCrosshairSpec, IPolarCrosshairSpec, ICrosshairTheme, ICrosshairCategoryFieldSpec } from './interface';
+import type { IAxis } from '../axis/interface';
+type IBound = {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+};
+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[];
+        textStyle?: Dict<any>;
+        minWidth?: number;
+        maxWidth?: number;
+        padding?: IPadding | number | number[];
+        panel?: Dict<any>;
+        zIndex?: number;
+    };
+}
+export declare abstract class BaseCrossHair<T extends ICartesianCrosshairSpec | IPolarCrosshairSpec> extends BaseComponent<T> implements ICrossHair {
+    layoutType: LayoutItem['layoutType'];
+    gridZIndex: LayoutItem['layoutZIndex'];
+    labelZIndex: LayoutItem['layoutZIndex'];
+    trigger: CrossHairTrigger;
+    enable: boolean;
+    showDefault: boolean;
+    triggerOff: CrossHairTrigger | 'none';
+    protected _theme: Maybe<ICrosshairTheme>;
+    get enableRemain(): boolean;
+    protected _crosshairConfig: ICartesianCrosshairSpec | IPolarCrosshairSpec;
+    private _limitBounds;
+    constructor(spec: T, options: IComponentOption);
+    protected abstract _showDefaultCrosshair(): void;
+    protected abstract _layoutCrosshair(x: number, y: number): void;
+    protected abstract _parseFieldInfo(): void;
+    abstract hide(): void;
+    protected _getLimitBounds(): IBoundsLike;
+    setAttrFromSpec(): void;
+    created(): void;
+    _compareSpec(): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    protected _initEvent(): void;
+    private _registerEvent;
+    private _eventOff;
+    updateLayoutAttribute(): void;
+    private _handleEvent;
+    private _getTriggerEvent;
+    protected _getAxisInfoByField<T = IAxis>(field: 'x' | 'y' | 'category' | 'value'): IAxisInfo<T>;
+    changeRegions(regions: IRegion[]): void;
+    onLayoutEnd(ctx: IModelLayoutOption): void;
+    onRender(ctx: IModelRenderOption): void;
+    protected _releaseEvent(): void;
+    protected _firstSeries<T>(): T | null;
+    protected _parseCrosshairSpec(): void;
+    protected _parseField(field: ICrosshairCategoryFieldSpec, fieldName: string): any;
+    protected _filterAxisByPoint<T>(axisMap: IAxisInfo<T>, relativeX: number, relativeY: number): IAxisInfo<T>;
+}
+export {};

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

@@ -0,0 +1,67 @@
+import type { IComponentOption } from '../interface';
+import { ComponentTypeEnum } from '../interface/type';
+import type { ICartesianCrosshairSpec } from './interface';
+import type { IHair } from './base';
+import { BaseCrossHair } from './base';
+import type { IGraphic } from '@visactor/vrender-core';
+import type { IAxis } from '../axis/interface';
+import type { StringOrNumber } from '../../typings';
+export declare class CartesianCrossHair<T extends ICartesianCrosshairSpec = ICartesianCrosshairSpec> extends BaseCrossHair<T> {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    currValueX: Map<number, {
+        v: StringOrNumber;
+        axis: IAxis;
+    }>;
+    currValueY: Map<number, {
+        v: StringOrNumber;
+        axis: IAxis;
+    }>;
+    xHair: IHair | undefined;
+    yHair: IHair | undefined;
+    private _cacheXCrossHairInfo;
+    private _cacheYCrossHairInfo;
+    private _xCrosshair;
+    private _xTopLabel;
+    private _xBottomLabel;
+    private _yCrosshair;
+    private _yLeftLabel;
+    private _yRightLabel;
+    static createComponent(spec: any, options: IComponentOption): CartesianCrossHair<any> | CartesianCrossHair<ICartesianCrosshairSpec>[];
+    constructor(spec: T, options: IComponentOption);
+    protected _showDefaultCrosshair(): void;
+    private defaultCrosshair;
+    findAllAxisContains(relativeX: number, relativeY: number): {
+        xAxisMap: Map<number, {
+            x1: number;
+            y1: number;
+            x2: number;
+            y2: number;
+        } & {
+            axis: IAxis;
+        }>;
+        yAxisMap: Map<number, {
+            x1: number;
+            y1: number;
+            x2: number;
+            y2: number;
+        } & {
+            axis: IAxis;
+        }>;
+    };
+    private getValueAt;
+    clearAxisValue(): void;
+    setAxisValue(v: StringOrNumber, axis: IAxis): void;
+    private getAllAxisValues;
+    protected _layoutCrosshair(relativeX: number, relativeY: number): void;
+    hide(): void;
+    private layoutByValue;
+    private _layoutVertical;
+    private _layoutHorizontal;
+    protected _parseFieldInfo(): void;
+    private _updateCrosshair;
+    private _updateCrosshairLabel;
+    getVRenderComponents(): IGraphic[];
+}
+export declare const registerCartesianCrossHair: () => void;