@visactor/vchart-types 0.16.17-alpha.0

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

@@ -0,0 +1,63 @@
+import type { DataView } from '@visactor/vdataset';
+import type { IRegion } from '../../region/interface';
+import { BaseComponent } from '../base/base-component';
+import type { IEffect, ILayoutRect } from '../../model/interface';
+import type { LayoutItem } from '../../model/layout-item';
+import type { IOrientType, IPoint, StringOrNumber } from '../../typings';
+import { CompilableData } from '../../compile/data/compilable-data';
+import type { ILegend, ILegendCommonSpec } from './interface';
+import type { IGraphic, IGroup } from '@visactor/vrender-core';
+export declare abstract class BaseLegend<T extends ILegendCommonSpec> extends BaseComponent<T> implements ILegend {
+    layoutType: LayoutItem['layoutType'];
+    layoutZIndex: LayoutItem['layoutZIndex'];
+    layoutLevel: number;
+    protected _orient: IOrientType;
+    get orient(): IOrientType;
+    protected _visible: boolean;
+    get visible(): boolean;
+    protected _position: 'start' | 'middle' | 'end';
+    get position(): "middle" | "start" | "end";
+    get layoutOrient(): IOrientType;
+    set layoutOrient(v: IOrientType);
+    protected _legendData: CompilableData;
+    getLegendData(): any;
+    private _preSelectedData;
+    protected _selectedData: StringOrNumber[];
+    getSelectedData(): StringOrNumber[];
+    protected _legendComponent: IGroup;
+    private _cacheAttrs;
+    effect: IEffect;
+    protected _seriesUserId?: StringOrNumber[];
+    protected _seriesIndex?: number[];
+    protected _regionUserId?: StringOrNumber[];
+    protected _regionUserIndex?: number[];
+    setAttrFromSpec(): void;
+    created(): void;
+    onRender(ctx: any): void;
+    _compareSpec(): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    changeRegions(regions: IRegion[]): void;
+    protected abstract _initLegendData(): DataView;
+    protected abstract _initSelectedData(): void;
+    protected abstract _getLegendAttributes(rect: ILayoutRect): any;
+    protected abstract _getLegendConstructor(): any;
+    protected abstract _initEvent(): void;
+    private _bindLegendDataChange;
+    protected initData(): void;
+    setSelectedData(selectedData: StringOrNumber[]): void;
+    setLayoutStartPosition(pos: Partial<IPoint>): void;
+    _boundsInRect(rect: ILayoutRect, fullSpace: ILayoutRect): {
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+    };
+    onDataUpdate(): void;
+    getVRenderComponents(): IGraphic[];
+    clear(): void;
+}

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

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

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

@@ -0,0 +1,58 @@
+import type { IRectMarkSpec, ISymbolMarkSpec, ITextMarkSpec, StringOrNumber } from '../../../typings';
+import type { ILegendCommonSpec, NoVisibleMarkStyle } from '../interface';
+type Text = StringOrNumber;
+export type TextAttribute = {
+    visible?: boolean;
+    text?: Text;
+    space?: number;
+    style?: Omit<NoVisibleMarkStyle<ITextMarkSpec>, 'text'>;
+};
+export type HandlerTextAttribute = {
+    visible?: boolean;
+    precision?: number;
+    formatter?: (text: Text) => Text;
+    space?: number;
+    style?: Omit<NoVisibleMarkStyle<ITextMarkSpec>, 'text'>;
+};
+export type IContinuousLegendSpec = ILegendCommonSpec & {
+    field?: string;
+    scale?: string;
+    defaultSelected?: [number, number];
+    slidable?: boolean;
+    rail?: {
+        width?: number;
+        height?: number;
+        style?: Omit<NoVisibleMarkStyle<IRectMarkSpec>, 'width' | 'height'>;
+    };
+    handler?: {
+        visible?: boolean;
+        style?: NoVisibleMarkStyle<ISymbolMarkSpec>;
+    };
+    track?: {
+        style?: Omit<NoVisibleMarkStyle<IRectMarkSpec>, 'width' | 'height'>;
+    };
+    startText?: TextAttribute;
+    endText?: TextAttribute;
+    handlerText?: HandlerTextAttribute;
+};
+export type IColorLegendSpec = IContinuousLegendSpec & {
+    type: 'color';
+};
+export type ISizeLegendSpec = IContinuousLegendSpec & {
+    type: 'size';
+    sizeBackground?: Omit<NoVisibleMarkStyle<IRectMarkSpec>, 'visible' | 'width' | 'height'>;
+};
+export type IContinuousLegendTheme = Omit<IContinuousLegendSpec, 'type' | 'field' | 'scale' | 'regionIndex' | 'regionId' | 'seriesIndex' | 'seriesId' | 'id' | 'defaultSelected'>;
+export interface IColorLegendTheme {
+    horizontal?: IContinuousLegendTheme;
+    vertical?: IContinuousLegendTheme;
+}
+export interface ISizeLegendTheme {
+    horizontal?: IContinuousLegendTheme & {
+        sizeBackground?: ISizeLegendSpec['sizeBackground'];
+    };
+    vertical?: IContinuousLegendTheme & {
+        sizeBackground?: ISizeLegendSpec['sizeBackground'];
+    };
+}
+export {};

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

@@ -0,0 +1,27 @@
+import { DataView } from '@visactor/vdataset';
+import type { IModelInitOption, ILayoutRect } from '../../../model/interface';
+import type { IComponentOption } from '../../interface';
+import { ComponentTypeEnum } from '../../interface/type';
+import type { ILegend } from '../interface';
+import type { IColorLegendSpec, IColorLegendTheme, ISizeLegendSpec } from './interface';
+import { BaseLegend } from '../base-legend';
+export declare class ContinuousLegend<T extends IColorLegendSpec | ISizeLegendSpec = IColorLegendSpec | ISizeLegendSpec> extends BaseLegend<T> {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    protected _theme: IColorLegendTheme;
+    private _field;
+    private _legendType;
+    static createComponent(spec: any, options: IComponentOption): ContinuousLegend<any> | ILegend[];
+    constructor(spec: T, options: IComponentOption);
+    setAttrFromSpec(): void;
+    init(option: IModelInitOption): void;
+    private _getScaleInGlobal;
+    protected _initLegendData(): DataView;
+    protected _initSelectedData(): void;
+    private _addDefaultTitleText;
+    protected _getLegendAttributes(rect: ILayoutRect): any;
+    protected _getLegendConstructor(): any;
+    protected _initEvent(): void;
+}
+export declare const registerContinuousLegend: () => void;

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

@@ -0,0 +1,8 @@
+import type { IColorLegendSpec, ISizeLegendSpec } from './interface';
+import { ColorContinuousLegend, SizeContinuousLegend } from '@visactor/vrender-components';
+export declare function getContinuousLegendAttributes(spec: IColorLegendSpec | ISizeLegendSpec): any;
+export declare function isContinuousLegend(type: string): boolean;
+export declare const ContinuousLegendMap: {
+    color: typeof ColorContinuousLegend;
+    size: typeof SizeContinuousLegend;
+};

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

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

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,26 @@
+import { DataView } from '@visactor/vdataset';
+import type { IDiscreteLegendSpec, IDiscreteLegendTheme } from './interface';
+import type { ISeries } from '../../../series/interface';
+import type { IModelInitOption, ILayoutRect } from '../../../model/interface';
+import type { IComponentOption } from '../../interface';
+import { ComponentTypeEnum } from '../../interface/type';
+import { DiscreteLegend as LegendComponent } from '@visactor/vrender-components';
+import type { ILegend } from '../interface';
+import { BaseLegend } from '../base-legend';
+export declare class DiscreteLegend extends BaseLegend<IDiscreteLegendSpec> {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    protected _theme: IDiscreteLegendTheme;
+    static createComponent(spec: any, options: IComponentOption): ILegend[] | DiscreteLegend;
+    init(option: IModelInitOption): void;
+    protected _initLegendData(): DataView;
+    protected _getSeriesLegendField(s: ISeries): string;
+    protected _initSelectedData(): void;
+    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 { ILayoutRect } from '../../../model/interface';
+import type { IDiscreteLegendSpec } from './interface';
+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,39 @@
+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'>;
+    };
+} & Omit<IComponentSpec, 'orient'>;
+export type ILegendSpec = IDiscreteLegendSpec | IColorLegendSpec | ISizeLegendSpec;

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

@@ -0,0 +1,26 @@
+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>, "width" | "height" | "visible">;
+    };
+    text?: string | number | string[] | number[];
+    visible?: boolean;
+    padding?: import("@visactor/vrender-components/es/core/type").Padding;
+    maxWidth?: number;
+    minWidth?: number;
+    space?: number;
+    align?: "center" | "start" | "end";
+};
+export declare function getLayout(spec: ILegendCommonSpec): "vertical" | "horizontal";

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

@@ -0,0 +1,54 @@
+import type { IRect } from '../../typings/space';
+import { BaseComponent } from '../base/base-component';
+import type { IComponentOption } from '../interface';
+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 type { LayoutItem } from '../../model/layout-item';
+import { MarkPoint } from '@visactor/vrender-components';
+import type { IGraphic } from '@visactor/vrender-core';
+import type { PanEventParam, ZoomEventParam } from '../../event/interface';
+export declare class MapLabelComponent extends BaseComponent<IMapLabelSpec> {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    layoutType: LayoutItem['layoutType'];
+    static speckey: string;
+    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 createComponent(spec: any, options: IComponentOption): MapLabelComponent;
+    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;
+    getVRenderComponents(): 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,66 @@
+import type { DataView } from '@visactor/vdataset';
+import type { IModelRenderOption } from '../../model/interface';
+import type { LayoutItem } from '../../model/layout-item';
+import type { IRegion } from '../../region/interface';
+import type { ICartesianSeries } from '../../series/interface';
+import type { StringOrNumber } 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> {
+    layoutType: LayoutItem['layoutType'];
+    protected _startRelativeSeries: ICartesianSeries;
+    protected _endRelativeSeries: ICartesianSeries;
+    protected _relativeSeries: ICartesianSeries;
+    protected _markerData: DataView;
+    protected _markerComponent: any;
+    created(): void;
+    private _isSpecAggr;
+    private _getAllRelativeSeries;
+    protected _processSpecX(specX: IDataPos | IDataPosCallback): {
+        getRelativeSeries: () => ICartesianSeries;
+        getStartRelativeSeries: () => ICartesianSeries;
+        getEndRelativeSeries: () => ICartesianSeries;
+        x: {
+            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: {
+            field: any;
+            aggrType: IAggrType;
+        };
+    } | {
+        getRelativeSeries: () => ICartesianSeries;
+        getStartRelativeSeries: () => ICartesianSeries;
+        getEndRelativeSeries: () => ICartesianSeries;
+        y: IDataPos | IDataPosCallback;
+    };
+    protected _processSpecCoo(spec: any): any;
+    updateLayoutAttribute(): void;
+    protected _getSeriesByIdOrIndex(seriesUserId: StringOrNumber, seriesIndex: number): ICartesianSeries;
+    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 _markerLayout(): void;
+    protected initEvent(): void;
+    onRender(ctx: IModelRenderOption): void;
+    changeRegions(regions: IRegion[]): void;
+    protected getFirstSeries(): ICartesianSeries;
+    getVRenderComponents(): IGraphic[];
+}

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

@@ -0,0 +1,65 @@
+import type { IPadding, IPointLike } from '@visactor/vutils';
+import type { SymbolType } 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';
+export type IAggrType = 'sum' | 'average' | 'min' | 'max' | 'variance' | 'standardDeviation' | 'median';
+export type IDataPos = string | number | IAggrType;
+export type IDataPosCallback = (relativeSeriesData: any, startRelativeSeriesData: any, endRelativeSeriesData: any) => IDataPos;
+export type IDataPointSpec = {
+    [key: string]: IDataPos;
+    refRelativeSeriesIndex?: number;
+    refRelativeSeriesId?: StringOrNumber;
+};
+export type IMarkerPositionsSpec = {
+    positions: IPointLike[];
+};
+export type IMarkerLabelWithoutRefSpec = {
+    visible?: boolean;
+    autoRotate?: boolean;
+    minWidth?: number;
+    maxWidth?: number;
+    labelBackground?: {
+        visible?: boolean;
+        padding?: IPadding | number[] | number;
+        style: Omit<IRectMarkSpec, 'visible'>;
+    };
+    text?: string | string[] | number | number[];
+    formatMethod?: (markData: Datum[], seriesData: Datum[]) => string | string[] | number | number[];
+    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 IMarkerAxisSpec {
+    startRelativeSeriesIndex?: number;
+    endRelativeSeriesIndex?: number;
+    startRelativeSeriesId?: string;
+    endRelativeSeriesId?: string;
+    relativeRelativeSeriesIndex?: number;
+}
+export interface IMarkerSpec extends IComponentSpec {
+    relativeSeriesIndex?: number;
+    relativeSeriesId?: number | string;
+    visible?: boolean;
+    interactive?: boolean;
+    autoRange?: boolean;
+    clip?: boolean;
+}
+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,26 @@
+import type { IComponent } from '../../../interface';
+import type { IMarkerPositionsSpec, IDataPointSpec, IDataPos, IMarkerSpec, IMarkerAxisSpec, IDataPosCallback } from '../../interface';
+import type { IMarkAreaTheme } from './theme';
+export type IMarkArea = IComponent;
+export type IRegressType = 'regression';
+export type IMarkAreaSpec = IMarkerSpec & (IMarkAreaXSpec | IMarkAreaYSpec | IMarkAreaCoordinateSpec | IMarkAreaPositionsSpec) & IMarkAreaTheme;
+export interface IMarkAreaXSpec extends IMarkerAxisSpec {
+    x: IDataPos | IDataPosCallback;
+    x1: IDataPos | IDataPosCallback;
+}
+export interface IMarkAreaYSpec extends IMarkerAxisSpec {
+    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 type IMarkAreaCoordinateSpec = {
+    coordinates: IDataPointSpec[];
+};
+export type IMarkAreaPositionsSpec = IMarkerPositionsSpec;

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,20 @@
+import type { IMarkArea, IMarkAreaSpec, IMarkAreaTheme } from './interface';
+import type { IComponentOption } from '../../interface';
+import { ComponentTypeEnum } from '../../interface/type';
+import { MarkArea as MarkAreaComponent } from '@visactor/vrender-components';
+import { BaseMarker } from '../base-marker';
+import type { LayoutItem } from '../../../model/layout-item';
+export declare class MarkArea extends BaseMarker<IMarkAreaSpec & IMarkAreaTheme> implements IMarkArea {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    layoutZIndex: LayoutItem['layoutZIndex'];
+    static speckey: string;
+    protected _theme: IMarkAreaTheme;
+    protected _markerComponent: MarkAreaComponent;
+    static createComponent(spec: any, options: IComponentOption): MarkArea | MarkArea[];
+    protected _createMarkerComponent(): void;
+    protected _markerLayout(): void;
+    protected _initDataView(): void;
+}
+export declare const registerMarkArea: () => void;