@visactor/vchart 1.2.0-beta.6 → 1.2.0-beta.7

package/build/es5/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/build/es5/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';
+import type { ILegend } from '../interface';
+import type { IColorLegendSpec, IColorLegendTheme, ISizeLegendSpec } from './interface';
+import { BaseLegend } from '../base-legend';
+export declare class ContinuousLegend extends BaseLegend {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    protected _spec: IColorLegendSpec | ISizeLegendSpec;
+    protected _theme: IColorLegendTheme;
+    private _field;
+    private _legendType;
+    static createComponent(spec: any, options: IComponentOption): ILegend[] | ContinuousLegend;
+    constructor(spec: any, 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;
+}

package/build/es5/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/build/es5/component/legend/discrete/index.d.ts

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

package/build/es5/component/legend/discrete/interface.d.ts

@@ -0,0 +1,59 @@
+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';
+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[]) => 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/build/es5/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';
+import { DiscreteLegend as LegendComponent } from '@visactor/vrender-components';
+import type { ILegend } from '../interface';
+import { BaseLegend } from '../base-legend';
+export declare class DiscreteLegend extends BaseLegend {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    protected _spec: IDiscreteLegendSpec;
+    protected _theme: IDiscreteLegendTheme;
+    static createComponent(spec: any, options: IComponentOption): DiscreteLegend | ILegend[];
+    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;
+}

package/build/es5/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/build/es5/component/legend/index.d.ts

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

package/build/es5/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 { IModelSpec } from '../../model/interface';
+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';
+    filter?: boolean;
+    title?: ITitle;
+    background?: {
+        visible?: boolean;
+        padding?: IPadding | number | number[];
+        style?: Omit<NoVisibleMarkStyle<IRectMarkSpec>, 'visible' | 'width' | 'height'>;
+    };
+    regionIndex?: number | number[];
+    regionId?: StringOrNumber | StringOrNumber[];
+    seriesIndex?: number | number[];
+    seriesId?: StringOrNumber | StringOrNumber[];
+} & Omit<IModelSpec, 'orient'>;

package/build/es5/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").ISymbolGraphicAttribute>, "visible">;
+    };
+    background?: {
+        visible?: boolean;
+        style?: Omit<import("./interface").NoVisibleMarkStyle<import("../..").IRectMarkSpec>, "visible" | "width" | "height">;
+    };
+    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/build/es5/component/map-label/component.d.ts

@@ -0,0 +1,52 @@
+import type { IRect } from '../../typings/space';
+import { BaseComponent } from '../base';
+import type { IComponentOption } from '../interface';
+import { ComponentTypeEnum } from '../interface';
+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 { PanEventParam, ZoomEventParam } from '../../event/interface';
+export declare class MapLabelComponent extends BaseComponent {
+    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;
+    _spec: IMapLabelSpec;
+    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, import("@visactor/vrender").IGraphic<Partial<import("@visactor/vrender").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;
+}

package/build/es5/component/map-label/index.d.ts

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

package/build/es5/component/map-label/interface.d.ts

@@ -0,0 +1,40 @@
+import type { IGraphic } from '@visactor/vrender';
+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/build/es5/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/build/es5/component/marker/base-marker.d.ts

@@ -0,0 +1,46 @@
+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';
+import type { IAggrType, IDataPos, IDataPosCallback } from './interface';
+export declare abstract class BaseMarker extends BaseComponent {
+    layoutType: LayoutItem['layoutType'];
+    protected _startRelativeSeries: ICartesianSeries;
+    protected _endRelativeSeries: ICartesianSeries;
+    protected _relativeSeries: ICartesianSeries;
+    protected _markerData: DataView;
+    protected _markerComponent: any;
+    created(): void;
+    private _isSpecAggrOrRege;
+    protected _processSpecX(specX: IDataPos | IDataPosCallback): {
+        x: {
+            field: any;
+            aggrType: IAggrType;
+        };
+    } | {
+        x: IDataPos;
+    };
+    protected _processSpecY(specY: IDataPos | IDataPosCallback): {
+        y: {
+            field: any;
+            aggrType: IAggrType;
+        };
+    } | {
+        y: IDataPos;
+    };
+    protected _processSpecCoo(spec: any): any;
+    updateLayoutAttribute(): void;
+    protected _getSeriesByIdOrIndex(seriesUserId: StringOrNumber, seriesIndex: number): ICartesianSeries;
+    protected _bindSeries(): void;
+    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;
+    clear(): void;
+}

package/build/es5/component/marker/interface.d.ts

@@ -0,0 +1,59 @@
+import type { IPadding, IPointLike } from '@visactor/vutils';
+import type { SymbolType } from '@visactor/vrender';
+import type { IModelSpec } from '../../model/interface';
+import type { IRectMarkSpec, ISymbolMarkSpec, ITextMarkSpec, StringOrNumber } from '../../typings';
+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 IMarkerLabelSpec = {
+    visible?: boolean;
+    autoRotate?: boolean;
+    minWidth?: number;
+    maxWidth?: number;
+    labelBackground?: {
+        visible?: boolean;
+        padding?: IPadding;
+        style: Omit<IRectMarkSpec, 'visible'>;
+    };
+    text?: string | string[] | number | number[];
+    formatMethod?: (datum: IDataPos) => string | string[] | number | number[];
+    style?: Omit<ITextMarkSpec, 'visible'>;
+    shape?: {
+        visible?: boolean;
+        style: Omit<ISymbolMarkSpec, 'visible'>;
+    };
+    space?: number;
+} & 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 IModelSpec {
+    relativeSeriesIndex?: number;
+    relativeSeriesId?: number;
+    visible?: boolean;
+    interactive?: boolean;
+    autoRange?: boolean;
+}
+export interface IMarkerSymbol extends IMarkerRef {
+    visible: boolean;
+    symbolType?: SymbolType;
+    size?: number;
+    style?: Omit<ISymbolMarkSpec, 'visible'>;
+}

package/build/es5/component/marker/mark-area/index.d.ts

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

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

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

package/build/es5/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/build/es5/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 { IMarkerLabelSpec } from '../../interface';
+export interface IMarkAreaTheme {
+    area?: {
+        style?: IPolygonMarkSpec;
+    };
+    label?: {
+        position?: IMarkAreaLabelPosition;
+    } & IMarkerLabelSpec;
+}

package/build/es5/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';
+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 implements IMarkArea {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    layoutZIndex: LayoutItem['layoutZIndex'];
+    static speckey: string;
+    protected _spec: IMarkAreaSpec & IMarkAreaTheme;
+    protected _theme: IMarkAreaTheme;
+    protected _markerComponent: MarkAreaComponent;
+    static createComponent(spec: any, options: IComponentOption): MarkArea | MarkArea[];
+    protected _createMarkerComponent(): void;
+    protected _markerLayout(): void;
+    protected _initDataView(): void;
+}

package/build/es5/component/marker/mark-line/index.d.ts

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

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

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

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

@@ -0,0 +1,29 @@
+import type { IComponent } from '../../../interface';
+import type { IAggrType, IMarkerPositionsSpec, IDataPointSpec, IMarkerSpec, IMarkerAxisSpec, IDataPos, IDataPosCallback } from '../../interface';
+import type { IRegressType } from '../../mark-area/interface';
+import type { IMarkLineTheme } from './theme';
+export type IMarkLine = IComponent;
+export type IMarkLineSpec = IMarkerSpec & (IMarkLineXSpec | IMarkLineYSpec | IMarkLineCoordinateSpec | IMarkLinePositionsSpec) & IMarkLineTheme;
+export interface IMarkLineXSpec extends IMarkerAxisSpec {
+    x: IDataPos | IDataPosCallback;
+}
+export interface IMarkLineYSpec extends IMarkerAxisSpec {
+    y: IDataPos | IDataPosCallback;
+}
+export interface IMarkLineAngleSpec extends IMarkerAxisSpec {
+    angle: IDataPos | IDataPosCallback;
+}
+export interface IMarkLineRadiusSpec extends IMarkerAxisSpec {
+    radius: IDataPos | IDataPosCallback;
+}
+export type IMarkLineCoordinateSpec = {
+    coordinates: IDataPointSpec[];
+    process?: {
+        x: IAggrType;
+    } | {
+        y: IAggrType;
+    } | {
+        xy: IRegressType;
+    };
+};
+export type IMarkLinePositionsSpec = IMarkerPositionsSpec;

package/build/es5/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/build/es5/component/marker/mark-line/mark-line.d.ts

@@ -0,0 +1,20 @@
+import type { IMarkLine, IMarkLineSpec, IMarkLineTheme } from './interface';
+import type { IComponentOption } from '../../interface';
+import { ComponentTypeEnum } from '../../interface';
+import { MarkLine as MarkLineComponent } from '@visactor/vrender-components';
+import { BaseMarker } from '../base-marker';
+import type { LayoutItem } from '../../../model/layout-item';
+export declare class MarkLine extends BaseMarker implements IMarkLine {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    layoutZIndex: LayoutItem['layoutZIndex'];
+    static speckey: string;
+    protected _spec: IMarkLineSpec & IMarkLineTheme;
+    protected _theme: IMarkLineTheme;
+    protected _markerComponent: MarkLineComponent;
+    static createComponent(spec: any, options: IComponentOption): MarkLine | MarkLine[];
+    protected _createMarkerComponent(): void;
+    protected _markerLayout(): void;
+    protected _initDataView(): void;
+}

package/build/es5/component/marker/mark-point/index.d.ts

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

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

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