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

package/build/es5/component/data-zoom/index.d.ts

@@ -0,0 +1,2 @@
+export * from './data-zoom';
+export * from './scroll-bar';

package/build/es5/component/data-zoom/interface.d.ts

@@ -0,0 +1,25 @@
+import type { IModelSpec } from '../../model/interface';
+import type { IOrientType } from '../../typings';
+import type { IComponent } from '../interface';
+export interface IDataFilterComponentSpec extends Omit<IModelSpec, 'width' | 'height'> {
+    visible?: boolean;
+    orient?: IOrientType;
+    width?: 'auto' | number;
+    height?: 'auto' | number;
+    field?: string;
+    axisId?: string;
+    axisIndex?: number;
+    regionIndex?: number | number[];
+    regionId?: string | string[];
+    filterMode?: 'filter' | 'axis';
+    start?: number;
+    end?: number;
+    startValue?: number | string;
+    endValue?: number | string;
+    rangeMode?: [string, string];
+    autoIndent?: boolean;
+    roam?: boolean;
+}
+export interface IDataFilterComponent extends IComponent {
+    setStartAndEnd: (start: number, end: number) => any;
+}

package/build/es5/component/data-zoom/scroll-bar/index.d.ts

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

package/build/es5/component/data-zoom/scroll-bar/interface.d.ts

@@ -0,0 +1,20 @@
+import type { IPadding } from '../../../typings';
+import type { IRectMarkSpec } from '../../../typings/visual';
+import type { IDataFilterComponentSpec } from '../interface';
+export interface IScrollBarStyle {
+    rail?: Omit<IRectMarkSpec, 'width' | 'height'>;
+    slider?: Omit<IRectMarkSpec, 'width' | 'height'>;
+}
+export interface IScrollBarSpec extends IDataFilterComponentSpec, IScrollBarStyle {
+    round?: boolean;
+    innerPadding?: number | number[] | IPadding;
+    range?: [number, number];
+    limitRange?: [number, number];
+}
+export type IScrollBarTheme = IScrollBarStyle & {
+    orient?: IScrollBarSpec['orient'];
+    width?: IScrollBarSpec['width'];
+    height?: IScrollBarSpec['height'];
+    round?: IScrollBarSpec['round'];
+    innerPadding?: IScrollBarSpec['innerPadding'];
+};

package/build/es5/component/data-zoom/scroll-bar/scroll-bar.d.ts

@@ -0,0 +1,23 @@
+import type { IComponentOption } from '../../interface';
+import { ComponentTypeEnum } from '../../interface';
+import { DataFilterBaseComponent } from '../data-filter-base-component';
+import type { ScrollBarAttributes } from '@visactor/vrender-components';
+import { ScrollBar as ScrollBarComponent } from '@visactor/vrender-components';
+export declare class ScrollBar extends DataFilterBaseComponent {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    layoutZIndex: number;
+    layoutLevel: number;
+    protected _component: ScrollBarComponent;
+    static createComponent(spec: any, options: IComponentOption): ScrollBar | ScrollBar[];
+    onLayoutEnd(ctx: any): void;
+    protected _updateScaleRange(): void;
+    protected _computeWidth(): number;
+    protected _computeHeight(): number;
+    protected _createOrUpdateComponent(): void;
+    protected _handleChange(start: number, end: number, updateComponent?: boolean): void;
+    protected _handleDataCollectionChange(): void;
+    protected _initEvent(): void;
+    protected _getComponentAttrs(): Partial<ScrollBarAttributes>;
+}

package/build/es5/component/data-zoom/util.d.ts

@@ -0,0 +1,19 @@
+export interface IDataFilterWithNewDomainOption {
+    getNewDomain: () => any[];
+    isContinuous: () => boolean;
+    field: () => string;
+}
+export declare const dataFilterWithNewDomain: (data: Array<any>, op: IDataFilterWithNewDomainOption) => any[];
+export interface IDataFilterComputeDomainOption {
+    input: {
+        dataCollection: any[];
+        stateFields: string[];
+        valueFields: string[];
+        method: 'sum';
+    };
+    output: {
+        stateField: string;
+        valueField: string;
+    };
+}
+export declare const dataFilterComputeDomain: (data: Array<any>, op: IDataFilterComputeDomainOption) => any[];

package/build/es5/component/geo/geo-coordinate.d.ts

@@ -0,0 +1,53 @@
+import type { IPoint } from '../../typings/coordinate';
+import { Projection } from './projection';
+import type { IEffect, IModelLayoutOption, IModelRenderOption, ILayoutItem } from '../../model/interface';
+import type { IComponentOption } from '../interface';
+import { ComponentTypeEnum } from '../interface';
+import { BaseComponent } from '../base';
+import type { IGeoRegionSpec, IRegion } from '../../region/interface';
+import type { IGeoCoordinate, IGeoCoordinateSpec, IProjectionSpec } from './interface';
+import type { IChartSpec } from '../../typings';
+export declare function projectionName(key: string, id: number): string;
+export declare class GeoCoordinate extends BaseComponent implements IGeoCoordinate {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    layoutType: ILayoutItem['layoutType'];
+    protected _spec: IGeoRegionSpec;
+    _longitudeField?: string;
+    get longitudeField(): string;
+    _latitudeField?: string;
+    get latitudeField(): string;
+    protected _projectionSpec: IProjectionSpec;
+    get projectionSpec(): IProjectionSpec;
+    setProjection(projectionSpec: IGeoCoordinateSpec['projection']): void;
+    protected _projection: Projection;
+    private _actualScale;
+    private _evaluated;
+    private _lastHeight;
+    private _lastWidth;
+    static createComponent(spec: IChartSpec, options: IComponentOption): IGeoCoordinate[];
+    effect: IEffect;
+    setAttrFromSpec(): void;
+    created(): void;
+    private _handleChartZoom;
+    dispatchZoom(zoomDelta: number, center?: {
+        x: number;
+        y: number;
+    }): void;
+    initEvent(): void;
+    initProjection(): void;
+    coordinateHelper(): void;
+    onLayoutEnd(ctx: IModelLayoutOption): void;
+    onRender(ctx: IModelRenderOption): void;
+    changeRegions(regions: IRegion[]): void;
+    protected collectFeatures(): any[];
+    dataToPosition(values?: number[]): IPoint;
+    dataToLatitude(lat: number): number;
+    dataToLongitude(lon: number): number;
+    zoom(p: number, anchor?: [number, number]): void;
+    pan: (delta?: [number, number]) => void;
+    shape(datum?: any): any;
+    private evaluateProjection;
+    private rescaleMark;
+}

package/build/es5/component/geo/index.d.ts

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

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

@@ -0,0 +1,27 @@
+import type { IPoint } from '../../typings/coordinate';
+import type { ProjectionType } from '@visactor/vgrammar';
+import type { IComponent } from '../interface';
+export interface IProjectionSpec {
+    name: string;
+    type: ProjectionType;
+    zoom?: number;
+    center?: [number, number];
+}
+export interface IGeoCoordinate extends IComponent {
+    projectionSpec: IProjectionSpec;
+    longitudeField?: string;
+    latitudeField?: string;
+    dataToPosition: (values: any[]) => IPoint;
+}
+export interface IGeoCoordinateHelper {
+    longitudeField?: string;
+    latitudeField?: string;
+    dataToPosition: (values: [number, number]) => IPoint;
+    dataToLatitude: (lat: number) => number;
+    dataToLongitude: (lon: number) => number;
+    shape: (datum: any) => string;
+    getCoordinateId: () => number;
+}
+export interface IGeoCoordinateSpec {
+    projection: Omit<IProjectionSpec, 'name'>;
+}

package/build/es5/component/geo/projection.d.ts

@@ -0,0 +1,16 @@
+import type { IProjectionSpec } from './interface';
+type GeoJsonFeatureSpec = any;
+export declare class Projection {
+    projection: any;
+    constructor(projectionSpec: IProjectionSpec);
+    fit(start: number[], size: number[], features: GeoJsonFeatureSpec[]): void;
+    center(center: [number, number]): void;
+    project(point: [number, number]): any;
+    shape(data: GeoJsonFeatureSpec): any;
+    scale(): number;
+    scale(scale: number): void;
+    translate(): [number, number];
+    translate(point: [number, number]): void;
+    evaluate(start: number[], size: number[], features: GeoJsonFeatureSpec[]): any;
+}
+export {};

package/build/es5/component/index.d.ts

@@ -0,0 +1,39 @@
+import type { IScrollBarSpec } from './data-zoom/scroll-bar';
+import { ScrollBar } from './data-zoom/scroll-bar';
+import type { IDataZoomSpec } from './data-zoom/data-zoom';
+import { DataZoom } from './data-zoom/data-zoom';
+import { CustomMark } from './custom-mark';
+import type { IBrushSpec } from './brush';
+import { Brush } from './brush';
+import type { IMapLabelSpec } from './map-label';
+import { MapLabelComponent } from './map-label';
+import type { ICartesianLinearAxisSpec, ICartesianBandAxisSpec, ICartesianTimeAxisSpec, ICartesianAxisSpec, ICartesianLogAxisSpec } from './axis/cartesian/index';
+import { CartesianAxis, CartesianLinearAxis, CartesianBandAxis, CartesianTimeAxis, CartesianLogAxis } from './axis/cartesian/index';
+import type { IPolarAxisSpec, IPolarBandAxisSpec, IPolarLinearAxisSpec } from './axis/polar';
+import { PolarAxis, PolarBandAxis, PolarLinearAxis } from './axis/polar';
+import type { IDiscreteLegendSpec } from './legend/discrete';
+import { DiscreteLegend } from './legend/discrete';
+import type { IContinuousLegendSpec } from './legend/continuous';
+import { ContinuousLegend } from './legend/continuous';
+import type { IIndicatorSpec } from './indicator';
+import { Indicator } from './indicator';
+import type { ITitleSpec } from './title';
+import { Title } from './title';
+import type { IGeoCoordinateSpec } from './geo';
+import { GeoCoordinate } from './geo';
+import type { ICartesianCrosshairSpec, IPolarCrosshairSpec } from './crosshair';
+import { CartesianCrossHair, PolarCrossHair } from './crosshair';
+import type { IPlayerSpec } from './player';
+import { Player } from './player';
+import type { IMarkLineSpec } from './marker/mark-line';
+import { MarkLine } from './marker/mark-line';
+import type { IMarkAreaSpec } from './marker/mark-area';
+import { MarkArea } from './marker/mark-area';
+import type { IMarkPointSpec } from './marker/mark-point';
+import { MarkPoint } from './marker/mark-point';
+import type { ITooltipSpec } from './tooltip';
+import { Tooltip } from './tooltip';
+import type { ILabelSpec } from './label';
+import { Label } from './label';
+export { ScrollBar, DataZoom, CustomMark, Brush, MapLabelComponent, CartesianAxis, CartesianBandAxis, CartesianLinearAxis, CartesianTimeAxis, CartesianLogAxis, PolarAxis, PolarBandAxis, PolarLinearAxis, DiscreteLegend, ContinuousLegend, Indicator, Title, GeoCoordinate, CartesianCrossHair, PolarCrossHair, Player, MarkArea, MarkLine, MarkPoint, Tooltip, Label };
+export type { IScrollBarSpec, IBrushSpec, ICartesianAxisSpec, ICartesianBandAxisSpec, ICartesianCrosshairSpec, ICartesianLinearAxisSpec, ICartesianTimeAxisSpec, ICartesianLogAxisSpec, IContinuousLegendSpec, IDataZoomSpec, IDiscreteLegendSpec, IGeoCoordinateSpec, IIndicatorSpec, ILabelSpec, IMapLabelSpec, IMarkAreaSpec, IMarkLineSpec, IMarkPointSpec, IPlayerSpec, IPolarAxisSpec, IPolarBandAxisSpec, IPolarCrosshairSpec, IPolarLinearAxisSpec, ITitleSpec, ITooltipSpec };

package/build/es5/component/indicator/index.d.ts

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

package/build/es5/component/indicator/indicator.d.ts

@@ -0,0 +1,38 @@
+import type { IComponentOption } from '../interface';
+import { ComponentTypeEnum } from '../interface';
+import type { LayoutItem } from '../../model/layout-item';
+import { BaseComponent } from '../base';
+import type { IRegion } from '../../region/interface';
+import type { IIndicator, IIndicatorTheme } from './interface';
+import type { Maybe } from '../../typings';
+export declare class Indicator extends BaseComponent implements IIndicator {
+    static speckey: string;
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    layoutType: LayoutItem['layoutType'];
+    layoutZIndex: number;
+    layoutLevel: number;
+    private _gap;
+    private _activeDatum;
+    private _displayData;
+    private _title;
+    private _content;
+    private _indicatorComponent;
+    private _cacheAttrs;
+    protected _theme: Maybe<IIndicatorTheme>;
+    static createComponent(spec: any, options: IComponentOption): import("../interface").IComponent[];
+    created(): void;
+    setAttrFromSpec(): void;
+    onRender(ctx: any): void;
+    changeRegions(regions: IRegion[]): void;
+    protected initEvent(): void;
+    private updateDatum;
+    private initData;
+    updateLayoutAttribute(): void;
+    private _getIndicatorAttrs;
+    private _createOrUpdateIndicatorComponent;
+    private _createText;
+    private isRelativeModel;
+    clear(): void;
+}

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

@@ -0,0 +1,31 @@
+import type { IModelSpec } from '../../model/interface';
+import type { ConvertToMarkStyleSpec, ITextMarkSpec } from '../../typings/visual';
+import type { IComponent } from '../interface';
+export interface IIndicatorItemSpec {
+    visible?: boolean;
+    field?: string;
+    space?: number;
+    autoLimit?: boolean;
+    autoFit?: boolean;
+    fitPercent?: number;
+    style?: Omit<ConvertToMarkStyleSpec<ITextMarkSpec>, 'visible'>;
+}
+export type IIndicator = IComponent;
+export interface IIndicatorSpec extends IModelSpec {
+    visible?: boolean;
+    fixed?: boolean;
+    trigger?: 'hover' | 'select' | 'none';
+    gap?: number;
+    offsetX?: number;
+    offsetY?: number;
+    limitRatio?: number;
+    title?: IIndicatorItemSpec;
+    content?: IIndicatorItemSpec[] | IIndicatorItemSpec;
+}
+export interface IIndicatorItemTheme extends IIndicatorItemSpec {
+    style?: Omit<ITextMarkSpec, 'visible'>;
+}
+export interface IIndicatorTheme extends IIndicatorSpec {
+    title?: IIndicatorItemTheme;
+    content?: IIndicatorItemTheme;
+}

package/build/es5/component/indicator/util.d.ts

@@ -0,0 +1,13 @@
+import type { IIndicatorItemSpec } from './interface';
+export interface IIndicatorDatum {
+    type: 'title' | 'content';
+    index: number;
+    datum: any;
+    spec: IIndicatorItemSpec;
+}
+export interface IIndicatorMapper {
+    title: IIndicatorItemSpec;
+    content: IIndicatorItemSpec[];
+    datum: () => any;
+}
+export declare const indicatorMapper: (data: Array<any>, op: IIndicatorMapper) => any[];

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

@@ -0,0 +1,34 @@
+import type { ISeriesFilter } from '../../region/interface';
+import type { IAnimate } from '../../animation/interface';
+import type { ILayoutItem, IModel, IModelOption } from '../../model/interface';
+import type { IRegion } from '../../region/interface';
+import type { ISeries } from '../../series/interface';
+import type { StringOrNumber } from '../../typings';
+export interface IComponentOption extends IModelOption {
+    getAllRegions: () => IRegion[];
+    getRegionsInIndex: (index?: number[]) => IRegion[];
+    getRegionsInIds: (ids: number[]) => IRegion[];
+    getRegionsInUserIdOrIndex: (user_ids?: StringOrNumber[], index?: number[]) => IRegion[];
+    defaultSpec?: any;
+    getAllSeries: () => ISeries[];
+    getSeriesInIndex: (index?: number[]) => ISeries[];
+    getSeriesInIds: (ids?: number[]) => ISeries[];
+    getSeriesInUserIdOrIndex: (user_ids?: StringOrNumber[], index?: number[]) => ISeries[];
+    getAllComponents: () => IComponent[];
+    getComponentByIndex: (key: string, index: number) => IComponent | undefined;
+    getComponentByUserId: (userId: StringOrNumber) => IComponent | undefined;
+    getComponentsByKey: (key: string) => IComponent[];
+}
+export interface IComponent extends IModel, ILayoutItem {
+    readonly name: string;
+    readonly animate?: IAnimate;
+    getRegions: () => IRegion[];
+    getBindSeriesFilter?: () => ISeriesFilter;
+    changeRegions: (regions: IRegion[]) => void;
+    clear: () => void;
+}
+export interface IComponentConstructor {
+    type: string;
+    createComponent: (spec: any, options: IComponentOption) => IComponent | IComponent[] | undefined;
+    new (spec: any, options: IComponentOption): IComponent;
+}

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

@@ -0,0 +1,4 @@
+export * from './common';
+export * from './type';
+export * from './tooltip-helper';
+export * from './theme';

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

@@ -0,0 +1,40 @@
+import type { PopTipAttributes } from '@visactor/vrender-components';
+import type { IAxisCommonTheme, ICartesianAxisCommonTheme, IPolarAxisCommonTheme } from '../axis';
+import type { IBrushTheme } from '../brush';
+import type { ICrosshairTheme } from '../crosshair/interface';
+import type { IDataZoomTheme, IScrollBarTheme } from '../data-zoom';
+import type { IIndicatorTheme } from '../indicator/interface';
+import type { IDiscreteLegendTheme, IColorLegendTheme, ISizeLegendTheme } from '../legend';
+import type { IMapLabelTheme } from '../map-label';
+import type { IMarkAreaTheme } from '../marker/mark-area/interface';
+import type { IMarkLineTheme } from '../marker/mark-line/interface';
+import type { IMarkPointTheme } from '../marker/mark-point/interface';
+import type { IPlayerTheme } from '../player';
+import type { ITitleTheme } from '../title';
+import type { ITooltipTheme } from '../tooltip/interface';
+import type { ComponentTypeEnum } from './type';
+export interface IComponentTheme {
+    axis?: IAxisCommonTheme;
+    axisBand?: IAxisCommonTheme;
+    axisLinear?: IAxisCommonTheme;
+    axisX?: ICartesianAxisCommonTheme;
+    axisY?: ICartesianAxisCommonTheme;
+    axisRadius?: IPolarAxisCommonTheme;
+    axisAngle?: IPolarAxisCommonTheme;
+    [ComponentTypeEnum.discreteLegend]?: IDiscreteLegendTheme;
+    [ComponentTypeEnum.colorLegend]?: IColorLegendTheme;
+    [ComponentTypeEnum.sizeLegend]?: ISizeLegendTheme;
+    [ComponentTypeEnum.markLine]?: IMarkLineTheme;
+    [ComponentTypeEnum.markArea]?: IMarkAreaTheme;
+    [ComponentTypeEnum.markPoint]?: IMarkPointTheme;
+    [ComponentTypeEnum.tooltip]?: ITooltipTheme;
+    [ComponentTypeEnum.crosshair]?: ICrosshairTheme;
+    [ComponentTypeEnum.dataZoom]?: IDataZoomTheme;
+    [ComponentTypeEnum.scrollBar]?: IScrollBarTheme;
+    [ComponentTypeEnum.indicator]?: IIndicatorTheme;
+    [ComponentTypeEnum.player]?: IPlayerTheme;
+    [ComponentTypeEnum.brush]?: IBrushTheme;
+    [ComponentTypeEnum.title]?: ITitleTheme;
+    [ComponentTypeEnum.mapLabel]?: IMapLabelTheme;
+    [ComponentTypeEnum.poptip]?: PopTipAttributes;
+}

package/build/es5/component/interface/tooltip-helper.d.ts

@@ -0,0 +1,5 @@
+import type { ITooltipHelper } from '../../model/tooltip-helper';
+import type { IComponent } from './common';
+export interface IComponentTooltipHelper extends ITooltipHelper {
+    component: IComponent;
+}

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

@@ -0,0 +1,33 @@
+export type ComponentType = keyof typeof ComponentTypeEnum | string;
+export declare enum ComponentTypeEnum {
+    cartesianAxis = "cartesianAxis",
+    cartesianBandAxis = "cartesianAxis-band",
+    cartesianLinearAxis = "cartesianAxis-linear",
+    cartesianTimeAxis = "cartesianAxis-time",
+    cartesianLogAxis = "cartesianAxis-log",
+    polarAxis = "polarAxis",
+    polarBandAxis = "polarAxis-band",
+    polarLinearAxis = "polarAxis-linear",
+    crosshair = "crosshair",
+    cartesianCrosshair = "cartesianCrosshair",
+    polarCrosshair = "polarCrosshair",
+    dataZoom = "dataZoom",
+    geoCoordinate = "geoCoordinate",
+    indicator = "indicator",
+    discreteLegend = "discreteLegend",
+    continuousLegend = "continuousLegend",
+    colorLegend = "colorLegend",
+    sizeLegend = "sizeLegend",
+    mapLabel = "mapLabel",
+    markLine = "markLine",
+    markArea = "markArea",
+    markPoint = "markPoint",
+    tooltip = "tooltip",
+    title = "title",
+    player = "player",
+    scrollBar = "scrollBar",
+    label = "label",
+    brush = "brush",
+    poptip = "poptip",
+    customMark = "customMark"
+}

package/build/es5/component/label/bar.d.ts

@@ -0,0 +1,9 @@
+import type { ILabelInfo } from './label';
+import type { Strategy } from '@visactor/vrender-components';
+export declare function barLabel(labelInfo: ILabelInfo): {
+    position: string | ((data: any) => string);
+    overlap: boolean | {
+        strategy: Strategy[];
+    };
+    smartInvert: boolean;
+};

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

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

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

@@ -0,0 +1,21 @@
+import type { BaseLabelAttrs } from '@visactor/vrender-components';
+import type { ConvertToMarkStyleSpec, ITextMarkSpec } from '../../typings';
+export interface ILabelSpec {
+    visible?: boolean;
+    interactive?: boolean;
+    formatMethod?: (text: string | string[], datum?: any) => string | string[];
+    offset?: number;
+    position?: string;
+    style?: ConvertToMarkStyleSpec<ITextMarkSpec>;
+    state?: LabelStateStyle<Partial<ITextMarkSpec>>;
+    overlap?: BaseLabelAttrs['overlap'];
+    smartInvert?: BaseLabelAttrs['smartInvert'];
+    animation?: BaseLabelAttrs['animation'];
+}
+type LabelStateStyle<T> = {
+    hover?: T;
+    hover_reverse?: T;
+    selected?: T;
+    selected_reverse?: T;
+};
+export {};

package/build/es5/component/label/label.d.ts

@@ -0,0 +1,62 @@
+import { BaseComponent } from '../base';
+import type { IComponentOption } from '../interface';
+import { ComponentTypeEnum } from '../interface';
+import type { IRegion } from '../../region/interface';
+import type { IModelInitOption, IModelRenderOption } from '../../model/interface';
+import type { LayoutItem } from '../../model/layout-item';
+import { type IMark } from '../../mark/interface';
+import type { ITextMark } from '../../mark/text';
+import type { ISeries } from '../../series/interface';
+import type { IComponentMark } from '../../mark/component';
+import type { ILabelSpec } from './interface';
+export interface ILabelInfo {
+    baseMark: IMark;
+    labelMark: ITextMark;
+    series: ISeries;
+}
+export interface ILabelComponentContext {
+    region: IRegion;
+    labelInfo: ILabelInfo[];
+}
+export declare class Label extends BaseComponent {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    layoutType: LayoutItem['layoutType'];
+    layoutZIndex: LayoutItem['layoutZIndex'];
+    protected _labelInfo: Map<IRegion, ILabelInfo[]>;
+    protected _labelComponentMap: Map<IComponentMark, ILabelComponentContext>;
+    protected _layoutRule: 'series' | 'region';
+    constructor(spec: any, options: IComponentOption);
+    static createComponent(spec: any, options: IComponentOption): Label[];
+    init(option: IModelInitOption): void;
+    initEvent(): void;
+    protected _initTextMark(): void;
+    protected _initLabelComponent(): void;
+    protected _interactiveConfig(labelSpec: ILabelSpec): {
+        hover: boolean;
+        select: boolean;
+        state: {
+            hover?: Partial<import("../..").ITextMarkSpec>;
+            hover_reverse?: Partial<import("../..").ITextMarkSpec>;
+            selected?: Partial<import("../..").ITextMarkSpec>;
+            selected_reverse?: Partial<import("../..").ITextMarkSpec>;
+        };
+    } | {
+        hover: boolean;
+        select: boolean;
+    };
+    setLayoutStartPosition(): void;
+    updateLayoutAttribute(): void;
+    compileMarks(): void;
+    updateSpec(spec: any): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    onRender(ctx: IModelRenderOption): void;
+    changeRegions(regions: IRegion[]): void;
+    clear(): void;
+}

package/build/es5/component/label/symbol.d.ts

@@ -0,0 +1,9 @@
+import type { ILabelInfo } from './label';
+import type { Strategy } from '@visactor/vrender-components';
+export declare function symbolLabel(labelInfo: ILabelInfo): {
+    position: string;
+    overlap: boolean | {
+        strategy: Strategy[];
+        avoidBaseMark: boolean;
+    };
+};

package/build/es5/component/label/util.d.ts

@@ -0,0 +1,9 @@
+import type { Datum } from '../../typings';
+import type { ILabelInfo } from './label';
+import { barLabel } from './bar';
+import { symbolLabel } from './symbol';
+export declare const markLabelConfigFunc: {
+    rect: typeof barLabel;
+    symbol: typeof symbolLabel;
+};
+export declare function textAttribute(labelInfo: ILabelInfo, datum: Datum): any;

package/build/es5/component/legend/base-legend.d.ts

@@ -0,0 +1,59 @@
+import type { DataView } from '@visactor/vdataset';
+import type { IRegion } from '../../region/interface';
+import { BaseComponent } from '../base';
+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';
+import type { ILegend } from './interface';
+import type { IGroup } from '@visactor/vrender';
+export declare abstract class BaseLegend extends BaseComponent 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;
+    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;
+    updateSpec(spec: any): {
+        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;
+    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;
+    };
+    clear(): void;
+}

package/build/es5/component/legend/continuous/index.d.ts

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