@visactor/vchart-types 1.11.0-alpha.2 → 1.11.0

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

@@ -29,8 +29,12 @@ export interface IComponentTheme {
     [ComponentTypeEnum.colorLegend]?: IColorLegendTheme;
     [ComponentTypeEnum.sizeLegend]?: ISizeLegendTheme;
     [ComponentTypeEnum.markLine]?: IMarkLineTheme;
+    [ComponentTypeEnum.polarMarkLine]?: IMarkLineTheme;
     [ComponentTypeEnum.markArea]?: IMarkAreaTheme;
+    [ComponentTypeEnum.polarMarkArea]?: IMarkAreaTheme;
     [ComponentTypeEnum.markPoint]?: IMarkPointTheme;
+    [ComponentTypeEnum.polarMarkPoint]?: IMarkPointTheme;
+    [ComponentTypeEnum.geoMarkPoint]?: IMarkPointTheme;
     [ComponentTypeEnum.tooltip]?: ITooltipTheme<string | IColorKey>;
     [ComponentTypeEnum.crosshair]?: ICrosshairTheme;
     [ComponentTypeEnum.dataZoom]?: IDataZoomTheme;

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

@@ -23,6 +23,10 @@ export declare enum ComponentTypeEnum {
     markLine = "markLine",
     markArea = "markArea",
     markPoint = "markPoint",
+    polarMarkLine = "polarMarkLine",
+    polarMarkArea = "polarMarkArea",
+    polarMarkPoint = "polarMarkPoint",
+    geoMarkPoint = "geoMarkPoint",
     tooltip = "tooltip",
     title = "title",
     player = "player",

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

@@ -1,3 +1,4 @@
+import type { WaterfallSeries } from './../../series/waterfall/waterfall';
 import type { Datum } from '../../typings/common';
 import type { ILabelInfo } from './label';
 import type { LabelItem, Strategy } from '@visactor/vrender-components';
@@ -14,6 +15,7 @@ export declare const labelRuleMap: {
     rect3d: typeof barLabel;
     arc3d: typeof pieLabel;
     treemap: typeof treemapLabel;
+    venn: typeof vennLabel;
 };
 export declare function defaultLabelConfig(rule: string, labelInfo: ILabelInfo): any;
 export declare function textAttribute(labelInfo: ILabelInfo, datum: Datum, formatMethod?: ILabelSpec['formatMethod'], formatter?: ILabelSpec['formatter']): any;
@@ -48,7 +50,9 @@ export declare function pieLabel(labelInfo: ILabelInfo): {
     position: import("@visactor/vrender-components").Functional<string>;
     smartInvert: boolean | import("@visactor/vrender-components").SmartInvertAttrs;
 };
-export declare function stackLabel(labelInfo: ILabelInfo): {
+export declare function stackLabelX(datum2: Datum, series: WaterfallSeries, pos: string, offset: number): number;
+export declare function stackLabelY(datum2: Datum, series: WaterfallSeries, pos: string, offset: number): number;
+export declare function stackLabel(labelInfo: ILabelInfo, datumTransform?: (data: any) => any, attributeTransform?: (label: LabelItem, datum: Datum, att: any) => any): {
     customLayoutFunc: (labels: LabelItem[]) => import("@visactor/vrender-core").IText[];
     dataFilter: (labels: LabelItem[]) => LabelItem[];
     overlap: {
@@ -59,6 +63,10 @@ export declare function treemapLabel(labelInfo: ILabelInfo): {
     customLayoutFunc: (labels: LabelItem[], text: any) => any;
     overlap: boolean;
 };
+export declare function vennLabel(labelInfo: ILabelInfo): {
+    customLayoutFunc: (labels: LabelItem[], text: any) => any;
+    smartInvert: boolean;
+};
 export declare function LineLabel(labelInfo: ILabelInfo): {
     position: string;
     data: any;

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

@@ -16,6 +16,7 @@ export type HandlerTextAttribute = {
     style?: Omit<NoVisibleMarkStyle<ITextMarkSpec>, 'text'>;
 };
 export type IContinuousLegendSpec = ILegendCommonSpec & {
+    inverse?: boolean;
     field?: string;
     scale?: string;
     defaultSelected?: [number, number];

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

@@ -67,6 +67,7 @@ export type IDiscreteLegendSpec = ILegendCommonSpec & {
     data?: (data: LegendItemDatum[], colorScale: IBaseScale, globalScale: IGlobalScale) => LegendItemDatum[];
     item?: IItem;
     pager?: IPager | ILegendScrollbar;
+    scale?: string;
     scaleName?: string;
     field?: string;
     defaultSelected?: string[];

package/types/component/legend/discrete/legend.d.ts

@@ -7,20 +7,23 @@ import { ComponentTypeEnum } from '../../interface/type';
 import { DiscreteLegend as LegendComponent } from '@visactor/vrender-components';
 import { BaseLegend } from '../base-legend';
 import type { ILayoutRect } from '../../../typings/layout';
+import type { StringOrNumber } from '../../../typings';
 export declare class DiscreteLegend extends BaseLegend<IDiscreteLegendSpec> {
     static specKey: string;
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
     name: string;
+    protected _unselectedData: StringOrNumber[];
     static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
     init(option: IModelInitOption): void;
     protected _initLegendData(): DataView;
     protected _getSeriesLegendField(s: ISeries): string;
     protected _initSelectedData(): void;
-    private _getLegendDefaultData;
+    getLegendDefaultData(originalData?: boolean): any;
     private _addDefaultTitleText;
     protected _getLegendAttributes(rect: ILayoutRect): any;
     protected _getLegendConstructor(): typeof LegendComponent;
+    setSelectedData(selectedData: StringOrNumber[]): void;
     protected _initEvent(): void;
     private _getLegendItems;
     private _addLegendItemFormatMethods;

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

@@ -15,12 +15,22 @@ export declare function transformLegendTitleAttributes(title: ITitle): {
         visible?: boolean;
         style?: Omit<import("./interface").NoVisibleMarkStyle<import("../..").IRectMarkSpec>, "visible" | "width" | "height">;
     };
-    text?: string | number | string[] | number[] | {
+    text?: string | number | number[] | string[] | {
         type?: "text";
-        text: string | number | string[] | number[];
+        text: string | number | number[] | string[];
     } | {
         type: "rich";
         text: import("@visactor/vrender-core").IRichTextCharacter[];
+    } | {
+        type: "html";
+        text: {
+            dom: string | HTMLElement;
+        } & import("@visactor/vrender-core").SimpleDomStyleOptions & import("@visactor/vrender-core").CommonDomOptions;
+    } | {
+        type: "react";
+        text: {
+            element: any;
+        } & import("@visactor/vrender-core").SimpleDomStyleOptions & import("@visactor/vrender-core").CommonDomOptions;
     };
     visible?: boolean;
     padding?: import("@visactor/vrender-components").Padding;

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

@@ -1,67 +1,53 @@
-import type { DataView } from '@visactor/vdataset';
-import type { IModelRenderOption } from '../../model/interface';
+import { DataView } from '@visactor/vdataset';
+import type { Maybe } from '@visactor/vutils';
+import type { IModelRenderOption, IModelSpecInfo } from '../../model/interface';
 import type { IRegion } from '../../region/interface';
-import type { ICartesianSeries } from '../../series/interface';
 import type { ILayoutRect, ILayoutType, IRect } from '../../typings';
 import { BaseComponent } from '../base/base-component';
-import type { IAggrType, IDataPos, IDataPosCallback, IMarkerSpec } from './interface';
+import type { IDataPos, IDataPosCallback, IMarkerSpec, IMarkerSupportSeries } 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;
-    protected _relativeSeries: ICartesianSeries;
-    getRelativeSeries(): ICartesianSeries;
+    static specKey: string;
+    static type: string;
+    static coordinateType: string;
+    coordinateType: string;
+    protected _startRelativeSeries: IMarkerSupportSeries;
+    protected _endRelativeSeries: IMarkerSupportSeries;
+    protected _relativeSeries: IMarkerSupportSeries;
+    protected _specifiedDataSeries: IMarkerSupportSeries | IMarkerSupportSeries[];
+    getRelativeSeries(): IMarkerSupportSeries;
     protected _markerData: DataView;
+    getMarkerData(): DataView;
     protected _markerComponent: any;
     protected _layoutOffsetX: number;
     protected _layoutOffsetY: number;
     private _firstSeries;
+    protected abstract _initDataView(): void;
+    protected abstract _createMarkerComponent(): IGroup;
+    protected abstract _markerLayout(): void;
+    static _getMarkerCoordinateType(markerSpec: any): string;
+    static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
     created(): void;
     protected _getAllRelativeSeries(): {
-        getRelativeSeries: () => ICartesianSeries;
-        getStartRelativeSeries: () => ICartesianSeries;
-        getEndRelativeSeries: () => ICartesianSeries;
+        getRelativeSeries: () => IMarkerSupportSeries;
+        getStartRelativeSeries: () => IMarkerSupportSeries;
+        getEndRelativeSeries: () => IMarkerSupportSeries;
     };
     private _getFieldInfoFromSpec;
-    protected _processSpecX(specX: IDataPos | IDataPosCallback): {
-        getRelativeSeries: () => ICartesianSeries;
-        getStartRelativeSeries: () => ICartesianSeries;
-        getEndRelativeSeries: () => ICartesianSeries;
-        x: string | number | IDataPosCallback | {
-            field: any;
-            aggrType: IAggrType;
-        };
-    };
-    protected _processSpecY(specY: IDataPos | IDataPosCallback): {
-        getRelativeSeries: () => ICartesianSeries;
-        getStartRelativeSeries: () => ICartesianSeries;
-        getEndRelativeSeries: () => ICartesianSeries;
-        y: string | number | IDataPosCallback | {
-            field: any;
-            aggrType: IAggrType;
-        };
-    };
-    protected _processSpecXY(specX: IDataPos | IDataPosCallback, specY: IDataPos | IDataPosCallback): {
-        getRelativeSeries: () => ICartesianSeries;
-        getStartRelativeSeries: () => ICartesianSeries;
-        getEndRelativeSeries: () => ICartesianSeries;
-        x: string | number | IDataPosCallback | {
-            field: any;
-            aggrType: IAggrType;
-        };
-        y: string | number | IDataPosCallback | {
-            field: any;
-            aggrType: IAggrType;
-        };
+    protected _processSpecByDims(dimSpec: {
+        dim: 'x' | 'y' | 'angle' | 'radius' | 'areaName';
+        specValue: IDataPos | IDataPosCallback;
+    }[]): {
+        getRelativeSeries: () => IMarkerSupportSeries;
+        getStartRelativeSeries: () => IMarkerSupportSeries;
+        getEndRelativeSeries: () => IMarkerSupportSeries;
     };
     protected _processSpecCoo(spec: any): any;
+    protected _getRelativeDataView(): DataView;
     updateLayoutAttribute(): void;
     private _getSeriesByIdOrIndex;
     protected _bindSeries(): void;
-    protected abstract _initDataView(): void;
-    protected abstract _createMarkerComponent(): IGroup;
-    protected abstract _markerLayout(): void;
     protected initEvent(): void;
     onRender(ctx: IModelRenderOption): void;
     changeRegions(regions: IRegion[]): void;

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

@@ -1,17 +1,24 @@
+import type { DataView } from '@visactor/vdataset';
 import type { IPadding } from '@visactor/vutils';
 import type { SymbolType } from '@visactor/vrender-core';
 import type { IComposedTextMarkSpec, IFormatMethod, IRectMarkSpec, IRichTextFormatMethod, ISymbolMarkSpec, 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';
+import type { ICartesianSeries, IGeoSeries, IPolarSeries } from '../../series/interface';
+import type { IOptionAggr, IOptionAggrField, IOptionSeries } from '../../data/transforms/aggregation';
+import type { IOptionRegr } from '../../data/transforms/regression';
+export type IMarkerSupportSeries = ICartesianSeries | IPolarSeries | IGeoSeries;
+export type IPolarPoint = {
+    angle: number;
+    radius: number;
+};
 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: Datum[], startRelativeSeriesData: Datum[], endRelativeSeriesData: Datum[], relativeSeries: ICartesianSeries, startRelativeSeries: ICartesianSeries, endRelativeSeries: ICartesianSeries) => StringOrNumber;
+export type IDataPosCallback = (relativeSeriesData: Datum[], startRelativeSeriesData: Datum[], endRelativeSeriesData: Datum[], relativeSeries: IMarkerSupportSeries, startRelativeSeries: IMarkerSupportSeries, endRelativeSeries: IMarkerSupportSeries) => StringOrNumber;
 export type IDataPointSpec = {
     [key: string]: IDataPos | IDataPosCallback;
     refRelativeSeriesIndex?: number;
@@ -20,6 +27,10 @@ export type IDataPointSpec = {
     xFieldDim?: string;
     yFieldIndex?: number;
     yFieldDim?: string;
+    angleFieldIndex?: number;
+    angleFieldDim?: string;
+    radiusFieldIndex?: number;
+    radiusFieldDim?: string;
 };
 export type MarkerPositionPoint = {
     x: StringOrNumber;
@@ -28,7 +39,9 @@ export type MarkerPositionPoint = {
 export type ICoordinateOption = {
     x?: IOptionAggrField | (IDataPosCallback | StringOrNumber)[];
     y?: IOptionAggrField | (IDataPosCallback | StringOrNumber)[];
-    getRefRelativeSeries?: () => ICartesianSeries;
+    angle?: IOptionAggrField | (IDataPosCallback | StringOrNumber)[];
+    radius?: IOptionAggrField | (IDataPosCallback | StringOrNumber)[];
+    getRefRelativeSeries?: () => IMarkerSupportSeries;
 } & IOptionSeries;
 export type IMarkerPositionsSpec = {
     positions: MarkerPositionPoint[];
@@ -42,12 +55,10 @@ export type IMarkerLabelWithoutRefSpec = {
     labelBackground?: {
         visible?: boolean;
         padding?: IPadding | number[] | number;
-        style?: Omit<IRectMarkSpec, 'visible'>;
-    };
+    } & Partial<IMarkerState<Omit<IRectMarkSpec, 'visible'>>>;
     type?: 'rich' | 'text';
     text?: string | string[] | number | number[] | ReturnType<IRichTextFormatMethod<[]>>;
     formatMethod?: IFormatMethod<[markData: Datum[], seriesData: Datum[]]>;
-    style?: Omit<IComposedTextMarkSpec, 'visible'>;
     shape?: {
         visible?: boolean;
         style: Omit<ISymbolMarkSpec, 'visible'>;
@@ -56,7 +67,7 @@ export type IMarkerLabelWithoutRefSpec = {
     confine?: boolean;
     dx?: number;
     dy?: number;
-};
+} & Partial<IMarkerState<Omit<IComposedTextMarkSpec, 'visible'>>>;
 export type IMarkerLabelSpec = IMarkerLabelWithoutRefSpec & IMarkerRef;
 export interface IMarkerRef {
     refX?: number;
@@ -68,8 +79,10 @@ export interface IMarkerCrossSeriesSpec {
     endRelativeSeriesIndex?: number;
     startRelativeSeriesId?: string;
     endRelativeSeriesId?: string;
+    specifiedDataSeriesIndex?: 'all' | number | number[];
+    specifiedDataSeriesId?: 'all' | string | string[];
 }
-export interface IMarkerSpec extends IComponentSpec {
+export type IMarkerSpec = IComponentSpec & {
     relativeSeriesIndex?: number;
     relativeSeriesId?: number | string;
     visible?: boolean;
@@ -77,10 +90,24 @@ export interface IMarkerSpec extends IComponentSpec {
     autoRange?: boolean;
     clip?: boolean;
     name?: string;
-}
-export interface IMarkerSymbol extends IMarkerRef {
+    coordinateType?: string;
+};
+export type IMarkerSymbol = IMarkerRef & {
     visible: boolean;
     symbolType?: SymbolType;
     size?: number;
-    style?: Omit<ISymbolMarkSpec, 'visible'>;
-}
+} & Partial<IMarkerState<Omit<ISymbolMarkSpec, 'visible'>>>;
+export type MarkerStyleCallback<T> = (markerData: DataView) => T;
+export type MarkerStateCallback<T> = (markerData: DataView) => T;
+export type MarkerStateValue = 'hover' | 'hover_reverse' | 'selected' | 'selected_reverse';
+export type IMarkerState<T> = {
+    style?: T | MarkerStyleCallback<T>;
+    state?: Record<MarkerStateValue, T | MarkerStateCallback<T>>;
+};
+export type MarkCoordinateType = 'cartesian' | 'polar' | 'geo';
+export type IMarkProcessOptions = {
+    options: IOptionAggr[] | IOptionRegr;
+    needAggr?: boolean;
+    needRegr?: boolean;
+    processData?: DataView;
+};

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

@@ -0,0 +1,18 @@
+import type { IMarkArea, IMarkAreaSpec } from './interface';
+import type { MarkArcAreaAttrs, MarkAreaAttrs } from '@visactor/vrender-components';
+import type { MarkArea as MarkAreaComponent, MarkArcArea as MarkArcAreaComponent } from '@visactor/vrender-components';
+import { BaseMarker } from '../base-marker';
+import type { IGroup } from '@visactor/vrender-core';
+import type { IMarkProcessOptions } from '../interface';
+export declare abstract class BaseMarkArea extends BaseMarker<IMarkAreaSpec> implements IMarkArea {
+    static specKey: string;
+    specKey: string;
+    layoutZIndex: number;
+    protected abstract _newMarkAreaComponent(attr: MarkAreaAttrs | MarkArcAreaAttrs): MarkAreaComponent | MarkArcAreaComponent;
+    protected abstract _computePointsAttr(): any;
+    protected abstract _computeOptions(): IMarkProcessOptions;
+    static _getMarkerCoordinateType(markerSpec: any): string;
+    protected _createMarkerComponent(): IGroup;
+    protected _markerLayout(): void;
+    protected _initDataView(): void;
+}

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

@@ -0,0 +1,19 @@
+import { ComponentTypeEnum } from '../../interface/type';
+import type { MarkAreaAttrs } from '@visactor/vrender-components';
+import { MarkArea as MarkAreaComponent } from '@visactor/vrender-components';
+import type { IPoint } from '../../../typings';
+import type { IMarkProcessOptions } from '../interface';
+import { BaseMarkArea } from './base-mark-area';
+export declare class CartesianMarkArea extends BaseMarkArea {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    static coordinateType: string;
+    coordinateType: string;
+    protected _newMarkAreaComponent(attr: MarkAreaAttrs): MarkAreaComponent;
+    protected _computePointsAttr(): {
+        points: IPoint[];
+    };
+    protected _computeOptions(): IMarkProcessOptions;
+}
+export declare const registerMarkArea: () => void;

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

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

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

@@ -1,9 +1,10 @@
+import type { BaseMarkerAnimation, CommonMarkAreaAnimationType } from '@visactor/vrender-components';
 import type { IComponent } 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 | IMarkAreaXYSpec | IMarkAreaCoordinateSpec | IMarkerPositionsSpec) & IMarkAreaTheme;
+export type IMarkAreaSpec = IMarkerSpec & (IMarkAreaXSpec | IMarkAreaYSpec | IMarkAreaXYSpec | IMarkAreaAngleSpec | IMarkAreaRadiusSpec | IMarkAreaAngleRadiusSpec | IMarkAreaCoordinateSpec | IMarkerPositionsSpec) & IMarkAreaTheme & BaseMarkerAnimation<CommonMarkAreaAnimationType>;
 export interface IMarkAreaXSpec extends IMarkerCrossSeriesSpec {
     x: IDataPos | IDataPosCallback;
     x1: IDataPos | IDataPosCallback;
@@ -18,6 +19,20 @@ export interface IMarkAreaXYSpec extends IMarkerCrossSeriesSpec {
     y: IDataPos | IDataPosCallback;
     y1: IDataPos | IDataPosCallback;
 }
+export interface IMarkAreaAngleSpec extends IMarkerCrossSeriesSpec {
+    angle: IDataPos | IDataPosCallback;
+    angle1: IDataPos | IDataPosCallback;
+}
+export interface IMarkAreaRadiusSpec extends IMarkerCrossSeriesSpec {
+    radius: IDataPos | IDataPosCallback;
+    radius1: IDataPos | IDataPosCallback;
+}
+export interface IMarkAreaAngleRadiusSpec extends IMarkerCrossSeriesSpec {
+    angle: IDataPos | IDataPosCallback;
+    angle1: IDataPos | IDataPosCallback;
+    radius: IDataPos | IDataPosCallback;
+    radius1: IDataPos | IDataPosCallback;
+}
 export type IMarkAreaCoordinateSpec = {
     coordinates: IDataPointSpec[];
     coordinatesOffset?: OffsetPoint[];

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

@@ -1,11 +1,9 @@
-import type { IMarkAreaLabelPosition } from '@visactor/vrender-components';
-import type { IPolygonMarkSpec } from '../../../../typings';
-import type { IMarkerLabelWithoutRefSpec } from '../../interface';
+import type { IMarkAreaLabelPosition, IMarkCommonArcLabelPosition } from '@visactor/vrender-components';
+import type { IArcMarkSpec, IPolygonMarkSpec } from '../../../../typings';
+import type { IMarkerLabelWithoutRefSpec, IMarkerState } from '../../interface';
 export interface IMarkAreaTheme {
-    area?: {
-        style?: IPolygonMarkSpec;
-    };
+    area?: Partial<IMarkerState<IPolygonMarkSpec | IArcMarkSpec>>;
     label?: {
-        position?: keyof typeof IMarkAreaLabelPosition;
+        position?: keyof typeof IMarkAreaLabelPosition | IMarkCommonArcLabelPosition;
     } & IMarkerLabelWithoutRefSpec;
 }

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

@@ -0,0 +1,25 @@
+import { ComponentTypeEnum } from '../../interface/type';
+import type { MarkArcAreaAttrs, MarkAreaAttrs } from '@visactor/vrender-components';
+import { MarkArcArea as MarkArcAreaComponent, MarkArea as MarkAreaComponent } from '@visactor/vrender-components';
+import type { IPoint, IPolarPoint } from '../../../typings';
+import { BaseMarkArea } from './base-mark-area';
+import type { IMarkProcessOptions } from '../interface';
+export declare class PolarMarkArea extends BaseMarkArea {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    static coordinateType: string;
+    coordinateType: string;
+    protected _markerComponent: MarkArcAreaComponent;
+    protected _newMarkAreaComponent(attr: MarkArcAreaAttrs | MarkAreaAttrs): MarkArcAreaComponent | MarkAreaComponent;
+    protected _computePointsAttr(): {
+        points?: IPoint[] | IPolarPoint[];
+        innerRadius?: number;
+        outerRadius?: number;
+        startAngle?: number;
+        endAngle?: number;
+        center?: IPoint;
+    };
+    protected _computeOptions(): IMarkProcessOptions;
+}
+export declare const registerPolarMarkArea: () => void;

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

@@ -0,0 +1,18 @@
+import type { IMarkLine, IMarkLineSpec } from './interface';
+import type { MarkArcLineAttrs, MarkLineAttrs } from '@visactor/vrender-components';
+import type { MarkLine as MarkLineComponent, MarkArcLine as MarkArcLineComponent } from '@visactor/vrender-components';
+import { BaseMarker } from '../base-marker';
+import type { IGroup } from '@visactor/vrender-core';
+import type { IMarkProcessOptions } from '../interface';
+export declare abstract class BaseMarkLine extends BaseMarker<IMarkLineSpec> implements IMarkLine {
+    static specKey: string;
+    specKey: string;
+    layoutZIndex: number;
+    protected abstract _newMarkLineComponent(attr: MarkLineAttrs | MarkArcLineAttrs): MarkLineComponent | MarkArcLineComponent;
+    protected abstract _computePointsAttr(): any;
+    protected abstract _computeOptions(): IMarkProcessOptions;
+    static _getMarkerCoordinateType(markerSpec: any): string;
+    protected _createMarkerComponent(): IGroup;
+    protected _markerLayout(): void;
+    protected _initDataView(): void;
+}

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

@@ -0,0 +1,20 @@
+import { ComponentTypeEnum } from '../../interface/type';
+import { type MarkLineAttrs, MarkLine as MarkLineComponent } from '@visactor/vrender-components';
+import type { IMarkProcessOptions } from '../interface';
+import type { IPoint } from '../../../typings';
+import { BaseMarkLine } from './base-mark-line';
+export declare class CartesianMarkLine extends BaseMarkLine {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    static coordinateType: string;
+    coordinateType: string;
+    protected _markerComponent: MarkLineComponent;
+    protected _newMarkLineComponent(attr: MarkLineAttrs): MarkLineComponent;
+    protected _computePointsAttr(): {
+        points: IPoint[];
+    };
+    protected _markerLayout(): void;
+    protected _computeOptions(): IMarkProcessOptions;
+}
+export declare const registerMarkLine: () => void;

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

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

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

@@ -1,10 +1,11 @@
 import type { IComponent } from '../../../interface';
-import type { IAggrType, IMarkerPositionsSpec, IDataPointSpec, IMarkerSpec, IDataPos, IDataPosCallback, IMarkerLabelSpec, IMarkerCrossSeriesSpec, OffsetPoint } from '../../interface';
+import type { IAggrType, IMarkerPositionsSpec, IDataPointSpec, IMarkerSpec, IDataPos, IDataPosCallback, IMarkerLabelSpec, IMarkerCrossSeriesSpec, OffsetPoint, MarkerStateValue, MarkerStateCallback } from '../../interface';
 import type { IRegressType } from '../../mark-area/interface';
 import type { IMarkLineTheme } from './theme';
 import type { ILineMarkSpec, IPoint } from '../../../../typings';
+import type { BaseMarkerAnimation, MarkCommonLineAnimationType } from '@visactor/vrender-components/es/marker/type';
 export type IMarkLine = IComponent;
-export type IMarkLineSpec = (IMarkerSpec & (IMarkLineXSpec | IMarkLineYSpec | IMarkLineXYSpec | IMarkLineXYY1Spec | IMarkLineYXX1Spec | IMarkLineCoordinateSpec | IMarkerPositionsSpec) & IMarkLineTheme) | IStepMarkLineSpec;
+export type IMarkLineSpec = (IMarkerSpec & (IMarkLineXSpec | IMarkLineYSpec | IMarkLineXYSpec | IMarkLineXYY1Spec | IMarkLineYXX1Spec | IMarkLineAngleSpec | IMarkLineRadiusSpec | IMarkLineAngRadRad1Spec | IMarkLineRadAngAng1Spec | IMarkLineAngRadSpec | IMarkLineCoordinateSpec | IMarkerPositionsSpec) & IMarkLineTheme & BaseMarkerAnimation<MarkCommonLineAnimationType>) | (IStepMarkLineSpec & BaseMarkerAnimation<MarkCommonLineAnimationType>);
 export interface IMarkLineXSpec extends IMarkerCrossSeriesSpec {
     x: IDataPos | IDataPosCallback;
 }
@@ -27,6 +28,28 @@ export interface IMarkLineXYSpec extends IMarkerCrossSeriesSpec {
     x1: IDataPos | IDataPosCallback;
     y1: IDataPos | IDataPosCallback;
 }
+export interface IMarkLineAngleSpec extends IMarkerCrossSeriesSpec {
+    angle: IDataPos | IDataPosCallback;
+}
+export interface IMarkLineRadiusSpec extends IMarkerCrossSeriesSpec {
+    radius: IDataPos | IDataPosCallback;
+}
+export interface IMarkLineAngRadRad1Spec extends IMarkerCrossSeriesSpec {
+    angle: IDataPos | IDataPosCallback;
+    radius: IDataPos | IDataPosCallback;
+    radius1: IDataPos | IDataPosCallback;
+}
+export interface IMarkLineRadAngAng1Spec extends IMarkerCrossSeriesSpec {
+    angle: IDataPos | IDataPosCallback;
+    angle1: IDataPos | IDataPosCallback;
+    radius: IDataPos | IDataPosCallback;
+}
+export interface IMarkLineAngRadSpec extends IMarkerCrossSeriesSpec {
+    angle: IDataPos | IDataPosCallback;
+    angle1: IDataPos | IDataPosCallback;
+    radius: IDataPos | IDataPosCallback;
+    radius1: IDataPos | IDataPosCallback;
+}
 export type IMarkLineCoordinateSpec = {
     coordinates: IDataPointSpec[];
     coordinatesOffset?: OffsetPoint[];
@@ -47,6 +70,7 @@ export type IStepMarkLineSpec = IMarkerSpec & {
         multiSegment?: boolean;
         mainSegmentIndex?: number;
         style?: ILineMarkSpec | ILineMarkSpec[];
+        state?: Record<MarkerStateValue, ILineMarkSpec | ILineMarkSpec[] | MarkerStateCallback<ILineMarkSpec | ILineMarkSpec[]>>;
     };
 } & Omit<IMarkLineTheme, 'label' | 'line'> & ({
     coordinates: [IDataPointSpec, IDataPointSpec];

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

@@ -1,12 +1,10 @@
-import type { IMarkLineLabelPosition } from '@visactor/vrender-components';
-import type { ILineMarkSpec } from '../../../../typings';
-import type { IMarkerLabelSpec, IMarkerSymbol } from '../../interface';
+import type { IMarkCommonArcLabelPosition, IMarkLineLabelPosition } from '@visactor/vrender-components';
+import type { IArcMarkSpec, ILineMarkSpec } from '../../../../typings';
+import type { IMarkerLabelSpec, IMarkerState, IMarkerSymbol } from '../../interface';
 export interface IMarkLineTheme {
-    line?: {
-        style?: ILineMarkSpec;
-    };
+    line?: Partial<IMarkerState<ILineMarkSpec | IArcMarkSpec>>;
     label?: {
-        position?: keyof typeof IMarkLineLabelPosition;
+        position?: keyof typeof IMarkLineLabelPosition | IMarkCommonArcLabelPosition;
     } & IMarkerLabelSpec;
     startSymbol?: IMarkerSymbol;
     endSymbol?: IMarkerSymbol;

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

@@ -0,0 +1,23 @@
+import { ComponentTypeEnum } from '../../interface/type';
+import type { MarkArcLineAttrs, MarkLineAttrs } from '@visactor/vrender-components';
+import { MarkArcLine as MarkArcLineComponent, MarkLine as MarkLineComponent } from '@visactor/vrender-components';
+import type { IPoint } from '../../../typings';
+import { BaseMarkLine } from './base-mark-line';
+export declare class PolarMarkLine extends BaseMarkLine {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    static coordinateType: string;
+    coordinateType: string;
+    protected _markerComponent: MarkArcLineComponent;
+    protected _newMarkLineComponent(attr: MarkArcLineAttrs | MarkLineAttrs): MarkArcLineComponent | MarkLineComponent;
+    protected _computePointsAttr(): {
+        points?: IPoint[];
+        radius?: number;
+        startAngle?: number;
+        endAngle?: number;
+        center?: IPoint;
+    };
+    protected _computeOptions(): any;
+}
+export declare const registerPolarMarkLine: () => void;

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

@@ -0,0 +1,17 @@
+import type { IMarkPoint, IMarkPointSpec } from './interface';
+import { MarkPoint as MarkPointComponent } from '@visactor/vrender-components';
+import { BaseMarker } from '../base-marker';
+import type { IGroup } from '@visactor/vrender-core';
+import type { IMarkProcessOptions } from '../interface';
+export declare abstract class BaseMarkPoint extends BaseMarker<IMarkPointSpec> implements IMarkPoint {
+    static specKey: string;
+    specKey: string;
+    layoutZIndex: number;
+    protected _markerComponent: MarkPointComponent;
+    protected abstract _computePointsAttr(): any;
+    protected abstract _computeOptions(): IMarkProcessOptions;
+    static _getMarkerCoordinateType(markerSpec: any): string;
+    protected _createMarkerComponent(): IGroup;
+    protected _markerLayout(): void;
+    protected _initDataView(): void;
+}

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

@@ -0,0 +1,16 @@
+import { ComponentTypeEnum } from '../../interface/type';
+import type { IPoint } from '../../../typings';
+import { BaseMarkPoint } from './base-mark-point';
+import type { IMarkProcessOptions } from '../interface';
+export declare class CartesianMarkPoint extends BaseMarkPoint {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    static coordinateType: string;
+    coordinateType: string;
+    protected _computePointsAttr(): {
+        point: IPoint;
+    };
+    protected _computeOptions(): IMarkProcessOptions;
+}
+export declare const registerMarkPoint: () => void;