@visactor/vchart-types 0.10.0-alpha.2

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

@@ -0,0 +1,35 @@
+import type { IOrientType, IPolarOrientType } from '../../typings';
+import type { AxisType, ICommonAxisSpec, ILinearAxisSpec } from './interface';
+import type { ITheme } from '../../theme';
+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, chartTheme: ITheme) => any;
+export declare const getPolarAxisTheme: (orient: IPolarOrientType, type: AxisType, chartTheme: ITheme) => any;
+export declare const isDiscreteAxis: (axisType: AxisType) => boolean;
+export declare function getAxisItem(value: any, normalizedValue: number): {
+    id: any;
+    label: any;
+    value: number;
+    rawValue: any;
+};

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

@@ -0,0 +1,10 @@
+import { BaseModelSpecTransformer } from '../../model';
+import type { IComponentSpec } from './interface';
+export declare class BaseComponentSpecTransformer<T extends IComponentSpec = IComponentSpec, K = any> extends BaseModelSpecTransformer<T, K> {
+    getTheme(spec: T, chartSpec: any): K;
+    protected _mergeThemeToSpec(spec: T, chartSpec: any): {
+        spec: T;
+        theme: K;
+    };
+    protected _adjustPadding(spec: T): void;
+}

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

@@ -0,0 +1,47 @@
+import type { IGraphic, IGroup } from '@visactor/vrender-core';
+import type { IRegion } from '../../region/interface';
+import type { IComponent, IComponentOption } from '../interface';
+import type { IComponentPluginService, IComponentPlugin } from '../../plugin/components/interface';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { IGroupMark } from '@visactor/vgrammar-core';
+import type { IAnimate } from '../../animation/interface';
+import type { Datum, ILayoutRect } from '../../typings';
+import type { IComponentSpec } from './interface';
+import { LayoutModel } from '../../model/layout-model';
+import { BaseComponentSpecTransformer } from './base-component-transformer';
+import type { IModelRenderOption, IModelSpecInfo } from '../../model/interface';
+export declare class BaseComponent<T extends IComponentSpec = IComponentSpec> extends LayoutModel<T> implements IComponent {
+    static transformerConstructor: typeof BaseComponentSpecTransformer;
+    name: string;
+    readonly modelType: string;
+    readonly transformerConstructor: any;
+    pluginService?: IComponentPluginService;
+    static createComponent(specInfo: IModelSpecInfo, options: IComponentOption): IComponent;
+    protected _option: IComponentOption;
+    protected _regions: IRegion[];
+    getRegions(): IRegion[];
+    protected _container: IGroup;
+    created(): void;
+    animate?: IAnimate;
+    constructor(spec: T, options: IComponentOption);
+    initLayout(): void;
+    changeRegions(regions: IRegion[]): void;
+    protected _getNeedClearVRenderComponents(): IGraphic[];
+    onRender(ctx: IModelRenderOption): void;
+    getVRenderComponents(): IGraphic<Partial<import("@visactor/vrender-core").IGraphicAttribute>>[];
+    protected callPlugin(cb: (plugin: IComponentPlugin) => void): void;
+    protected getContainer(): IGroup;
+    _compareSpec(spec: T, prevSpec: T): {
+        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;
+    getBoundsInRect(rect: ILayoutRect, fullRect: ILayoutRect): IBoundsLike;
+}

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

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

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 { ITheme } from '../../theme';
+import { ComponentTypeEnum } from '../interface/type';
+export declare function getComponentThemeFromGlobalTheme(type: ComponentTypeEnum, chartTheme: ITheme, componentSpec: any, chartSpec: any): any;

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

@@ -0,0 +1,85 @@
+import { BaseComponent } from '../base/base-component';
+import { ComponentTypeEnum } from '../interface/type';
+import { Brush as BrushComponent } from '@visactor/vrender-components';
+import type { Maybe } from '@visactor/vutils';
+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 { 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 specKey: string;
+    specKey: string;
+    layoutZIndex: number;
+    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 _needDisablePickable;
+    private _relatedDataZooms;
+    init(): void;
+    static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
+    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 _setDataZoomState;
+    protected _bindRegions(): void;
+    protected _bindLinkedSeries(): void;
+    private _bindDataZoom;
+    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;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    onLayoutEnd(ctx: any): void;
+    clearGraphic(): 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,51 @@
+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[];
+    dataZoomId?: string | string[];
+    dataZoomIndex?: number | number[];
+    dataZoomRangeExpand?: number;
+}
+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,84 @@
+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, StringOrNumber } from '../../typings';
+import type { IComponentOption } from '../interface';
+import type { ICrossHair, CrossHairTrigger, ICartesianCrosshairSpec, IPolarCrosshairSpec, ICrosshairCategoryFieldSpec } 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[];
+        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 {
+    static specKey: string;
+    specKey: string;
+    layoutType: 'none';
+    gridZIndex: number;
+    labelZIndex: number;
+    trigger: CrossHairTrigger;
+    enable: boolean;
+    showDefault: boolean;
+    triggerOff: 'none' | number;
+    private _timer?;
+    private _clickLock?;
+    private _hasActive?;
+    get enableRemain(): boolean;
+    private _limitBounds;
+    constructor(spec: T, options: IComponentOption);
+    protected abstract _showDefaultCrosshairBySpec(): void;
+    protected abstract _layoutCrosshair(x: number, y: number): void;
+    protected abstract _parseFieldInfo(): void;
+    abstract hide(): void;
+    protected _getLimitBounds(): IBoundsLike;
+    protected _showDefaultCrosshair(): void;
+    setAttrFromSpec(): void;
+    created(): void;
+    _compareSpec(spec: T, prevSpec: T): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    protected _initEvent(): void;
+    private _registerEvent;
+    private _eventOff;
+    updateLayoutAttribute(): void;
+    private _handleIn;
+    private _handleClickInEvent;
+    private _handleHoverInEvent;
+    private _handleOutEvent;
+    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>;
+    protected clearEvent(): void;
+    clear(): void;
+}

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

@@ -0,0 +1,52 @@
+import type { Maybe } from '@visactor/vutils';
+import type { IComponentOption } from '../interface';
+import { ComponentTypeEnum } from '../interface/type';
+import type { ICartesianCrosshairSpec } from './interface';
+import type { IBound } from './base';
+import { BaseCrossHair } from './base';
+import type { IGraphic } from '@visactor/vrender-core';
+import type { IAxis } from '../axis/interface';
+import type { StringOrNumber } from '../../typings';
+import type { IModelSpecInfo } from '../../model/interface';
+export declare class CartesianCrossHair<T extends ICartesianCrosshairSpec = ICartesianCrosshairSpec> extends BaseCrossHair<T> {
+    static specKey: string;
+    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(v: StringOrNumber, axis: IAxis): void;
+    private _getAllAxisValues;
+    protected _layoutCrosshair(relativeX: number, relativeY: number): void;
+    hide(): void;
+    _setRegionArea(outRegion: IBound, currentValue: Map<number, {
+        v: StringOrNumber;
+        axis: IAxis;
+    }>): void;
+    layoutByValue(tag?: number): void;
+    private _layoutVertical;
+    private _layoutHorizontal;
+    private _getRectSize;
+    protected _parseFieldInfo(): void;
+    private _updateCrosshair;
+    private _updateCrosshairLabel;
+    protected _getNeedClearVRenderComponents(): IGraphic[];
+}
+export declare const registerCartesianCrossHair: () => void;

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

@@ -0,0 +1,17 @@
+import type { RenderMode } from '../../typings/spec';
+export declare function getDefaultCrosshairTriggerEventByMode(mode: RenderMode): {
+    click: string;
+    hover: string;
+    hoverOut: string;
+    clickOut: string;
+} | {
+    click: string;
+    hover: string[];
+    hoverOut: string;
+    clickOut: string;
+};
+export declare const enum LayoutType {
+    ALL = 3,
+    HORIZONTAL = 2,
+    VERTICAL = 1
+}

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

@@ -0,0 +1,3 @@
+export * from './cartesian';
+export * from './polar';
+export * from './interface';

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

@@ -0,0 +1,2 @@
+export * from './spec';
+export * from './theme';

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

@@ -0,0 +1,76 @@
+import type { IPadding, StringOrNumber, ILineMarkSpec, IRectMarkSpec, ITextMarkSpec } from '../../../typings';
+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;
+}
+export type CrossHairTrigger = 'click' | 'hover' | ['click', 'hover'];
+export interface ICommonCrosshairSpec extends IComponentSpec {
+    trigger?: CrossHairTrigger;
+    triggerOff?: CrossHairTrigger | 'none' | number;
+    lockAfterClick?: boolean;
+    labelZIndex?: number;
+    gridZIndex?: number;
+}
+export interface ICartesianCrosshairSpec extends ICommonCrosshairSpec {
+    xField?: ICrosshairCategoryFieldSpec;
+    yField?: ICrosshairCategoryFieldSpec;
+}
+export interface IPolarCrosshairSpec extends ICommonCrosshairSpec {
+    categoryField?: ICrosshairCategoryFieldSpec;
+    valueField?: ICrosshairValueFieldSpec;
+}
+export interface ICrosshairCategoryFieldSpec extends ICrosshairDataBindSpec {
+    visible: boolean;
+    line?: ICrosshairLineSpec | Omit<ICrosshairRectSpec, 'width'>;
+    label?: ICrosshairLabelSpec;
+}
+export interface ICrosshairValueFieldSpec extends ICrosshairDataBindSpec {
+    visible: boolean;
+    line?: ICrosshairLineSpec;
+    label?: ICrosshairLabelSpec;
+}
+export type ICrosshairLineStyle = Pick<ILineMarkSpec, 'stroke' | 'strokeOpacity' | 'opacity' | 'lineDash' | 'lineWidth'>;
+export type ICrosshairRectStyle = ICrosshairLineStyle & Pick<IRectMarkSpec, 'fill' | 'fillOpacity' | 'cornerRadius'>;
+export interface ICrosshairLineSpec {
+    visible?: boolean;
+    type?: 'line';
+    width?: number;
+    smooth?: boolean;
+    style?: ICrosshairLineStyle;
+}
+export type ICrosshairRectWidthCallback = (axisSize: {
+    width: number;
+    height: number;
+}, axis: IAxis) => number;
+export interface ICrosshairRectSpec {
+    visible?: boolean;
+    type?: 'rect';
+    width?: number | string | ICrosshairRectWidthCallback;
+    style?: ICrosshairRectStyle;
+}
+export interface ICrosshairLabelSpec {
+    visible?: boolean;
+    formatMethod?: (text: StringOrNumber | string[]) => string | string[];
+    style?: Partial<ITextMarkSpec>;
+    labelBackground?: ICrosshairLabelBackgroundSpec;
+}
+export interface ICrosshairLabelBackgroundSpec {
+    visible?: boolean;
+    minWidth?: number;
+    maxWidth?: number;
+    padding?: IPadding | number | number[];
+    style?: Partial<IRectMarkSpec>;
+}
+export interface ICrosshairDataBindSpec {
+    bindingAxesIndex?: number[];
+    defaultSelect?: {
+        axisIndex: number;
+        datum: StringOrNumber;
+    };
+}
+export type ICrosshairSpec = ICartesianCrosshairSpec | IPolarCrosshairSpec;

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

@@ -0,0 +1,9 @@
+import type { ICartesianCrosshairSpec, ICommonCrosshairSpec, ICrosshairCategoryFieldSpec, ICrosshairValueFieldSpec, IPolarCrosshairSpec } from '.';
+export interface ICrosshairTheme extends ICommonCrosshairSpec {
+    bandField?: Partial<ICrosshairCategoryFieldSpec>;
+    linearField?: Partial<ICrosshairValueFieldSpec>;
+    xField?: Partial<ICartesianCrosshairSpec['xField']>;
+    yField?: Partial<ICartesianCrosshairSpec['yField']>;
+    categoryField?: Partial<IPolarCrosshairSpec['categoryField']>;
+    valueField?: Partial<IPolarCrosshairSpec['valueField']>;
+}

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

@@ -0,0 +1,39 @@
+import type { IComponentOption } from '../interface';
+import { ComponentTypeEnum } from '../interface/type';
+import type { IPolarCrosshairSpec } from './interface';
+import { BaseCrossHair } from './base';
+import type { Maybe } from '@visactor/vutils';
+import type { IGraphic } from '@visactor/vrender-core';
+import type { IModelSpecInfo } from '../../model/interface';
+export declare class PolarCrossHair<T extends IPolarCrosshairSpec = IPolarCrosshairSpec> extends BaseCrossHair<T> {
+    static specKey: string;
+    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;
+    private _findAllAxisContains;
+    private _getAllAxisValues;
+    private _getValueByAxis;
+    protected _layoutCrosshair(relativeX: number, relativeY: number): void;
+    layoutByValue(tag?: number): void;
+    private _layoutVertical;
+    private _layoutHorizontal;
+    protected _parseFieldInfo(): void;
+    private _updateCrosshairLabel;
+    protected _getNeedClearVRenderComponents(): IGraphic[];
+}
+export declare const registerPolarCrossHair: () => void;

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

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

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

@@ -0,0 +1,35 @@
+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 { MarkTypeEnum } from '../../mark/interface';
+import type { Maybe } from '@visactor/vutils';
+import type { IGraphic } from '@visactor/vrender-core';
+export declare class CustomMark<T = any> extends BaseComponent<any> {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    static specKey: string;
+    specKey: string;
+    layoutType: 'none';
+    layoutZIndex: number;
+    layoutLevel: number;
+    protected _spec: (ICustomMarkSpec<Exclude<EnableMarkType, MarkTypeEnum.group>> | ICustomMarkGroupSpec)[];
+    static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
+    created(): void;
+    protected initMarks(): void;
+    private _createExtensionMark;
+    initEvent(): void;
+    _compareSpec(spec: T, prevSpec: T): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    changeRegions(regions: IRegion[]): void;
+    protected _getNeedClearVRenderComponents(): IGraphic[];
+    onRender(ctx: IModelRenderOption): void;
+    private _getMarkAttributeContext;
+}
+export declare const registerCustomMark: () => void;

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

@@ -0,0 +1 @@
+export * from './custom-mark';

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

@@ -0,0 +1,4 @@
+export declare const enum IFilterMode {
+    filter = "filter",
+    axis = "axis"
+}