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

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

@@ -1,20 +1,38 @@
-import type { IMarkStateStyle, MarkType } from '../../mark/interface';
+import type { IMark, IMarkStateStyle, MarkType } from '../../mark/interface';
 import type { IModel } from '../../model/interface';
 import type { GrammarItemCompileOption, GrammarItemInitOption, IGrammarItem } from '../interface';
 import type { DataView } from '@visactor/vdataset';
-import type { IAnimate, IAnimateArranger, IElement, IGroupMark, IMark, IMarkConfig, MarkAnimationSpec, Nil, TransformSpec } from '@visactor/vgrammar-core';
 import type { Maybe, Datum, StringOrNumber } from '../../typings';
 import type { IRegion } from '../../region/interface';
 import type { ICompilableData } from '../data/interface';
+import type { ICustomPath2D, IGraphic, IGroup } from '@visactor/vrender-core';
+import type { MarkAnimationSpec } from '../../animation/interface';
+export interface IMarkConfig {
+    clipPath?: IGraphic[] | ((graphics: IGraphic[]) => IGraphic[]);
+    clip?: boolean;
+    zIndex?: number;
+    interactive?: boolean;
+    setCustomizedShape?: (datum: any[], attrs: any, path: ICustomPath2D) => ICustomPath2D;
+    large?: boolean;
+    largeThreshold?: number;
+    progressiveStep?: number;
+    progressiveThreshold?: number;
+    support3d?: boolean;
+    graphicName?: string | ((g: IMarkConfig) => string);
+    morph?: boolean;
+    morphKey?: string;
+    morphElementKey?: string;
+    overflow?: 'scroll' | 'hidden' | 'scroll-x' | 'scroll-y';
+    skipTheme?: boolean;
+}
 export interface IMarkStateManager {
     getStateInfoList: () => IStateInfo[];
     getStateInfo: (stateValue: StateValue) => IStateInfo;
     addStateInfo: (stateInfo: IStateInfo) => void;
     changeStateInfo: (stateInfo: Partial<IStateInfo>) => void;
     clearStateInfo: (stateValues: StateValue[]) => void;
-    checkOneState: (renderNode: IElement, datum: Datum | Datum[], state: IStateInfo, isMultiMark?: boolean) => 'in' | 'out' | 'skip';
-    checkState: (renderNode: IElement, datum: Datum | Datum[]) => StateValue[];
-    updateLayoutState: (noRender?: boolean) => void;
+    checkOneState: (renderNode: IGraphic, datum: Datum[], state: IStateInfo) => 'in' | 'out' | 'skip';
+    checkState: (renderNode: IGraphic, datum: Datum[]) => StateValue[];
 }
 export interface IMarkData extends ICompilableData {
     setCompiledProductId: (name: string) => any;
@@ -33,48 +51,37 @@ export interface ICompilableMark extends IGrammarItem {
     readonly name: string;
     readonly key?: string | ((datum: Datum) => string);
     readonly model: IModel;
-    getData: () => IMarkData | undefined;
-    setData: (d: IMarkData) => void;
+    commit: (render?: boolean, recursion?: boolean) => void;
+    uncommit: () => void;
+    isCommited: () => boolean;
+    getData: () => ICompilableData | undefined;
+    setData: (d: ICompilableData) => void;
     getDataView: () => DataView | undefined;
-    setDataView: (d?: DataView, productId?: string) => void;
+    setDataView: (d: DataView) => void;
     state: IMarkStateManager;
     readonly stateStyle: IMarkStateStyle<any>;
     hasState: (state: string) => boolean;
     getState: (state: string) => any;
     updateState: (newState: Record<string, unknown>) => void;
-    updateStaticEncode: () => void;
     compileEncode: () => void;
-    updateLayoutState: (noRender?: boolean, recursion?: boolean) => void;
-    updateMarkState: (key: string) => void;
-    setTransform: (transform: TransformSpec[] | Nil) => void;
     setAnimationConfig: (config: Partial<MarkAnimationSpec>) => void;
     getAnimationConfig: () => Partial<MarkAnimationSpec>;
     getVisible: () => boolean;
     setVisible: (visible: boolean) => void;
-    getGroupKey: () => string | undefined;
     setGroupKey: (groupKey: string) => void;
     getUserId: () => StringOrNumber | undefined;
     setUserId: (id: StringOrNumber) => void;
     compile: (option?: IMarkCompileOption) => void;
-    getProduct: () => Maybe<IMark>;
-    getProductElements: () => Maybe<IMark['elements']>;
+    getProduct: () => Maybe<IGroup>;
     getMarks: () => ICompilableMark[];
     setSkipBeforeLayouted: (skip: boolean) => void;
-    getSkipBeforeLayouted: () => boolean;
-    setStateSortCallback: (stateSort: (stateA: string, stateB: string) => number) => void;
     getMarkConfig: () => IMarkConfig;
     setMarkConfig: (config: IMarkConfig) => void;
-    runAnimationByState: (animationState?: string) => IAnimateArranger;
-    stopAnimationByState: (animationState?: string) => IAnimate;
-    pauseAnimationByState: (animationState: string) => IAnimate;
-    resumeAnimationByState: (animationState: string) => IAnimate;
-}
-export interface IMarkDataInitOption extends ICompilableMarkOption {
-    mark: ICompilableMark;
+    getContext: () => any;
+    layout: (layoutCallback: () => void) => void;
 }
 export interface IMarkCompileOption extends GrammarItemCompileOption {
-    group?: string | IGroupMark;
-    ignoreChildren?: boolean;
+    group?: IGroup;
     context?: any;
 }
 export interface IStateInfo {
@@ -83,7 +90,11 @@ export interface IStateInfo {
     datums?: any[] | null | undefined;
     datumKeys?: string[] | null | undefined;
     items?: any[] | null | undefined;
-    filter?: ((datum: any, options: Record<string, any>) => boolean) | null | undefined;
+    filter?: ((datum: any, options: {
+        mark?: IMark;
+        type?: string;
+        renderNode?: IGraphic;
+    }) => boolean) | null | undefined;
     cache?: {
         [key: string]: {
             [key: string]: boolean;
@@ -116,7 +127,10 @@ export declare enum STATE_VALUE_ENUM {
     STATE_SELECTED = "selected",
     STATE_SELECTED_REVERSE = "selected_reverse",
     STATE_SANKEY_EMPHASIS = "selected",
-    STATE_SANKEY_EMPHASIS_REVERSE = "blur"
+    STATE_SANKEY_EMPHASIS_REVERSE = "blur",
+    STATE_HIGHLIGHT = "highlight",
+    STATE_BLUR = "blur",
+    STATE_ACTIVE = "active"
 }
 export declare enum STATE_VALUE_ENUM_REVERSE {
     STATE_HOVER_REVERSE = "hover_reverse",
@@ -130,11 +144,6 @@ export type STATE_CUSTOM = string;
 export type StateValueNot = STATE_HOVER_REVERSE | STATE_CUSTOM;
 export type StateValue = STATE_NORMAL | STATE_HOVER | STATE_CUSTOM;
 export type StateValueType = StateValue | StateValueNot;
-export interface IAttributeOpt {
-    element: IElement;
-    mark: IElement['mark'];
-    parent: IElement['mark']['group'];
-}
 export interface IModelMarkAttributeContext {
     [key: string]: unknown;
 }

package/types/compile/mark/mark-state-manager.d.ts

@@ -1,26 +1,24 @@
-import type { IElement, IMark as IVGrammarMark } from '@visactor/vgrammar-core';
+import type { IMark, IMarkGraphic } from '../../mark/interface';
 import type { Datum, StringOrNumber } from '../../typings';
-import type { IStateManagerOption } from '../signal/interface';
-import { StateManager } from '../signal/state-manager';
-import type { CompilableMark } from './compilable-mark';
 import type { IMarkStateManager, IStateInfo, StateValue } from './interface';
+import type { ICompilableInitOption } from '../interface/compilable-item';
+import { StateManager } from '../state-manager';
 export declare class MarkStateManager extends StateManager implements IMarkStateManager {
-    protected _mark: CompilableMark;
+    protected _mark: IMark;
     private _stateInfoList;
     getStateInfoList(): IStateInfo[];
-    constructor(option: IStateManagerOption, mark: CompilableMark);
+    constructor(options: ICompilableInitOption, mark: IMark);
     protected _getDefaultStateMap(): Record<string, unknown>;
     getStateInfo(stateValue: StateValue): IStateInfo;
     addStateInfo(stateInfo: IStateInfo): void;
     private _clearStateBeforeSet;
     changeStateInfo(stateInfo: Partial<IStateInfo>): void;
     clearStateInfo(stateValues: StateValue[]): void;
-    checkOneState(renderNode: IElement, datum: Datum | Datum[], state: IStateInfo, isMultiMark?: boolean): 'in' | 'out' | 'skip';
-    checkState(renderNode: IElement, datum: Datum | Datum[]): StateValue[];
-    checkDatumState(state: IStateInfo, datum: Datum | Datum[], isMultiMark: boolean): boolean;
+    protected _isMultiMark(): boolean;
+    checkOneState(renderNode: IMarkGraphic, datum: Datum[], state: IStateInfo): 'in' | 'out' | 'skip';
+    checkState(renderNode: IMarkGraphic, datum: Datum[]): StateValue[];
+    checkDatumState(state: IStateInfo, datum: Datum[]): boolean;
     checkItemsState(state: IStateInfo, item: any): boolean | undefined;
-    checkFieldsState(state: IStateInfo, datum: Datum | Datum[], item: any, isMultiMark: boolean): boolean;
-    checkLinearFieldState(domain: StringOrNumber[], key: string, datum: any, item: any, isMultiMark: boolean): boolean;
-    updateLayoutState(noRender?: boolean): void;
-    compileState(product: IVGrammarMark, stateSort?: (stateA: string, stateB: string) => number): void;
+    checkFieldsState(state: IStateInfo, datum: Datum[], item: any): boolean;
+    checkLinearFieldState(domain: StringOrNumber[], key: string, datum: any, item: any): boolean;
 }

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

@@ -2,4 +2,4 @@ import type { IAttrs, IMarkStateStyle } from '../../mark/interface';
 export declare function isAttrChangeable<T>(key: string, stateStyle: IMarkStateStyle<T>): boolean;
 export declare function isStateAttrChangeable<T>(key: string, stateStyle: Partial<IAttrs<T>>, facetField: string): boolean;
 export declare function stateInDefaultEnum(state: string): boolean;
-export declare function stateToReverse(state: string): any;
+export declare function stateToReverse(state: string): string;

package/types/compile/state-manager.d.ts

@@ -0,0 +1,11 @@
+import { CompilableBase } from './compilable-base';
+import type { ICompilableInitOption, StateValueMap } from './interface/compilable-item';
+export declare class StateManager extends CompilableBase {
+    compile(): void;
+    protected _stateMap: StateValueMap;
+    getStateMap(): StateValueMap;
+    protected _getDefaultStateMap(): StateValueMap;
+    constructor(options: ICompilableInitOption);
+    initStateMap(state?: StateValueMap): void;
+    updateState(newState: Partial<StateValueMap>, noRender?: boolean): void;
+}

package/types/compile/util.d.ts

@@ -1,2 +1,16 @@
+import type { IMorphConfig } from '../animation/spec';
+import type { IMark } from '../mark/interface';
+import type { DiffResult } from '../typings/common';
 import type { RenderMode } from '../typings/spec';
 export declare function toRenderMode(mode: RenderMode): any;
+export declare function traverseGroupMark<T>(group: IMark, apply: (mark: IMark) => T, filter?: (mark: IMark) => boolean, leafFirst?: boolean, stop?: boolean): T | undefined;
+export declare function findSimpleMarks(groups: IMark[]): IMark[];
+export declare function diffUpdateByGroup(prev: IMark[], next: IMark[], prevKey: (datum: IMark) => string, nextKey: (datum: IMark) => string): {
+    prev: IMark[];
+    next: IMark[];
+    update: {
+        prev: IMark[];
+        next: IMark[];
+    }[];
+};
+export declare function diffMarks(prevMarks: IMark[], nextMarks: IMark[], runningConfig: IMorphConfig): DiffResult<IMark[], IMark[]>;

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

@@ -4,12 +4,13 @@ import type { IGraphic } from '@visactor/vrender-core';
 import type { IOrientType, IPolarOrientType, StringOrNumber, CoordinateType } from '../../typings';
 import { BaseComponent } from '../base/base-component';
 import { CompilableData } from '../../compile/data';
-import type { IAxis, ICommonAxisSpec, ITick } from './interface';
+import { type IAxis, type ICommonAxisSpec, type ITick } from './interface';
 import { type IComponentOption } from '../interface';
 import type { ISeries } from '../../series/interface';
 import type { ITransformOptions } from '@visactor/vdataset';
 import { DataView } from '@visactor/vdataset';
 import type { IComponentMark } from '../../mark/interface/mark';
+import type { ICompilableMark } from '../../compile/mark';
 export declare abstract class AxisComponent<T extends ICommonAxisSpec & Record<string, any> = any> extends BaseComponent<T> implements IAxis {
     static specKey: string;
     specKey: string;
@@ -50,7 +51,7 @@ export declare abstract class AxisComponent<T extends ICommonAxisSpec & Record<s
     getCoordinateType(): CoordinateType;
     constructor(spec: T, options: IComponentOption);
     protected _getNeedClearVRenderComponents(): IGraphic[];
-    getVRenderComponents(): any[];
+    getVRenderComponents(): import("@visactor/vrender-core").IGroup[];
     created(): void;
     protected _shouldComputeTickData(): boolean;
     protected _initData(): void;
@@ -68,8 +69,9 @@ export declare abstract class AxisComponent<T extends ICommonAxisSpec & Record<s
     protected initEvent(): void;
     protected updateScaleDomain(): void;
     protected _clearRawDomain(): void;
-    onLayoutEnd(ctx: any): void;
+    onLayoutEnd(): void;
     protected computeData(updateType?: 'domain' | 'range' | 'force'): void;
+    protected _updateTickDataMarks(m: ICompilableMark): void;
     protected initScales(): void;
     _compareSpec(spec: T, prevSpec: T): {
         change: boolean;

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

@@ -77,7 +77,7 @@ export declare abstract class CartesianAxis<T extends ICartesianAxisCommonSpec =
     protected updateScaleRange(): boolean;
     init(option: IModelInitOption): void;
     setAttrFromSpec(): void;
-    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect, ctx: any): void;
+    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect): void;
     protected getSeriesStatisticsField(s: ICartesianSeries): string[];
     protected _tickTransformOption(): ICartesianTickDataOpt;
     protected axisHelper(): IAxisHelper;

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

@@ -16,6 +16,7 @@ export declare class CartesianTimeAxis<T extends ICartesianTimeAxisSpec = ICarte
     setAttrFromSpec(): void;
     protected _initData(): void;
     protected computeData(updateType?: 'range' | 'domain' | 'force'): void;
+    created(): void;
     protected _getLabelFormatMethod(): any;
     protected getLabelItems(length: number): any[];
     protected registerTicksTransform(): string;

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

@@ -48,3 +48,11 @@ export interface ITickCalculationCfg {
 export interface IBandAxisLayer extends Omit<ITickCalculationCfg, 'noDecimals' | 'tickMode'> {
     visible?: boolean;
 }
+export declare enum AxisEnum {
+    lineAxis = "lineAxis",
+    circleAxis = "circleAxis"
+}
+export declare enum GridEnum {
+    lineAxisGrid = "lineAxisGrid",
+    circleAxisGrid = "circleAxisGrid"
+}

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

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

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

@@ -6,7 +6,7 @@ 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 { 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';
@@ -23,19 +23,19 @@ 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;
@@ -49,12 +49,14 @@ export declare class Brush<T extends IBrushSpec = IBrushSpec> extends BaseCompon
     created(): void;
     protected _extendDataInBrush(elementsMap: {
         [brushName: string]: {
-            [elementKey: string]: IElement;
+            [elementKey: string]: IMarkGraphic;
         };
-    }): any[];
+    }): {
+        [x: string]: any;
+    }[];
     protected _extendDatumOutOfBrush(elementsMap: {
-        [elementKey: string]: IElement;
-    }): any[];
+        [elementKey: string]: IMarkGraphic;
+    }): import("../../typings").Datum[];
     protected _getBrushInteractiveAttr(region: IRegion): BrushInteractiveRangeAttr;
     protected _updateBrushComponent(region: IRegion, componentIndex: number): void;
     protected _createBrushComponent(region: IRegion, componentIndex: number): void;
@@ -83,7 +85,7 @@ export declare class Brush<T extends IBrushSpec = IBrushSpec> extends BaseCompon
         reSize: boolean;
         reCompile: boolean;
     };
-    onLayoutEnd(ctx: any): void;
+    onLayoutEnd(): void;
     clearGraphic(): void;
     clear(): 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(v?: number): 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,22 @@ 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 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[];
+    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: (v?: number) => void;
+    hideCrosshair: () => any;
+    showCrosshair: (dimInfo: {
+        axis: IAxis;
+        value: string | number;
+    }[]) => any;
 }
 export type CrossHairTrigger = 'click' | 'hover' | ['click', 'hover'];
 export interface ICommonCrosshairSpec extends IComponentSpec {