@visactor/vchart-types 1.7.2 → 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/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/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/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,37 +21,23 @@ 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;

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,75 +1,34 @@
 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;
@@ -77,4 +36,3 @@ export declare class PolarCrossHair<T extends IPolarCrosshairSpec = IPolarCrossh
     protected _getNeedClearVRenderComponents(): IGraphic[];
 }
 export declare const registerPolarCrossHair: () => void;
-export {};

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/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;
+    clear(): void;
+    private _getFirstSeries;
     protected _getNeedClearVRenderComponents(): IGraphic[];
     onLayoutStart(layoutRect: IRect, chartViewRect: ILayoutRect, ctx: any): void;
 }

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

@@ -3,11 +3,18 @@ import type { SymbolType, IRichTextCharacter } from '@visactor/vrender-core';
 import type { IRectMarkSpec, ISymbolMarkSpec, ITextMarkSpec, StringOrNumber } from '../../typings';
 import type { IComponentSpec } from '../base/interface';
 import type { Datum } from '@visactor/vrender-components';
+import type { ICartesianSeries } from '../../series/interface';
+import type { IOptionAggrField, IOptionSeries } from '../../data/transforms/aggregation';
+export type OffsetPoint = {
+    x?: number | string;
+    y?: number | string;
+};
 export type IAggrType = 'sum' | 'average' | 'min' | 'max' | 'variance' | 'standardDeviation' | 'median';
 export type IDataPos = StringOrNumber | IAggrType;
-export type IDataPosCallback = (relativeSeriesData: any, startRelativeSeriesData: any, endRelativeSeriesData: any) => IDataPos;
+export type IDataPosCallback = (relativeSeriesData: Datum[], startRelativeSeriesData: Datum[], endRelativeSeriesData: Datum[], relativeSeries: ICartesianSeries, startRelativeSeries: ICartesianSeries, endRelativeSeries: ICartesianSeries) => StringOrNumber;
+export type IDataPointCallback = (relativeSeriesData: Datum[], relativeSeries: ICartesianSeries) => StringOrNumber;
 export type IDataPointSpec = {
-    [key: string]: IDataPos;
+    [key: string]: IDataPos | IDataPointCallback;
     refRelativeSeriesIndex?: number;
     refRelativeSeriesId?: StringOrNumber;
     xFieldIndex?: number;
@@ -15,12 +22,17 @@ export type IDataPointSpec = {
     yFieldIndex?: number;
     yFieldDim?: string;
 };
-type Point = {
-    x: number;
-    y: number;
+export type MarkerPositionPoint = {
+    x: StringOrNumber;
+    y: StringOrNumber;
 };
+export type ICoordinateOption = {
+    x?: IOptionAggrField | (IDataPointCallback | StringOrNumber)[];
+    y?: IOptionAggrField | (IDataPointCallback | StringOrNumber)[];
+    getRefRelativeSeries?: () => ICartesianSeries;
+} & IOptionSeries;
 export type IMarkerPositionsSpec = {
-    positions: Point[];
+    positions: MarkerPositionPoint[];
     regionRelative?: boolean;
 };
 export type IMarkerLabelWithoutRefSpec = {
@@ -52,12 +64,11 @@ export interface IMarkerRef {
     refY?: number;
     refAngle?: number;
 }
-export interface IMarkerAxisSpec {
+export interface IMarkerCrossSeriesSpec {
     startRelativeSeriesIndex?: number;
     endRelativeSeriesIndex?: number;
     startRelativeSeriesId?: string;
     endRelativeSeriesId?: string;
-    relativeRelativeSeriesIndex?: number;
 }
 export interface IMarkerSpec extends IComponentSpec {
     relativeSeriesIndex?: number;
@@ -74,4 +85,3 @@ export interface IMarkerSymbol extends IMarkerRef {
     size?: number;
     style?: Omit<ISymbolMarkSpec, 'visible'>;
 }
-export {};

package/types/component/marker/mark-area/interface/spec.d.ts

@@ -1,26 +1,24 @@
 import type { IComponent } from '../../../interface';
-import type { IMarkerPositionsSpec, IDataPointSpec, IDataPos, IMarkerSpec, IMarkerAxisSpec, IDataPosCallback } from '../../interface';
+import type { IMarkerPositionsSpec, IDataPointSpec, IDataPos, IMarkerSpec, IDataPosCallback, IMarkerCrossSeriesSpec, OffsetPoint } from '../../interface';
 import type { IMarkAreaTheme } from './theme';
 export type IMarkArea = IComponent;
 export type IRegressType = 'regression';
-export type IMarkAreaSpec = IMarkerSpec & (IMarkAreaXSpec | IMarkAreaYSpec | (IMarkAreaXSpec & IMarkAreaYSpec) | IMarkAreaCoordinateSpec | IMarkAreaPositionsSpec) & IMarkAreaTheme;
-export interface IMarkAreaXSpec extends IMarkerAxisSpec {
+export type IMarkAreaSpec = IMarkerSpec & (IMarkAreaXSpec | IMarkAreaYSpec | IMarkAreaXYSpec | IMarkAreaCoordinateSpec | IMarkerPositionsSpec) & IMarkAreaTheme;
+export interface IMarkAreaXSpec extends IMarkerCrossSeriesSpec {
     x: IDataPos | IDataPosCallback;
     x1: IDataPos | IDataPosCallback;
 }
-export interface IMarkAreaYSpec extends IMarkerAxisSpec {
+export interface IMarkAreaYSpec extends IMarkerCrossSeriesSpec {
     y: IDataPos | IDataPosCallback;
     y1: IDataPos | IDataPosCallback;
 }
-export interface IMarkAreaAngleSpec extends IMarkerAxisSpec {
-    startAngle: IDataPos | IDataPosCallback;
-    endAngle: IDataPos | IDataPosCallback;
-}
-export interface IMarkAreaRadiusSpec extends IMarkerAxisSpec {
-    startRadius: IDataPos | IDataPosCallback;
-    endRadius: IDataPos | IDataPosCallback;
+export interface IMarkAreaXYSpec extends IMarkerCrossSeriesSpec {
+    x: IDataPos | IDataPosCallback;
+    x1: IDataPos | IDataPosCallback;
+    y: IDataPos | IDataPosCallback;
+    y1: IDataPos | IDataPosCallback;
 }
 export type IMarkAreaCoordinateSpec = {
     coordinates: IDataPointSpec[];
+    coordinatesOffset?: OffsetPoint[];
 };
-export type IMarkAreaPositionsSpec = IMarkerPositionsSpec;

package/types/component/marker/mark-area/mark-area.d.ts

@@ -3,7 +3,8 @@ import type { IComponentOption } from '../../interface';
 import { ComponentTypeEnum } from '../../interface/type';
 import { MarkArea as MarkAreaComponent } from '@visactor/vrender-components';
 import { BaseMarker } from '../base-marker';
-export declare class MarkArea extends BaseMarker<IMarkAreaSpec & IMarkAreaTheme> implements IMarkArea {
+import type { IGroup } from '@visactor/vrender-core';
+export declare class MarkArea extends BaseMarker<IMarkAreaSpec> implements IMarkArea {
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
     name: string;
@@ -11,7 +12,7 @@ export declare class MarkArea extends BaseMarker<IMarkAreaSpec & IMarkAreaTheme>
     protected _theme: IMarkAreaTheme;
     protected _markerComponent: MarkAreaComponent;
     static createComponent(spec: any, options: IComponentOption): MarkArea | MarkArea[];
-    protected _createMarkerComponent(): void;
+    protected _createMarkerComponent(): IGroup;
     protected _markerLayout(): void;
     protected _initDataView(): void;
 }

package/types/component/marker/mark-line/interface/spec.d.ts

@@ -1,24 +1,35 @@
 import type { IComponent } from '../../../interface';
-import type { IAggrType, IMarkerPositionsSpec, IDataPointSpec, IMarkerSpec, IMarkerAxisSpec, IDataPos, IDataPosCallback, IMarkerLabelSpec } from '../../interface';
+import type { IAggrType, IMarkerPositionsSpec, IDataPointSpec, IMarkerSpec, IDataPos, IDataPosCallback, IMarkerLabelSpec, IMarkerCrossSeriesSpec, OffsetPoint } from '../../interface';
 import type { IRegressType } from '../../mark-area/interface';
 import type { IMarkLineTheme } from './theme';
 import type { ILineMarkSpec, IPoint } from '../../../../typings';
 export type IMarkLine = IComponent;
-export type IMarkLineSpec = (IMarkerSpec & (IMarkLineXSpec | IMarkLineYSpec | IMarkLineCoordinateSpec | IMarkLinePositionsSpec) & IMarkLineTheme) | IStepMarkLineSpec;
-export interface IMarkLineXSpec extends IMarkerAxisSpec {
+export type IMarkLineSpec = (IMarkerSpec & (IMarkLineXSpec | IMarkLineYSpec | IMarkLineXYSpec | IMarkLineXYY1Spec | IMarkLineYXX1Spec | IMarkLineCoordinateSpec | IMarkerPositionsSpec) & IMarkLineTheme) | IStepMarkLineSpec;
+export interface IMarkLineXSpec extends IMarkerCrossSeriesSpec {
     x: IDataPos | IDataPosCallback;
 }
-export interface IMarkLineYSpec extends IMarkerAxisSpec {
+export interface IMarkLineXYY1Spec extends IMarkerCrossSeriesSpec {
+    x: IDataPos | IDataPosCallback;
     y: IDataPos | IDataPosCallback;
+    y1: IDataPos | IDataPosCallback;
 }
-export interface IMarkLineAngleSpec extends IMarkerAxisSpec {
-    angle: IDataPos | IDataPosCallback;
+export interface IMarkLineYSpec extends IMarkerCrossSeriesSpec {
+    y: IDataPos | IDataPosCallback;
 }
-export interface IMarkLineRadiusSpec extends IMarkerAxisSpec {
-    radius: IDataPos | IDataPosCallback;
+export interface IMarkLineYXX1Spec extends IMarkerCrossSeriesSpec {
+    y: IDataPos | IDataPosCallback;
+    x: IDataPos | IDataPosCallback;
+    x1: IDataPos | IDataPosCallback;
+}
+export interface IMarkLineXYSpec extends IMarkerCrossSeriesSpec {
+    x: IDataPos | IDataPosCallback;
+    y: IDataPos | IDataPosCallback;
+    x1: IDataPos | IDataPosCallback;
+    y1: IDataPos | IDataPosCallback;
 }
 export type IMarkLineCoordinateSpec = {
     coordinates: IDataPointSpec[];
+    coordinatesOffset?: OffsetPoint[];
     process?: {
         x: IAggrType;
     } | {
@@ -27,7 +38,6 @@ export type IMarkLineCoordinateSpec = {
         xy: IRegressType;
     };
 };
-export type IMarkLinePositionsSpec = IMarkerPositionsSpec;
 export type IStepMarkLineSpec = IMarkerSpec & {
     type: 'type-step';
     connectDirection: 'top' | 'bottom' | 'left' | 'right';
@@ -49,4 +59,5 @@ export type IStepMarkLineSpec = IMarkerSpec & {
     };
 } | {
     positions: [IPoint, IPoint];
+    regionRelative?: boolean;
 });

package/types/component/marker/mark-line/mark-line.d.ts

@@ -3,15 +3,17 @@ import type { IComponentOption } from '../../interface';
 import { ComponentTypeEnum } from '../../interface/type';
 import { MarkLine as MarkLineComponent } from '@visactor/vrender-components';
 import { BaseMarker } from '../base-marker';
-export declare class MarkLine extends BaseMarker<IMarkLineSpec & IMarkLineTheme> implements IMarkLine {
+import type { IGroup } from '@visactor/vrender-core';
+export declare class MarkLine extends BaseMarker<IMarkLineSpec> implements IMarkLine {
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
     name: string;
     layoutZIndex: number;
     protected _theme: IMarkLineTheme;
     protected _markerComponent: MarkLineComponent;
+    private _isXYLayout;
     static createComponent(spec: any, options: IComponentOption): MarkLine | MarkLine[];
-    protected _createMarkerComponent(): void;
+    protected _createMarkerComponent(): IGroup;
     protected _markerLayout(): void;
     protected _initDataView(): void;
 }

package/types/component/marker/mark-point/interface/spec.d.ts

@@ -1,15 +1,17 @@
-import type { IPoint } from '../../../../typings';
 import type { IComponent } from '../../../interface';
-import type { IDataPointSpec, IMarkerSpec, IMarkerSymbol } from '../../interface';
+import type { IDataPointSpec, IDataPos, IDataPosCallback, IMarkerSpec, IMarkerSymbol, MarkerPositionPoint, OffsetPoint } from '../../interface';
 import type { IMarkPointTheme } from './theme';
 export type IMarkPoint = IComponent;
-export type IMarkPointSpec = IMarkerSpec & (IMarkPointCoordinateSpec | IMarkPointPositionsSpec) & IMarkPointTheme<IMarkerSymbol>;
+export type IMarkPointSpec = IMarkerSpec & (IMarkPointXYSpec | IMarkPointCoordinateSpec | IMarkPointPositionsSpec) & IMarkPointTheme<IMarkerSymbol>;
+export type IMarkPointXYSpec = {
+    y: IDataPos | IDataPosCallback;
+    x: IDataPos | IDataPosCallback;
+};
 export type IMarkPointCoordinateSpec = {
     coordinates: IDataPointSpec;
-    relativeRelativeSeriesIndex?: number;
-    relativeRelativeSeriesId?: string;
+    coordinatesOffset?: OffsetPoint;
 };
 export type IMarkPointPositionsSpec = {
-    position: IPoint;
+    position: MarkerPositionPoint;
     regionRelative?: boolean;
 };

package/types/component/marker/mark-point/mark-point.d.ts

@@ -3,7 +3,8 @@ import type { IComponentOption } from '../../interface';
 import { ComponentTypeEnum } from '../../interface/type';
 import { MarkPoint as MarkPointComponent } from '@visactor/vrender-components';
 import { BaseMarker } from '../base-marker';
-export declare class MarkPoint extends BaseMarker<IMarkPointSpec & IMarkPointTheme> implements IMarkPoint {
+import type { IGroup } from '@visactor/vrender-core';
+export declare class MarkPoint extends BaseMarker<IMarkPointSpec> implements IMarkPoint {
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
     name: string;
@@ -11,7 +12,7 @@ export declare class MarkPoint extends BaseMarker<IMarkPointSpec & IMarkPointThe
     protected _theme: IMarkPointTheme;
     protected _markerComponent: MarkPointComponent;
     static createComponent(spec: any, options: IComponentOption): MarkPoint | MarkPoint[];
-    protected _createMarkerComponent(): void;
+    protected _createMarkerComponent(): IGroup;
     protected _markerLayout(): void;
     protected _initDataView(): void;
 }