@visactor/vchart-types 0.10.0-alpha.3 → 0.11.6-alpha.1

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, IRichTextCharacter } from '@visactor/vrender-core';
-import type { IRectMarkSpec, ISymbolMarkSpec, ITextMarkSpec, StringOrNumber } from '../../typings';
+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'>;
-    };
-    type?: 'text' | 'rich' | 'html';
-    text?: string | string[] | number | number[] | IRichTextCharacter[];
-    formatMethod?: (markData: Datum[], seriesData: Datum[]) => string | string[] | number | number[] | IRichTextCharacter[];
-    style?: Omit<ITextMarkSpec, 'visible'>;
+    } & Partial<IMarkerState<Omit<IRectMarkSpec, 'visible'>>>;
+    type?: 'rich' | 'text';
+    text?: string | string[] | number | number[] | ReturnType<IRichTextFormatMethod<[]>>;
+    formatMethod?: IFormatMethod<[markData: Datum[], seriesData: Datum[]]>;
     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?: 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,19 @@
+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 _getUpdateMarkerAttrs(): any;
+    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?: 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;

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

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

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

@@ -1,2 +1,4 @@
-export * from './mark-point';
+export * from './cartesian-mark-point';
+export * from './polar-mark-point';
+export * from './geo-mark-point';
 export * from './interface';

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

@@ -1,12 +1,20 @@
 import type { IComponent } from '../../../interface';
 import type { IDataPointSpec, IDataPos, IDataPosCallback, IMarkerSpec, IMarkerSymbol, MarkerPositionPoint, OffsetPoint } from '../../interface';
 import type { IMarkPointTheme } from './theme';
+import type { BaseMarkerAnimation, MarkPointAnimationType } from '@visactor/vrender-components';
 export type IMarkPoint = IComponent;
-export type IMarkPointSpec = IMarkerSpec & (IMarkPointXYSpec | IMarkPointCoordinateSpec | IMarkPointPositionsSpec) & IMarkPointTheme<IMarkerSymbol>;
+export type IMarkPointSpec = IMarkerSpec & (IMarkPointXYSpec | IMarkPointAngleRadiusSpec | IMarkPointGeoNameSpec | IMarkPointCoordinateSpec | IMarkPointPositionsSpec) & IMarkPointTheme<IMarkerSymbol> & BaseMarkerAnimation<MarkPointAnimationType>;
 export type IMarkPointXYSpec = {
     y: IDataPos | IDataPosCallback;
     x: IDataPos | IDataPosCallback;
 };
+export type IMarkPointAngleRadiusSpec = {
+    angle: IDataPos | IDataPosCallback;
+    radius: IDataPos | IDataPosCallback;
+};
+export type IMarkPointGeoNameSpec = {
+    areaName: string | IDataPosCallback;
+};
 export type IMarkPointCoordinateSpec = {
     coordinates: IDataPointSpec;
     coordinatesOffset?: OffsetPoint;

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

@@ -1,26 +1,24 @@
-import type { IImageGraphicAttribute, IRichTextGraphicAttribute } from '@visactor/vrender-core';
+import type { IImageGraphicAttribute, IRichTextGraphicAttribute, IGroupGraphicAttribute } from '@visactor/vrender-core';
 import type { IMarkPointItemPosition } from '@visactor/vrender-components';
 import type { ILineMarkSpec, ISymbolMarkSpec } from '../../../../typings';
-import type { IMarkerLabelSpec, IMarkerRef, IMarkerSymbol } from '../../interface';
+import type { IMarkerLabelSpec, IMarkerRef, IMarkerState, IMarkerSymbol } from '../../interface';
+import type { IRegion } from 'src/region';
+export type IOffsetCallback = (region: IRegion) => number;
 export interface IItemContent extends IMarkerRef {
     type?: 'symbol' | 'text' | 'image' | 'richText';
-    position?: IMarkPointItemPosition;
-    offsetX?: number;
-    offsetY?: number;
+    position?: keyof typeof IMarkPointItemPosition;
+    offsetX?: number | 'regionRight' | 'regionLeft' | IOffsetCallback;
+    offsetY?: number | 'regionTop' | 'regionBottom' | IOffsetCallback;
     confine?: boolean;
-    symbol?: {
-        style?: ISymbolMarkSpec;
-    };
-    image?: {
-        style?: IImageGraphicAttribute;
-    };
+    symbol?: Partial<IMarkerState<ISymbolMarkSpec>>;
+    image?: Partial<IMarkerState<IImageGraphicAttribute>>;
     text?: IMarkerLabelSpec;
-    richText?: {
-        style?: IRichTextGraphicAttribute;
-    };
+    richText?: Partial<IMarkerState<IRichTextGraphicAttribute>>;
+    customMark?: Partial<IMarkerState<IGroupGraphicAttribute>>;
 }
 export type IItemLine<T extends Partial<IMarkerSymbol> = IMarkerSymbol> = {
-    type?: 'type-s' | 'type-do' | 'type-po' | 'type-op';
+    type?: 'type-s' | 'type-do' | 'type-po' | 'type-op' | 'type-arc';
+    arcRatio?: number;
     visible?: boolean;
     decorativeLine?: {
         visible?: boolean;
@@ -28,11 +26,14 @@ export type IItemLine<T extends Partial<IMarkerSymbol> = IMarkerSymbol> = {
     };
     startSymbol?: T;
     endSymbol?: T;
-    line?: {
-        style?: Omit<ILineMarkSpec, 'visible'>;
-    };
+    line?: Partial<IMarkerState<Omit<ILineMarkSpec, 'visible'>>>;
 };
 export interface IMarkPointTheme<T extends Partial<IMarkerSymbol> = Partial<IMarkerSymbol>> {
     itemLine?: IItemLine<T>;
     itemContent?: IItemContent;
+    targetSymbol?: {
+        offset?: number;
+        visible?: boolean;
+        size?: number;
+    } & Partial<IMarkerState<ISymbolMarkSpec>>;
 }

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

@@ -0,0 +1,18 @@
+import { ComponentTypeEnum } from '../../interface/type';
+import { BaseMarkPoint } from './base-mark-point';
+import type { IMarkProcessOptions } from '../interface';
+export declare class PolarMarkPoint extends BaseMarkPoint {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    static coordinateType: string;
+    coordinateType: string;
+    protected _computePointsAttr(): {
+        point: {
+            x: number;
+            y: number;
+        };
+    };
+    protected _computeOptions(): IMarkProcessOptions;
+}
+export declare const registerPolarMarkPoint: () => void;

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

@@ -1,12 +1,16 @@
-import type { ICartesianSeries, ISeries } from '../../series/interface';
+import type { ISeries } from '../../series/interface';
 import type { DataView } from '@visactor/vdataset';
+import { type IPointLike } from '@visactor/vutils';
 import type { IPoint } from '../../typings';
-import type { IDataPos, IMarkerLabelSpec, MarkerPositionPoint } from './interface';
+import type { IDataPos, IMarkerLabelSpec, IMarkerState, IMarkerSupportSeries, IPolarPoint, MarkerPositionPoint, MarkerStateValue } from './interface';
 import type { IRegion } from '../../region/interface';
 import type { OffsetPoint } from './interface';
 export declare function isAggrSpec(spec: IDataPos): boolean;
-export declare function xyLayout(data: DataView, startRelativeSeries: ICartesianSeries, endRelativeSeries: ICartesianSeries, relativeSeries: ICartesianSeries, autoRange: boolean): IPoint[][];
-export declare function coordinateLayout(data: DataView, relativeSeries: ICartesianSeries, autoRange: boolean, coordinatesOffset: OffsetPoint[] | OffsetPoint): IPoint[];
+export declare function xyLayout(data: DataView, startRelativeSeries: IMarkerSupportSeries, endRelativeSeries: IMarkerSupportSeries, relativeSeries: IMarkerSupportSeries, autoRange: boolean): IPoint[][];
+export declare function polarLayout(data: DataView, startRelativeSeries: IMarkerSupportSeries, endRelativeSeries: IMarkerSupportSeries, relativeSeries: IMarkerSupportSeries, autoRange: boolean): IPolarPoint[][];
+export declare function geoLayout(data: DataView, relativeSeries: IMarkerSupportSeries): IPoint[][];
+export declare function cartesianCoordinateLayout(data: DataView, relativeSeries: IMarkerSupportSeries, autoRange: boolean, coordinatesOffset: OffsetPoint[] | OffsetPoint): IPoint[];
+export declare function polarCoordinateLayout(data: DataView, relativeSeries: IMarkerSupportSeries, autoRange: boolean): IPolarPoint[];
 export declare function positionLayout(positions: MarkerPositionPoint[], series: ISeries, regionRelative: boolean): IPoint[];
 export declare function computeClipRange(regions: IRegion[]): {
     minX: number;
@@ -14,4 +18,35 @@ export declare function computeClipRange(regions: IRegion[]): {
     minY: number;
     maxY: number;
 };
-export declare function transformLabelAttributes(label: IMarkerLabelSpec): any;
+export declare function transformLabelAttributes(label: IMarkerLabelSpec, markerData: any): any;
+export declare function transformState(state: {} | Record<MarkerStateValue, any | IMarkerState<any>>, markerData: DataView): {} | Record<MarkerStateValue, any>;
+export declare function transformStyle(style: any, markerData: DataView): any;
+export declare function transformOffset(offset: string | number | Function, region: IRegion): any;
+export declare function computeOffsetFromRegion(point: IPointLike, offset: string | number, region: IRegion): number;
+export declare function getMarkLineProcessInfo(spec: any): {
+    doXProcess: boolean;
+    doXYY1Process: boolean;
+    doYProcess: boolean;
+    doYXX1Process: boolean;
+    doXYProcess: boolean;
+    doAngleProcess: boolean;
+    doRadiusProcess: boolean;
+    doAngRadRad1Process: boolean;
+    doRadAngAng1Process: boolean;
+    doRadAngProcess: boolean;
+    doCoordinatesProcess: boolean;
+};
+export declare function getMarkAreaProcessInfo(spec: any): {
+    doXProcess: boolean;
+    doYProcess: boolean;
+    doXYProcess: boolean;
+    doAngleProcess: boolean;
+    doRadiusProcess: boolean;
+    doRadAngProcess: boolean;
+    doCoordinatesProcess: boolean;
+};
+export declare function getMarkPointProcessInfo(spec: any): {
+    doXYProcess: boolean;
+    doPolarProcess: boolean;
+    doGeoProcess: boolean;
+};

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

@@ -1,6 +1,6 @@
 import type { ControllerLayout, OrientType } from '@visactor/vrender-components';
 import type { ISymbolMarkSpec, IRectMarkSpec } from '../../../typings';
-import type { BaseGraphicAttributes } from '@visactor/vrender-components/es/core/type';
+import type { BaseGraphicAttributes } from '@visactor/vrender-components';
 import type { ILayoutItemSpec } from '../../../layout/interface';
 export interface IPlayerTheme extends ILayoutItemSpec {
     visible?: boolean;

package/types/component/player/player.d.ts

@@ -18,6 +18,7 @@ export declare class Player extends BaseComponent<IPlayer> implements IComponent
     private _specs;
     private _playerComponent;
     private _cacheAttrs;
+    private _visible;
     private _direction;
     private _alternate;
     private _dx;
@@ -32,8 +33,8 @@ export declare class Player extends BaseComponent<IPlayer> implements IComponent
     afterSetLayoutStartPoint(pos: IPoint): void;
     getBoundsInRect(rect: ILayoutRect, fullSpace: ILayoutRect): {
         x1: number;
-        y1: number;
         x2: number;
+        y1: number;
         y2: number;
     };
     changeRegions(regions: IRegion[]): void;