@visactor/vchart-types 1.7.1 → 1.7.3

package/types/animation/utils.d.ts

@@ -8,6 +8,7 @@ import type { ISeriesMarkAttributeContext } from '../compile/mark';
 export declare const AnimationStates: string[];
 export declare function animationConfig<Preset extends string>(defaultConfig?: MarkAnimationSpec, userConfig?: Partial<Record<IAnimationState, boolean | IStateAnimateSpec<Preset> | IAnimationConfig | IAnimationConfig[]>>, params?: {
     dataIndex: (datum: any) => number;
+    dataCount: () => number;
 }): MarkAnimationSpec;
 export declare function userAnimationConfig<M extends string, Preset extends string>(markName: SeriesMarkNameEnum | string, spec: IAnimationSpec<M, Preset>, ctx: ISeriesMarkAttributeContext): Partial<Record<"none" | "normal" | "state" | "update" | "appear" | "enter" | "exit" | "disappear", boolean | IAnimationConfig | IAnimationConfig[] | IStateAnimateSpec<string>>>;
 export declare function shouldMarkDoMorph(spec: ISeriesSpec & IAnimationSpec<string, string>, markName: string): boolean;

package/types/chart/bar/bar-3d.d.ts

@@ -1,5 +1,5 @@
-import { CartesianChart } from '../cartesian/cartesian';
-export declare class Bar3dChart extends CartesianChart {
+import { BarChart } from './bar';
+export declare class Bar3dChart extends BarChart {
     static readonly type: string;
     static readonly view: string;
     readonly type: string;

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

@@ -109,7 +109,7 @@ export declare class BaseChart extends CompilableBase implements IChart {
     updateGlobalScaleDomain(): void;
     updateGlobalScale(result: IUpdateSpecResult): void;
     updateGlobalScaleTheme(): void;
-    updateSpec(spec: any, morphConfig?: IMorphConfig): {
+    updateSpec(spec: any): {
         change: boolean;
         reMake: boolean;
         reRender: boolean;
@@ -125,10 +125,7 @@ export declare class BaseChart extends CompilableBase implements IChart {
     protected isValidSeries(seriesType: string): boolean;
     protected _getDefaultSeriesSpec(spec: any): any;
     private _updateLayoutRect;
-    setCurrentTheme(reInit?: boolean): void;
-    protected setRegionTheme(reInit?: boolean): void;
-    protected setComponentTheme(reInit?: boolean): void;
-    protected setSeriesTheme(reInit?: boolean): void;
+    setCurrentTheme(): void;
     clear(): void;
     compile(): void;
     afterCompile(): void;

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

@@ -10,6 +10,6 @@ export interface ICartesianChartSpec extends IChartSpec {
     axes?: ICartesianAxisSpec[];
     crosshair?: ICartesianCrosshairSpec | ICartesianCrosshairSpec[];
     markLine?: IMarkLineSpec | IMarkLineSpec[];
-    markArea?: IMarkAreaSpec | IMarkLineSpec[];
+    markArea?: IMarkAreaSpec | IMarkAreaSpec[];
     markPoint?: IMarkPointSpec | IMarkPointSpec[];
 }

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

@@ -1,6 +1,6 @@
 import type { IEvent } from '../../event/interface';
 import type { LayoutCallBack } from '../../layout/interface';
-import type { IRunningConfig as IMorphConfig, IView } from '@visactor/vgrammar-core';
+import type { IView } from '@visactor/vgrammar-core';
 import type { IParserOptions } from '@visactor/vdataset/es/parser';
 import type { IComponent } from '../../component/interface';
 import type { IMark } from '../../mark/interface';
@@ -73,13 +73,13 @@ export interface IChart extends ICompilable {
     getAllModels: () => IModel[];
     getMarkById: (id: number) => IMark | undefined;
     getAllMarks: () => IMark[];
-    updateSpec: (spec: any, morphConfig?: IMorphConfig) => IUpdateSpecResult;
+    updateSpec: (spec: any) => IUpdateSpecResult;
     updateState: (state: Record<string, Omit<IMarkStateSpec<unknown>, 'style'>>, filter?: (series: ISeries, mark: IMark, stateKey: string) => boolean) => void;
     setSelected: (datum: MaybeArray<any> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier) => void;
     setHovered: (datum: MaybeArray<Datum> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier) => void;
     updateViewBox: (viewBox: IBoundsLike, reLayout: boolean) => void;
     getCanvas: () => HTMLCanvasElement | undefined;
-    setCurrentTheme: (reInit?: boolean) => void;
+    setCurrentTheme: () => void;
     getSeriesData: (id: StringOrNumber | undefined, index: number | undefined) => DataView | undefined;
     setDimensionIndex: (value: StringOrNumber, opt: DimensionIndexOption) => void;
 }

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

@@ -50,7 +50,8 @@ export declare abstract class AxisComponent<T extends ICommonAxisSpec & Record<s
     protected _axisMark: IComponentMark;
     protected _gridMark: IComponentMark;
     constructor(spec: T, options: IComponentOption);
-    getVRenderComponents(): IGraphic[];
+    protected _getNeedClearVRenderComponents(): IGraphic[];
+    getVRenderComponents(): any[];
     created(): void;
     protected isSeriesDataEnable(): boolean;
     protected setSeriesAndRegionsFromSpec(): void;

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

@@ -101,5 +101,5 @@ export declare abstract class CartesianAxis<T extends ICartesianAxisCommonSpec =
     onDataUpdate(): void;
     protected _transformSpec(): void;
     private _appendAxisUnit;
-    getVRenderComponents(): IGraphic[];
+    protected _getNeedClearVRenderComponents(): IGraphic[];
 }

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

@@ -9,5 +9,3 @@ export declare function getOrient(spec: ICartesianAxisCommonSpec, whiteList?: st
 export declare function getDirectionByOrient(orient: IOrientType): Direction;
 export declare function isOrientInSameDirection(orient1: IOrientType, orient2: IOrientType): boolean;
 export declare function transformInverse(spec: ICartesianAxisCommonSpec, isHorizontal: boolean): boolean;
-export declare function scaleWholeRangeSize(count: number, bandwidth: number, paddingInner: number, paddingOuter: number): number;
-export declare function bandSpace(count: number, paddingInner: number, paddingOuter: number): number;

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

@@ -15,6 +15,7 @@ export interface IAxis extends IComponent {
     getScales: () => IBaseScale[];
     getOrient: () => ICartesianAxisSpec['orient'] | IPolarOrientType;
     visible: boolean;
+    directionStr?: 'l2r' | 'r2l' | 't2b' | 'b2t';
 }
 export interface IAxisItem<T> {
     visible?: boolean;

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

@@ -1,7 +1,6 @@
 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 { IAxis, IGrid } from '../../interface';
 import type { ICompilableData } from '../../../../compile/data';
 export type IPolarGrid = IGrid & {
     smooth?: boolean;
@@ -16,7 +15,7 @@ export interface IPolarAxisHelper {
     getBandwidth?: (depth?: number) => number;
     getAxisId: () => number;
 }
-export interface IPolarAxis extends IComponent {
+export interface IPolarAxis extends IAxis {
     startAngle: number;
     endAngle: number;
     getOrient: () => IPolarOrientType;

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

@@ -22,7 +22,8 @@ export declare abstract class BaseComponent<T extends IComponentSpec = IComponen
     constructor(spec: T, options: IComponentOption);
     initLayout(): void;
     abstract changeRegions(regions: IRegion[]): void;
-    abstract getVRenderComponents(): IGraphic[];
+    protected abstract _getNeedClearVRenderComponents(): IGraphic[];
+    getVRenderComponents(): IGraphic<Partial<import("@visactor/vrender-core").IGraphicAttribute>>[];
     protected callPlugin(cb: (plugin: IComponentPlugin) => void): void;
     protected eventPos(markEventParams: BaseEventParams): {
         x: number;
@@ -43,11 +44,5 @@ export declare abstract class BaseComponent<T extends IComponentSpec = IComponen
     compile(): void;
     compileMarks(group?: string | IGroupMark): void;
     protected _delegateEvent: (component: IGraphic, event: any, type: string, item?: any, datum?: Datum) => void;
-    getGraphicBounds: () => {
-        x1: number;
-        y1: number;
-        x2: number;
-        y2: number;
-    };
     getBoundsInRect(rect: ILayoutRect, fullRect: ILayoutRect): IBoundsLike;
 }

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

@@ -63,7 +63,7 @@ export declare class Brush extends BaseComponent<IBrushSpec> implements IBrush {
     protected initEvent(): void;
     onRender(ctx: IModelRenderOption): void;
     changeRegions(regions: IRegion[]): void;
-    getVRenderComponents(): IGraphic[];
+    protected _getNeedClearVRenderComponents(): IGraphic[];
     _compareSpec(): {
         change: boolean;
         reMake: boolean;

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

@@ -6,13 +6,13 @@ import type { IPadding, Maybe, StringOrNumber } from '../../typings';
 import type { IComponentOption } from '../interface';
 import type { ICrossHair, CrossHairTrigger, ICartesianCrosshairSpec, IPolarCrosshairSpec, ICrosshairTheme, ICrosshairCategoryFieldSpec } from './interface';
 import type { IAxis } from '../axis/interface';
-type IBound = {
+export type IBound = {
     x1: number;
     y1: number;
     x2: number;
     y2: number;
 };
-type IAxisInfo<T> = Map<number, IBound & {
+export type IAxisInfo<T> = Map<number, IBound & {
     axis: T;
 }>;
 export interface IHair {
@@ -40,14 +40,14 @@ export declare abstract class BaseCrossHair<T extends ICartesianCrosshairSpec |
     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 _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(): {
@@ -73,4 +73,3 @@ export declare abstract class BaseCrossHair<T extends ICartesianCrosshairSpec |
     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

@@ -1,7 +1,6 @@
 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';
@@ -12,16 +11,8 @@ export declare class CartesianCrossHair<T extends ICartesianCrosshairSpec = ICar
     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 _xHair;
+    private _yHair;
     private _cacheXCrossHairInfo;
     private _cacheYCrossHairInfo;
     private _xCrosshair;
@@ -30,40 +21,26 @@ export declare class CartesianCrossHair<T extends ICartesianCrosshairSpec = ICar
     private _yCrosshair;
     private _yLeftLabel;
     private _yRightLabel;
+    private _currValueX;
+    private _currValueY;
     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;
+    protected _showDefaultCrosshairBySpec(): void;
+    private _defaultCrosshair;
+    private _findAllAxisContains;
+    private _getValueAt;
     clearAxisValue(): void;
     setAxisValue(v: StringOrNumber, axis: IAxis): void;
-    private getAllAxisValues;
+    private _getAllAxisValues;
     protected _layoutCrosshair(relativeX: number, relativeY: number): void;
     hide(): void;
-    private layoutByValue;
+    layoutByValue(tag?: number): void;
     private _layoutVertical;
     private _layoutHorizontal;
+    private _getRectSize;
     protected _parseFieldInfo(): void;
     private _updateCrosshair;
     private _updateCrosshairLabel;
-    getVRenderComponents(): IGraphic[];
+    protected _getNeedClearVRenderComponents(): IGraphic[];
 }
 export declare const registerCartesianCrossHair: () => void;

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

@@ -10,3 +10,9 @@ export declare function getDefaultCrosshairTriggerEventByMode(mode: RenderMode):
     hoverOut: string;
     clickOut: string;
 };
+export declare enum LayoutType {
+    ALL = 3,
+    HORIZONTAL = 2,
+    VERTICAL = 1,
+    NONE = 0
+}

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

@@ -25,10 +25,10 @@ export interface IPolarCrosshairSpec extends ICommonCrosshairSpec {
 }
 export interface ICrosshairCategoryFieldSpec extends ICrosshairDataBindSpec {
     visible: boolean;
-    line?: ICrosshairLineSpec | ICrosshairRectSpec;
+    line?: ICrosshairLineSpec | Omit<ICrosshairRectSpec, 'width'>;
     label?: ICrosshairLabelSpec;
 }
-export interface ICrosshairValueFieldSpec {
+export interface ICrosshairValueFieldSpec extends ICrosshairDataBindSpec {
     visible: boolean;
     line?: ICrosshairLineSpec;
     label?: ICrosshairLabelSpec;
@@ -42,10 +42,14 @@ export interface ICrosshairLineSpec {
     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;
+    width?: number | string | ICrosshairRectWidthCallback;
     style?: ICrosshairRectStyle;
 }
 export interface ICrosshairLabelSpec {

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

@@ -1,80 +1,38 @@
 import type { IComponentOption } from '../interface';
 import { ComponentTypeEnum } from '../interface/type';
 import type { IPolarCrosshairSpec } from './interface';
-import type { IPolarAxis } from '../axis/polar/interface';
-import type { IPoint, StringOrNumber } from '../../typings';
-import type { IHair } from './base';
 import { BaseCrossHair } from './base';
 import type { IGraphic } from '@visactor/vrender-core';
-type IBound = {
-    x1: number;
-    y1: number;
-    x2: number;
-    y2: number;
-};
-type IAxisInfo = Map<number, IBound & {
-    axis: IPolarAxis;
-}>;
 export declare class PolarCrossHair<T extends IPolarCrosshairSpec = IPolarCrosshairSpec> extends BaseCrossHair<T> {
     static specKey: string;
     specKey: string;
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
     name: string;
-    currValueX: Map<number, {
-        v: StringOrNumber;
-        axis: IPolarAxis;
-        [key: string]: any;
-    }>;
-    currValueY: Map<number, {
-        v: StringOrNumber;
-        axis: IPolarAxis;
-        [key: string]: any;
-    }>;
-    xHair: IHair | undefined;
-    yHair: (IHair & {
-        smooth: boolean;
-    }) | undefined;
-    private _cacheXCrossHairInfo;
-    private _cacheYCrossHairInfo;
+    private _currValueAngle;
+    private _currValueRadius;
+    private _angleHair;
+    private _radiusHair;
+    private _cacheAngleCrossHairInfo;
+    private _cacheRadiusCrossHairInfo;
     private _radiusCrosshair;
     private _radiusLabelCrosshair;
     private _angleCrosshair;
     private _angleLabelCrosshair;
     static createComponent(spec: any, options: IComponentOption): PolarCrossHair<any> | PolarCrossHair<IPolarCrosshairSpec>[];
     constructor(spec: T, options: IComponentOption);
-    protected _showDefaultCrosshair(): void;
+    protected _showDefaultCrosshairBySpec(): void;
+    private _defaultCrosshair;
     hide(): void;
-    findAllAxisContains(relativeX: number, relativeY: number): {
-        xAxisMap: Map<number, {
-            x1: number;
-            y1: number;
-            x2: number;
-            y2: number;
-        } & {
-            axis: IPolarAxis;
-        }>;
-        yAxisMap: Map<number, {
-            x1: number;
-            y1: number;
-            x2: number;
-            y2: number;
-        } & {
-            axis: IPolarAxis;
-        }>;
-    };
-    getAllAxisValues(axisMap: IAxisInfo, point: IPoint, currValue: Map<number, {
-        v: StringOrNumber;
-        axis: IPolarAxis;
-        [key: string]: any;
-    }>): boolean;
+    private _findAllAxisContains;
+    private _getAllAxisValues;
+    private _getValueByAxis;
     protected _layoutCrosshair(relativeX: number, relativeY: number): void;
-    private layoutByValue;
+    layoutByValue(tag?: number): void;
     private _layoutVertical;
     private _layoutHorizontal;
     protected _parseFieldInfo(): void;
     private _updateCrosshairLabel;
-    getVRenderComponents(): IGraphic[];
+    protected _getNeedClearVRenderComponents(): IGraphic[];
 }
 export declare const registerPolarCrossHair: () => void;
-export {};

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

@@ -26,7 +26,7 @@ export declare class CustomMark extends BaseComponent<any> {
         reCompile: boolean;
     };
     changeRegions(regions: IRegion[]): void;
-    getVRenderComponents(): IGraphic[];
+    protected _getNeedClearVRenderComponents(): IGraphic[];
     onRender(ctx: IModelRenderOption): void;
     private _getMarkAttributeContext;
 }

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

@@ -121,5 +121,5 @@ export declare abstract class DataFilterBaseComponent<T extends IDataFilterCompo
         minBandSize: number;
     };
     protected _autoUpdate(rect?: ILayoutRect): boolean;
-    getVRenderComponents(): IGraphic[];
+    protected _getNeedClearVRenderComponents(): IGraphic[];
 }

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

@@ -62,6 +62,6 @@ export declare class DataZoom<T extends IDataZoomSpec = IDataZoomSpec> extends D
             area: any;
         };
     };
-    getVRenderComponents(): IGraphic[];
+    protected _getNeedClearVRenderComponents(): IGraphic[];
 }
 export declare const registerDataZoom: () => void;

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

@@ -27,6 +27,6 @@ export declare class ScrollBar<T extends IScrollBarSpec = IScrollBarSpec> extend
     protected _handleDataCollectionChange(): void;
     protected _initCommonEvent(): void;
     protected _getComponentAttrs(): Partial<ScrollBarAttributes>;
-    getVRenderComponents(): IGraphic[];
+    protected _getNeedClearVRenderComponents(): IGraphic[];
 }
 export declare const registerScrollBar: () => void;

package/types/component/geo/geo-coordinate.d.ts

@@ -47,7 +47,7 @@ export declare class GeoCoordinate extends BaseComponent<IGeoRegionSpec> impleme
     onLayoutEnd(ctx: IModelLayoutOption): void;
     onRender(ctx: IModelRenderOption): void;
     changeRegions(regions: IRegion[]): void;
-    getVRenderComponents(): IGraphic[];
+    protected _getNeedClearVRenderComponents(): IGraphic[];
     protected collectFeatures(): any[];
     dataToPosition(values?: number[]): IPoint;
     dataToLatitude(lat: number): number;

package/types/component/indicator/indicator.d.ts

@@ -34,7 +34,7 @@ export declare class Indicator<T extends IIndicatorSpec> extends BaseComponent<T
     private _createText;
     private _computeLayoutRadius;
     private isRelativeModel;
-    getVRenderComponents(): IGraphic[];
+    protected _getNeedClearVRenderComponents(): IGraphic[];
     clear(): void;
 }
 export declare const registerIndicator: () => void;

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

@@ -34,5 +34,5 @@ export declare abstract class BaseLabelComponent<T extends ILabelSpec = ILabelSp
     };
     onRender(ctx: IModelRenderOption): void;
     changeRegions(regions: IRegion[]): void;
-    getVRenderComponents(): IGraphic[];
+    protected _getNeedClearVRenderComponents(): IGraphic[];
 }

package/types/component/label/label.d.ts

@@ -41,5 +41,6 @@ export declare class Label<T extends ILabelSpec = ILabelSpec> extends BaseLabelC
     protected _updateSingleLabelAttribute(labelInfo: ILabelInfo, labelComponent: IComponentMark): void;
     protected _updateLabelComponentAttribute(component: ILabel, target: IVGrammarMark | IVGrammarMark[], labelInfos: ILabelInfo[]): void;
     compileMarks(): void;
+    getVRenderComponents(): any[];
 }
 export declare const registerLabel: () => void;

package/types/component/label/totalLabel.d.ts

@@ -21,6 +21,7 @@ export declare class TotalLabel extends BaseLabelComponent {
     protected _initLabelComponent(): void;
     updateLayoutAttribute(): void;
     compileMarks(): void;
+    getVRenderComponents(): any[];
 }
 export declare function totalLabelPosition(series: ISeries, type: MarkType): string;
 export declare const registerTotalLabel: () => void;

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

@@ -55,6 +55,6 @@ export declare abstract class BaseLegend<T extends ILegendCommonSpec> extends Ba
         y2: number;
     };
     onDataUpdate(): void;
-    getVRenderComponents(): IGraphic[];
+    protected _getNeedClearVRenderComponents(): IGraphic[];
     clear(): void;
 }

package/types/component/legend/continuous/interface.d.ts

@@ -41,6 +41,7 @@ export type IColorLegendSpec = IContinuousLegendSpec & {
 export type ISizeLegendSpec = IContinuousLegendSpec & {
     type: 'size';
     sizeBackground?: Omit<NoVisibleMarkStyle<IRectMarkSpec>, 'visible' | 'width' | 'height'>;
+    align?: 'top' | 'bottom' | 'left' | 'right';
 };
 export type IContinuousLegendTheme = Omit<IContinuousLegendSpec, 'type' | 'field' | 'scale' | 'regionIndex' | 'regionId' | 'seriesIndex' | 'seriesId' | 'id' | 'defaultSelected'>;
 export interface IColorLegendTheme {

package/types/component/map-label/component.d.ts

@@ -47,6 +47,6 @@ export declare class MapLabelComponent extends BaseComponent<IMapLabelSpec> {
     private _isRelativeSeries;
     onRender(ctx: any): void;
     changeRegions(): void;
-    getVRenderComponents(): IGraphic[];
+    protected _getNeedClearVRenderComponents(): IGraphic[];
 }
 export declare const registerMapLabel: () => void;

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

@@ -2,11 +2,11 @@ import type { DataView } from '@visactor/vdataset';
 import type { IModelRenderOption } from '../../model/interface';
 import type { IRegion } from '../../region/interface';
 import type { ICartesianSeries } from '../../series/interface';
-import type { ILayoutRect, ILayoutType, IRect, StringOrNumber } from '../../typings';
+import type { ILayoutRect, ILayoutType, IRect } from '../../typings';
 import { BaseComponent } from '../base/base-component';
-import type { IAggrType, IDataPos, IDataPosCallback, IMarkerAxisSpec, IMarkerSpec } from './interface';
-import type { IGraphic } from '@visactor/vrender-core';
-export declare abstract class BaseMarker<T extends IMarkerSpec & IMarkerAxisSpec> extends BaseComponent<T> {
+import type { IAggrType, IDataPos, IDataPosCallback, IMarkerSpec } from './interface';
+import type { IGraphic, IGroup } from '@visactor/vrender-core';
+export declare abstract class BaseMarker<T extends IMarkerSpec> extends BaseComponent<T> {
     layoutType: ILayoutType | 'none';
     protected _startRelativeSeries: ICartesianSeries;
     protected _endRelativeSeries: ICartesianSeries;
@@ -16,55 +16,53 @@ export declare abstract class BaseMarker<T extends IMarkerSpec & IMarkerAxisSpec
     protected _markerComponent: any;
     protected _layoutOffsetX: number;
     protected _layoutOffsetY: number;
+    private _firstSeries;
     created(): void;
-    private _isSpecAggr;
     private _getAllRelativeSeries;
+    private _getFieldInfoFromSpec;
     protected _processSpecX(specX: IDataPos | IDataPosCallback): {
         getRelativeSeries: () => ICartesianSeries;
         getStartRelativeSeries: () => ICartesianSeries;
         getEndRelativeSeries: () => ICartesianSeries;
-        x: {
+        x: string | number | IDataPosCallback | {
             field: any;
             aggrType: IAggrType;
         };
-    } | {
-        getRelativeSeries: () => ICartesianSeries;
-        getStartRelativeSeries: () => ICartesianSeries;
-        getEndRelativeSeries: () => ICartesianSeries;
-        x: IDataPos | IDataPosCallback;
     };
     protected _processSpecY(specY: IDataPos | IDataPosCallback): {
         getRelativeSeries: () => ICartesianSeries;
         getStartRelativeSeries: () => ICartesianSeries;
         getEndRelativeSeries: () => ICartesianSeries;
-        y: {
+        y: string | number | IDataPosCallback | {
             field: any;
             aggrType: IAggrType;
         };
-    } | {
+    };
+    protected _processSpecXY(specX: IDataPos | IDataPosCallback, specY: IDataPos | IDataPosCallback): {
         getRelativeSeries: () => ICartesianSeries;
         getStartRelativeSeries: () => ICartesianSeries;
         getEndRelativeSeries: () => ICartesianSeries;
-        y: IDataPos | IDataPosCallback;
+        x: string | number | IDataPosCallback | {
+            field: any;
+            aggrType: IAggrType;
+        };
+        y: string | number | IDataPosCallback | {
+            field: any;
+            aggrType: IAggrType;
+        };
     };
-    protected _processSpecXY(specX: IDataPos | IDataPosCallback, specY: IDataPos | IDataPosCallback): any;
     protected _processSpecCoo(spec: any): any;
     updateLayoutAttribute(): void;
-    protected _getSeriesByIdOrIndex(seriesUserId: StringOrNumber, seriesIndex: number): ICartesianSeries;
+    private _getSeriesByIdOrIndex;
     protected _bindSeries(): void;
-    protected _computeClipRange(regions: IRegion[]): {
-        minX: number;
-        maxX: number;
-        minY: number;
-        maxY: number;
-    };
     protected abstract _initDataView(): void;
-    protected abstract _createMarkerComponent(): void;
+    protected abstract _createMarkerComponent(): IGroup;
     protected abstract _markerLayout(): void;
     protected initEvent(): void;
     onRender(ctx: IModelRenderOption): void;
     changeRegions(regions: IRegion[]): void;
-    protected getFirstSeries(): ICartesianSeries;
-    getVRenderComponents(): IGraphic[];
+    clear(): void;
+    private _getFirstSeries;
+    protected _getNeedClearVRenderComponents(): IGraphic[];
     onLayoutStart(layoutRect: IRect, chartViewRect: ILayoutRect, ctx: any): void;
 }