@visactor/vchart-types 0.10.0-alpha.2

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

@@ -0,0 +1,61 @@
+import type { IRectMarkSpec, ISymbolMarkSpec, ITextMarkSpec } from '../../../typings/visual';
+import type { DiscreteLegendAttrs, LegendItemDatum, LegendItem } from '@visactor/vrender-components';
+import type { ILegendCommonSpec, NoVisibleMarkStyle } from '../interface';
+import type { StringOrNumber } from '../../../typings';
+import type { IBaseScale } from '@visactor/vscale';
+import type { IGlobalScale } from '../../../scale/interface';
+export type formatterCallback = (text: StringOrNumber, item: LegendItemDatum, index: number) => any;
+export type LegendItemStyleValue<T> = T | ((item: LegendItemDatum, isSelected: boolean, index: number, allItems: LegendItemDatum[]) => T);
+export type LegendItemStyle<T> = {
+    style?: T;
+    state?: {
+        selected?: T;
+        unSelected?: T;
+        selectedHover?: T;
+        unSelectedHover?: T;
+    };
+};
+export type IItem = {
+    background?: {
+        visible?: boolean;
+    } & LegendItemStyle<LegendItemStyleValue<NoVisibleMarkStyle<IRectMarkSpec>>>;
+    shape?: {
+        visible?: boolean;
+        space?: number;
+    } & LegendItemStyle<LegendItemStyleValue<Partial<NoVisibleMarkStyle<ISymbolMarkSpec>>>>;
+    label?: {
+        space?: number;
+        formatMethod?: formatterCallback;
+    } & LegendItemStyle<LegendItemStyleValue<NoVisibleMarkStyle<ITextMarkSpec>>>;
+    value?: {
+        space?: number;
+        alignRight?: boolean;
+        formatMethod?: formatterCallback;
+    } & LegendItemStyle<LegendItemStyleValue<NoVisibleMarkStyle<ITextMarkSpec>>>;
+    focusIconStyle?: NoVisibleMarkStyle<ISymbolMarkSpec>;
+    maxWidth?: number | string;
+    width?: number | string;
+    height?: number | string;
+} & Omit<LegendItem, 'background' | 'shape' | 'label' | 'value' | 'focusIconStyle' | 'width' | 'height' | 'maxWidth'>;
+export type IPager = {
+    textStyle?: Partial<NoVisibleMarkStyle<ITextMarkSpec>>;
+    handler?: {
+        space?: number;
+        preShape?: string;
+        nextShape?: string;
+        style?: Omit<NoVisibleMarkStyle<ISymbolMarkSpec>, 'symbolType'>;
+        state?: {
+            hover?: Omit<NoVisibleMarkStyle<ISymbolMarkSpec>, 'symbolType'>;
+            disable?: Omit<NoVisibleMarkStyle<ISymbolMarkSpec>, 'symbolType'>;
+        };
+    };
+} & Omit<DiscreteLegendAttrs['pager'], 'textStyle' | 'handler'>;
+export type IDiscreteLegendSpec = ILegendCommonSpec & {
+    type?: 'discrete';
+    data?: (data: LegendItemDatum[], colorScale: IBaseScale, globalScale: IGlobalScale) => LegendItemDatum[];
+    item?: IItem;
+    pager?: IPager;
+    scaleName?: string;
+    field?: string;
+} & Omit<DiscreteLegendAttrs, 'layout' | 'title' | 'items' | 'item' | 'pager'>;
+export type IDiscreteLegendTheme = Omit<IDiscreteLegendSpec, 'type' | 'data' | 'regionIndex' | 'regionId' | 'seriesIndex' | 'seriesId' | 'id' | 'defaultSelected'>;

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

@@ -0,0 +1,27 @@
+import type { Maybe } from '@visactor/vutils';
+import { DataView } from '@visactor/vdataset';
+import type { IDiscreteLegendSpec } from './interface';
+import type { ISeries } from '../../../series/interface';
+import type { IModelInitOption, IModelSpecInfo } from '../../../model/interface';
+import { ComponentTypeEnum } from '../../interface/type';
+import { DiscreteLegend as LegendComponent } from '@visactor/vrender-components';
+import { BaseLegend } from '../base-legend';
+import type { ILayoutRect } from '../../../typings/layout';
+export declare class DiscreteLegend extends BaseLegend<IDiscreteLegendSpec> {
+    static specKey: string;
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
+    init(option: IModelInitOption): void;
+    protected _initLegendData(): DataView;
+    protected _getSeriesLegendField(s: ISeries): string;
+    protected _initSelectedData(): void;
+    private _getLegendDefaultData;
+    private _addDefaultTitleText;
+    protected _getLegendAttributes(rect: ILayoutRect): any;
+    protected _getLegendConstructor(): typeof LegendComponent;
+    protected _initEvent(): void;
+    private _getLegendItems;
+}
+export declare const registerDiscreteLegend: () => void;

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

@@ -0,0 +1,3 @@
+import type { IDiscreteLegendSpec } from './interface';
+import type { ILayoutRect } from '../../../typings/layout';
+export declare function getLegendAttributes(spec: IDiscreteLegendSpec, rect: ILayoutRect): any;

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

@@ -0,0 +1,3 @@
+export * from './discrete';
+export * from './continuous';
+export * from './interface';

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

@@ -0,0 +1,40 @@
+import type { LegendTitle } from '@visactor/vrender-components';
+import type { Datum, IOrientType, IPadding, IRectMarkSpec, ISymbolMarkSpec, ITextMarkSpec, StringOrNumber } from '../../typings';
+import type { IComponent } from '../interface';
+import type { IComponentSpec } from '../base/interface';
+import type { IDiscreteLegendSpec } from './discrete';
+import type { IColorLegendSpec, ISizeLegendSpec } from './continuous';
+export type ILegend = IComponent & {
+    getLegendData: () => Datum[];
+    getSelectedData: () => StringOrNumber[];
+    setSelectedData: (d: StringOrNumber[]) => void;
+};
+export type NoVisibleMarkStyle<T> = Omit<T, 'visible'>;
+export type ITitle = {
+    textStyle?: NoVisibleMarkStyle<ITextMarkSpec>;
+    style?: NoVisibleMarkStyle<ITextMarkSpec>;
+    shape?: {
+        visible?: boolean;
+        space?: number;
+        style?: NoVisibleMarkStyle<ISymbolMarkSpec>;
+    };
+    background?: {
+        visible?: boolean;
+        style?: Omit<NoVisibleMarkStyle<IRectMarkSpec>, 'visible' | 'width' | 'height'>;
+    };
+} & Omit<LegendTitle, 'textStyle' | 'style' | 'background'>;
+export type ILegendCommonSpec = {
+    visible?: boolean;
+    orient?: IOrientType;
+    position?: 'start' | 'middle' | 'end';
+    layout?: 'horizontal' | 'vertical';
+    filter?: boolean;
+    title?: ITitle;
+    background?: {
+        visible?: boolean;
+        padding?: IPadding | number | number[];
+        style?: Omit<NoVisibleMarkStyle<IRectMarkSpec>, 'visible' | 'width' | 'height'>;
+    };
+    interactive?: boolean;
+} & Omit<IComponentSpec, 'orient'>;
+export type ILegendSpec = IDiscreteLegendSpec | IColorLegendSpec | ISizeLegendSpec;

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

@@ -0,0 +1,32 @@
+import type { ILegendCommonSpec, ITitle } from './interface';
+export declare function transformLegendTitleAttributes(title: ITitle): {
+    textStyle?: import("./interface").NoVisibleMarkStyle<import("../..").ITextMarkSpec>;
+    style?: import("./interface").NoVisibleMarkStyle<import("../..").ITextMarkSpec>;
+    shape?: {
+        visible?: boolean;
+        space?: number;
+        style?: import("./interface").NoVisibleMarkStyle<import("../..").ISymbolMarkSpec>;
+    } & {
+        visible?: boolean;
+        space?: number;
+        style?: Omit<Partial<import("@visactor/vrender-core").ISymbolGraphicAttribute>, "visible">;
+    };
+    background?: {
+        visible?: boolean;
+        style?: Omit<import("./interface").NoVisibleMarkStyle<import("../..").IRectMarkSpec>, "visible" | "width" | "height">;
+    };
+    text?: string | number | string[] | number[] | {
+        type?: "text";
+        text: string | number | string[] | number[];
+    } | {
+        type: "rich";
+        text: import("@visactor/vrender-core").IRichTextCharacter[];
+    };
+    visible?: boolean;
+    padding?: import("@visactor/vrender-components/es/core/type").Padding;
+    maxWidth?: number;
+    minWidth?: number;
+    space?: number;
+    align?: "start" | "end" | "center";
+};
+export declare function getLayout(spec: ILegendCommonSpec): "vertical" | "horizontal";

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

@@ -0,0 +1,55 @@
+import type { IRect } from '../../typings/space';
+import { BaseComponent } from '../base/base-component';
+import { ComponentTypeEnum } from '../interface/type';
+import { LayoutZIndex } from '../../constant';
+import type { IMapLabelSpec, MapLabelSceneNodeMap } from './interface';
+import type { ICartesianSeries, IGeoSeries } from '../../series/interface';
+import type { IPoint, Datum } from '../../typings';
+import type { IPairInfo } from './layout';
+import { MarkPoint } from '@visactor/vrender-components';
+import type { IGraphic } from '@visactor/vrender-core';
+import type { Maybe } from '@visactor/vutils';
+import type { PanEventParam, ZoomEventParam } from '../../event/interface';
+import type { IModelSpecInfo } from '../../model/interface';
+export declare class MapLabelComponent extends BaseComponent<IMapLabelSpec> {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    static specKey: string;
+    specKey: string;
+    layoutType: 'none';
+    layoutZIndex: LayoutZIndex;
+    protected nameField: string;
+    protected valueField?: string;
+    protected _series: ICartesianSeries | IGeoSeries;
+    protected _map: any[];
+    protected _longitudeField: string;
+    protected _latitudeField: string;
+    protected _markerComponents: MarkPoint[];
+    private _activeDatum;
+    static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
+    setAttrFromSpec(): void;
+    created(): void;
+    initRelatedInfo(): void;
+    initData(): void;
+    initEvent(): void;
+    handlePan(e: PanEventParam): void;
+    handleZoom(e: ZoomEventParam): void;
+    private _updateDatum;
+    dataToPosition(datum: any): IPoint;
+    updateLayoutAttribute(): void;
+    protected _updateMarkerLayoutAttribute(): void;
+    protected _evaluateMarker(data: Datum, index: number): {
+        pairInfo: IPairInfo;
+        contentMarks: Partial<Record<import("./interface").IMapLabelNodes, IGraphic<Partial<import("@visactor/vrender-core").IGraphicAttribute>>>>;
+    };
+    protected _layoutMarkers(positionedRects: IRect[], contentMarks: MapLabelSceneNodeMap[]): void;
+    protected _renderMarkers(): void;
+    protected _layoutLabels(rects: IPairInfo[]): IRect[];
+    private _isRelativeModel;
+    private _isRelativeSeries;
+    onRender(ctx: any): void;
+    changeRegions(): void;
+    protected _getNeedClearVRenderComponents(): IGraphic[];
+}
+export declare const registerMapLabel: () => void;

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

@@ -0,0 +1,2 @@
+export * from './component';
+export * from './interface';

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

@@ -0,0 +1,40 @@
+import type { IGraphic } from '@visactor/vrender-core';
+import type { IPadding, IOrientType, StringOrNumber } from '../../typings';
+import type { IPathMarkSpec, IRectMarkSpec, ISymbolMarkSpec, ITextMarkSpec } from '../../typings/visual';
+import type { IModelSpec } from '../../model/interface';
+export type LabelPosition = IOrientType | 'outer';
+export interface IMapLabelSpec extends IMapLabelTheme, Pick<IModelSpec, 'id'> {
+    seriesId: StringOrNumber;
+    nameField?: string;
+    valueField?: string;
+    trigger?: 'hover' | 'click' | 'none';
+}
+export type IMapLabelNodes = 'nameLabel' | 'valueLabel' | 'icon' | 'labelBackground' | 'container';
+export type MapLabelSceneNodeMap = Partial<Record<IMapLabelNodes, IGraphic>>;
+export interface IMapLabelTheme {
+    visible?: boolean;
+    offset?: number;
+    space?: number;
+    position?: LabelPosition;
+    nameLabel?: {
+        visible?: boolean;
+        style?: ITextMarkSpec;
+    };
+    valueLabel?: {
+        visible?: boolean;
+        style?: ITextMarkSpec;
+    };
+    icon?: {
+        visible?: boolean;
+        style?: ISymbolMarkSpec;
+    };
+    background?: {
+        visible?: boolean;
+        padding?: IPadding;
+        style?: IRectMarkSpec;
+    };
+    leader?: {
+        visible?: boolean;
+        style?: IPathMarkSpec;
+    };
+}

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

@@ -0,0 +1,23 @@
+import type { Feature } from '@visactor/vutils';
+import type { IRect, IOrientType, IPoint } from '../../typings';
+type IBound = {
+    x1: number;
+    x2: number;
+    y1: number;
+    y2: number;
+};
+export interface IPairInfo {
+    rect: IRect;
+    point: IPoint;
+    pointCoord?: IPoint;
+    anchors?: IOrientType[];
+    offset?: number;
+    index: number;
+}
+export declare function bound(rect: IRect): IBound;
+export declare function layoutByPosition(pairs: IPairInfo[]): IRect[];
+export declare function layoutOuter(pairs: IPairInfo[], features: Feature[], dataToPosition: (coord: number[]) => IPoint | null): IRect[];
+export declare function layoutOuter2(pairs: IPairInfo[], features: Feature[], dataToPosition: (coord: number[]) => IPoint | null): IRect[];
+export declare function placeRectByOrient(rect: IRect, position: IOrientType, offset?: number): IRect;
+export declare function candidatesByOrient(positions: IOrientType[], anchor: IPoint, rect: Pick<IRect, 'width' | 'height'>, offset?: number): IPoint[];
+export {};

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

@@ -0,0 +1,72 @@
+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 } from '../../typings';
+import { BaseComponent } from '../base/base-component';
+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;
+    protected _relativeSeries: ICartesianSeries;
+    getRelativeSeries(): ICartesianSeries;
+    protected _markerData: DataView;
+    protected _markerComponent: any;
+    protected _layoutOffsetX: number;
+    protected _layoutOffsetY: number;
+    private _firstSeries;
+    created(): void;
+    protected _getAllRelativeSeries(): {
+        getRelativeSeries: () => ICartesianSeries;
+        getStartRelativeSeries: () => ICartesianSeries;
+        getEndRelativeSeries: () => ICartesianSeries;
+    };
+    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 _processSpecCoo(spec: any): any;
+    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;
+    clear(): void;
+    private _getFirstSeries;
+    protected _getNeedClearVRenderComponents(): IGraphic[];
+    onLayoutStart(layoutRect: IRect, chartViewRect: ILayoutRect, ctx: any): void;
+}

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

@@ -0,0 +1,86 @@
+import type { IPadding } from '@visactor/vutils';
+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: Datum[], startRelativeSeriesData: Datum[], endRelativeSeriesData: Datum[], relativeSeries: ICartesianSeries, startRelativeSeries: ICartesianSeries, endRelativeSeries: ICartesianSeries) => StringOrNumber;
+export type IDataPointSpec = {
+    [key: string]: IDataPos | IDataPosCallback;
+    refRelativeSeriesIndex?: number;
+    refRelativeSeriesId?: StringOrNumber;
+    xFieldIndex?: number;
+    xFieldDim?: string;
+    yFieldIndex?: number;
+    yFieldDim?: string;
+};
+export type MarkerPositionPoint = {
+    x: StringOrNumber;
+    y: StringOrNumber;
+};
+export type ICoordinateOption = {
+    x?: IOptionAggrField | (IDataPosCallback | StringOrNumber)[];
+    y?: IOptionAggrField | (IDataPosCallback | StringOrNumber)[];
+    getRefRelativeSeries?: () => ICartesianSeries;
+} & IOptionSeries;
+export type IMarkerPositionsSpec = {
+    positions: MarkerPositionPoint[];
+    regionRelative?: boolean;
+};
+export type IMarkerLabelWithoutRefSpec = {
+    visible?: boolean;
+    autoRotate?: boolean;
+    minWidth?: number;
+    maxWidth?: number;
+    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'>;
+    shape?: {
+        visible?: boolean;
+        style: Omit<ISymbolMarkSpec, 'visible'>;
+    };
+    space?: number;
+    confine?: boolean;
+    dx?: number;
+    dy?: number;
+};
+export type IMarkerLabelSpec = IMarkerLabelWithoutRefSpec & IMarkerRef;
+export interface IMarkerRef {
+    refX?: number;
+    refY?: number;
+    refAngle?: number;
+}
+export interface IMarkerCrossSeriesSpec {
+    startRelativeSeriesIndex?: number;
+    endRelativeSeriesIndex?: number;
+    startRelativeSeriesId?: string;
+    endRelativeSeriesId?: string;
+}
+export interface IMarkerSpec extends IComponentSpec {
+    relativeSeriesIndex?: number;
+    relativeSeriesId?: number | string;
+    visible?: boolean;
+    interactive?: boolean;
+    autoRange?: boolean;
+    clip?: boolean;
+    name?: string;
+}
+export interface IMarkerSymbol extends IMarkerRef {
+    visible: boolean;
+    symbolType?: SymbolType;
+    size?: number;
+    style?: Omit<ISymbolMarkSpec, 'visible'>;
+}

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

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

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

@@ -0,0 +1,2 @@
+export * from './spec';
+export * from './theme';

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

@@ -0,0 +1,24 @@
+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 interface IMarkAreaXSpec extends IMarkerCrossSeriesSpec {
+    x: IDataPos | IDataPosCallback;
+    x1: IDataPos | IDataPosCallback;
+}
+export interface IMarkAreaYSpec extends IMarkerCrossSeriesSpec {
+    y: IDataPos | IDataPosCallback;
+    y1: 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[];
+};

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

@@ -0,0 +1,11 @@
+import type { IMarkAreaLabelPosition } from '@visactor/vrender-components';
+import type { IPolygonMarkSpec } from '../../../../typings';
+import type { IMarkerLabelWithoutRefSpec } from '../../interface';
+export interface IMarkAreaTheme {
+    area?: {
+        style?: IPolygonMarkSpec;
+    };
+    label?: {
+        position?: IMarkAreaLabelPosition;
+    } & IMarkerLabelWithoutRefSpec;
+}

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

@@ -0,0 +1,21 @@
+import type { IMarkArea, IMarkAreaSpec } from './interface';
+import { ComponentTypeEnum } from '../../interface/type';
+import { MarkArea as MarkAreaComponent } from '@visactor/vrender-components';
+import type { Maybe } from '@visactor/vutils';
+import { BaseMarker } from '../base-marker';
+import type { IGroup } from '@visactor/vrender-core';
+import type { IModelSpecInfo } from '../../../model/interface';
+export declare class MarkArea extends BaseMarker<IMarkAreaSpec> implements IMarkArea {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    static specKey: string;
+    specKey: string;
+    layoutZIndex: number;
+    protected _markerComponent: MarkAreaComponent;
+    static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
+    protected _createMarkerComponent(): IGroup;
+    protected _markerLayout(): void;
+    protected _initDataView(): void;
+}
+export declare const registerMarkArea: () => void;

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

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

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

@@ -0,0 +1,2 @@
+export * from './spec';
+export * from './theme';

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

@@ -0,0 +1,63 @@
+import type { IComponent } 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 | IMarkLineXYSpec | IMarkLineXYY1Spec | IMarkLineYXX1Spec | IMarkLineCoordinateSpec | IMarkerPositionsSpec) & IMarkLineTheme) | IStepMarkLineSpec;
+export interface IMarkLineXSpec extends IMarkerCrossSeriesSpec {
+    x: IDataPos | IDataPosCallback;
+}
+export interface IMarkLineXYY1Spec extends IMarkerCrossSeriesSpec {
+    x: IDataPos | IDataPosCallback;
+    y: IDataPos | IDataPosCallback;
+    y1: IDataPos | IDataPosCallback;
+}
+export interface IMarkLineYSpec extends IMarkerCrossSeriesSpec {
+    y: 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;
+    } | {
+        y: IAggrType;
+    } | {
+        xy: IRegressType;
+    };
+};
+export type IStepMarkLineSpec = IMarkerSpec & {
+    type: 'type-step';
+    connectDirection: 'top' | 'bottom' | 'left' | 'right';
+    expandDistance?: number | string;
+    label?: IMarkerLabelSpec;
+    line?: {
+        multiSegment?: boolean;
+        mainSegmentIndex?: number;
+        style?: ILineMarkSpec | ILineMarkSpec[];
+    };
+} & Omit<IMarkLineTheme, 'label' | 'line'> & ({
+    coordinates: [IDataPointSpec, IDataPointSpec];
+    process?: {
+        x: IAggrType;
+    } | {
+        y: IAggrType;
+    } | {
+        xy: IRegressType;
+    };
+} | {
+    positions: [IPoint, IPoint];
+    regionRelative?: boolean;
+});

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

@@ -0,0 +1,13 @@
+import type { IMarkLineLabelPosition } from '@visactor/vrender-components';
+import type { ILineMarkSpec } from '../../../../typings';
+import type { IMarkerLabelSpec, IMarkerSymbol } from '../../interface';
+export interface IMarkLineTheme {
+    line?: {
+        style?: ILineMarkSpec;
+    };
+    label?: {
+        position?: IMarkLineLabelPosition;
+    } & IMarkerLabelSpec;
+    startSymbol?: IMarkerSymbol;
+    endSymbol?: IMarkerSymbol;
+}

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

@@ -0,0 +1,22 @@
+import type { IMarkLine, IMarkLineSpec } from './interface';
+import { ComponentTypeEnum } from '../../interface/type';
+import { MarkLine as MarkLineComponent } from '@visactor/vrender-components';
+import type { Maybe } from '@visactor/vutils';
+import { BaseMarker } from '../base-marker';
+import type { IGroup } from '@visactor/vrender-core';
+import type { IModelSpecInfo } from '../../../model/interface';
+export declare class MarkLine extends BaseMarker<IMarkLineSpec> implements IMarkLine {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    static specKey: string;
+    specKey: string;
+    layoutZIndex: number;
+    protected _markerComponent: MarkLineComponent;
+    private _isXYLayout;
+    static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
+    protected _createMarkerComponent(): IGroup;
+    protected _markerLayout(): void;
+    protected _initDataView(): void;
+}
+export declare const registerMarkLine: () => void;

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

@@ -0,0 +1,9 @@
+import type { IPoint } from '../../../typings';
+export declare function getInsertPoints(start: IPoint, end: IPoint, direction: 'top' | 'bottom' | 'left' | 'right', offset?: number): IPoint[];
+export declare function getTextOffset(start: IPoint, end: IPoint, direction: 'top' | 'bottom' | 'left' | 'right', offset?: number): {
+    dx: number;
+    dy: number;
+} | {
+    dx?: undefined;
+    dy?: undefined;
+};

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

@@ -0,0 +1,2 @@
+export * from './mark-point';
+export * from './interface';

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

@@ -0,0 +1,2 @@
+export * from './spec';
+export * from './theme';