@visactor/vchart-types 0.10.0-alpha.2

package/types/component/data-zoom/data-filter-base-component.d.ts

@@ -0,0 +1,129 @@
+import { BaseComponent } from '../base/base-component';
+import type { IEffect, IModelInitOption } from '../../model/interface';
+import type { IComponent, IComponentOption } from '../interface';
+import type { AdaptiveSpec, ILayoutRect, ILayoutType, IOrientType, IRect, StringOrNumber } from '../../typings';
+import type { IBaseScale } from '@visactor/vscale';
+import type { ICartesianBandAxisSpec } from '../axis/cartesian';
+import type { IBoundsLike } from '@visactor/vutils';
+import { IFilterMode } from './constant';
+import type { IDataFilterComponent, IDataFilterComponentSpec, IRoamDragSpec, IRoamScrollSpec, IRoamZoomSpec } from './interface';
+import type { BaseEventParams } from '../../event/interface';
+import type { AbstractComponent } from '@visactor/vrender-components';
+import type { IGraphic } from '@visactor/vrender-core';
+export declare abstract class DataFilterBaseComponent<T extends IDataFilterComponentSpec = IDataFilterComponentSpec> extends BaseComponent<AdaptiveSpec<T, 'width' | 'height'>> implements IDataFilterComponent {
+    layoutType: ILayoutType | 'none';
+    protected _component: AbstractComponent;
+    protected _orient: IOrientType;
+    protected _isHorizontal: boolean;
+    protected _auto?: boolean;
+    protected _fixedBandSize?: number;
+    protected _cacheRect?: ILayoutRect;
+    protected _cacheVisibility?: boolean;
+    protected _stateScale: IBaseScale;
+    protected _relatedAxisComponent: IComponent;
+    protected _originalStateFields: Record<number, string | number>;
+    protected _seriesUserId?: StringOrNumber[];
+    protected _seriesIndex?: number[];
+    protected _regionUserId: string[];
+    protected _regionIndex: number[];
+    protected _newDomain: any[];
+    protected _startValue: number | string;
+    protected _endValue: number | string;
+    protected _start: number;
+    protected _end: number;
+    protected _minSpan: number;
+    protected _maxSpan: number;
+    protected _shouldChange: boolean;
+    protected _field: string | undefined;
+    protected _stateField: string;
+    protected _valueField?: string;
+    protected _width: number;
+    protected _height: number;
+    protected _filterMode: IFilterMode;
+    protected _activeRoam: boolean;
+    protected _zoomAttr: IRoamZoomSpec;
+    protected _dragAttr: IRoamDragSpec;
+    protected _scrollAttr: IRoamScrollSpec;
+    get orient(): IOrientType;
+    get isHorizontal(): boolean;
+    get stateScale(): IBaseScale;
+    get relatedAxisComponent(): IComponent;
+    setStartAndEnd(start: number | string, end: number | string, rangeMode?: ['percent' | 'value', 'percent' | 'value']): void;
+    enableInteraction(): void;
+    disableInteraction(): void;
+    zoomIn(location?: {
+        x: number;
+        y: number;
+    }): void;
+    zoomOut(location?: {
+        x: number;
+        y: number;
+    }): void;
+    protected abstract _getComponentAttrs(): any;
+    protected abstract _createOrUpdateComponent(): void;
+    protected abstract _computeWidth(): number;
+    protected abstract _computeHeight(): number;
+    protected abstract _handleDataCollectionChange(): void;
+    protected _handleChange(start: number, end: number, updateComponent?: boolean): void;
+    protected _isReverse(): boolean;
+    protected _updateRangeFactor(tag?: string, label?: string): void;
+    effect: IEffect;
+    protected _visible: boolean;
+    get visible(): boolean;
+    constructor(spec: T, options: IComponentOption);
+    created(): void;
+    initLayout(): void;
+    protected _setAxisFromSpec(): void;
+    protected _setRegionsFromSpec(): void;
+    onDataUpdate(): void;
+    protected _computeDomainOfStateScale(isContinuous?: boolean): any;
+    protected _initEvent(): void;
+    protected _initData(): void;
+    setAttrFromSpec(): void;
+    protected _statePointToData(state: number): any;
+    protected _dataToStatePoint(data: number | string): number;
+    protected _modeCheck(statePoint: 'start' | 'end', mode: string): any;
+    protected _setStateFromSpec(): void;
+    private _parseFieldOfSeries;
+    protected _initStateScale(): void;
+    init(option: IModelInitOption): void;
+    protected _addTransformToSeries(): void;
+    onRender(ctx: any): void;
+    _compareSpec(spec: AdaptiveSpec<T, 'width' | 'height'>, prevSpec: AdaptiveSpec<T, 'width' | 'height'>): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    reInit(spec?: AdaptiveSpec<T, 'width' | 'height'>): void;
+    changeRegions(): void;
+    protected update(ctx: IComponentOption): void;
+    protected resize(ctx: IComponentOption): void;
+    protected _parseDomainFromState(startValue: number | string, endValue: number | string): any;
+    protected _handleStateChange: (startValue: number, endValue: number, tag?: string) => boolean;
+    protected _handleChartZoom: (params: {
+        zoomDelta: number;
+        zoomX?: number;
+        zoomY?: number;
+    }) => void;
+    protected _handleChartScroll: (params: {
+        scrollX: number;
+        scrollY: number;
+    }, e: BaseEventParams['event']) => boolean;
+    protected _handleChartDrag: (delta: [number, number], e: BaseEventParams['event']) => void;
+    protected _handleChartMove: (value: number, rate: number) => void;
+    protected _initCommonEvent(): void;
+    updateLayoutAttribute(): void;
+    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect, ctx: any): void;
+    getBoundsInRect(rect: ILayoutRect): IBoundsLike;
+    hide(): void;
+    show(): void;
+    protected _getAxisBandSize(axisSpec?: ICartesianBandAxisSpec): {
+        bandSize: number;
+        maxBandSize: number;
+        minBandSize: number;
+    };
+    protected _autoUpdate(rect?: ILayoutRect): boolean;
+    protected _getNeedClearVRenderComponents(): IGraphic[];
+}

package/types/component/data-zoom/data-zoom/data-zoom-transformer.d.ts

@@ -0,0 +1,9 @@
+import type { AdaptiveSpec } from '../../../typings';
+import { BaseComponentSpecTransformer } from '../../base';
+import type { IDataZoomSpec, IDataZoomTheme } from './interface';
+export declare class DataZoomSpecTransformer<T extends IDataZoomSpec = IDataZoomSpec, K extends IDataZoomTheme = IDataZoomTheme> extends BaseComponentSpecTransformer<AdaptiveSpec<T, 'width' | 'height'>, K> {
+    protected _mergeThemeToSpec(spec: AdaptiveSpec<T, 'width' | 'height'>, chartSpec: any): {
+        spec: AdaptiveSpec<T, 'width' | 'height'>;
+        theme: K;
+    };
+}

package/types/component/data-zoom/data-zoom/data-zoom.d.ts

@@ -0,0 +1,78 @@
+import type { Maybe } from '@visactor/vutils';
+import type { IComponentOption } from '../../interface';
+import { ComponentTypeEnum } from '../../interface/type';
+import { DataFilterBaseComponent } from '../data-filter-base-component';
+import { DataZoom as DataZoomComponent } from '@visactor/vrender-components';
+import type { IRectGraphicAttribute, ISymbolGraphicAttribute, IGraphic } from '@visactor/vrender-core';
+import type { Datum, ILayoutType } from '../../../typings';
+import type { ILinearScale, IBaseScale } from '@visactor/vscale';
+import type { IDataZoomSpec } from './interface';
+import type { IModelSpecInfo } from '../../../model/interface';
+import { DataZoomSpecTransformer } from './data-zoom-transformer';
+export declare class DataZoom<T extends IDataZoomSpec = IDataZoomSpec> extends DataFilterBaseComponent<T> {
+    static type: ComponentTypeEnum;
+    static readonly transformerConstructor: any;
+    type: ComponentTypeEnum;
+    name: string;
+    readonly transformerConstructor: typeof DataZoomSpecTransformer;
+    static specKey: string;
+    specKey: string;
+    layoutZIndex: number;
+    layoutLevel: number;
+    layoutType: ILayoutType;
+    protected _component: DataZoomComponent;
+    protected _valueScale: ILinearScale;
+    protected _backgroundSize: number;
+    protected _middleHandlerSize: number;
+    protected _startHandlerSize: number;
+    protected _endHandlerSize: number;
+    static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
+    constructor(spec: T, options: IComponentOption);
+    created(): void;
+    setAttrFromSpec(): void;
+    onLayoutEnd(ctx: any): void;
+    protected _initValueScale(): void;
+    protected _updateScaleRange(): void;
+    protected _computeDomainOfValueScale(): unknown[];
+    protected _computeMiddleHandlerSize(): number;
+    protected _computeWidth(): number;
+    protected _computeHeight(): number;
+    protected _isScaleValid(scale: IBaseScale | ILinearScale): boolean;
+    protected _dataToPositionX: (datum: Datum) => number;
+    protected _dataToPositionX2: (datum: Datum) => number;
+    protected _dataToPositionY: (datum: Datum) => number;
+    protected _dataToPositionY2: (datum: Datum) => number;
+    private _getAttrs;
+    protected _createOrUpdateComponent(): void;
+    protected _handleChange(start: number, end: number, updateComponent?: boolean, tag?: string): void;
+    protected _handleDataCollectionChange(): void;
+    protected _getComponentAttrs(): {
+        backgroundStyle: IRectGraphicAttribute;
+        startHandlerStyle: ISymbolGraphicAttribute;
+        middleHandlerStyle: {
+            visible: boolean;
+            icon: ISymbolGraphicAttribute;
+            background: any;
+        } | {
+            visible: boolean;
+            icon?: undefined;
+            background?: undefined;
+        };
+        endHandlerStyle: ISymbolGraphicAttribute;
+        startTextStyle: unknown;
+        endTextStyle: unknown;
+        selectedBackgroundStyle: IRectGraphicAttribute;
+        dragMaskStyle: IRectGraphicAttribute;
+        backgroundChartStyle: {
+            line: any;
+            area: any;
+        };
+        selectedBackgroundChartStyle: {
+            line: any;
+            area: any;
+        };
+        disableTriggerEvent: boolean;
+    };
+    protected _getNeedClearVRenderComponents(): IGraphic[];
+}
+export declare const registerDataZoom: () => void;

package/types/component/data-zoom/data-zoom/index.d.ts

@@ -0,0 +1,3 @@
+export * from './data-zoom';
+export * from './interface';
+export * from './data-zoom-transformer';

package/types/component/data-zoom/data-zoom/interface.d.ts

@@ -0,0 +1,67 @@
+import type { IMarkSpec } from '../../../typings/spec';
+import type { IAreaMarkSpec, ILineMarkSpec, IRectMarkSpec, ISymbolMarkSpec, ITextMarkSpec } from '../../../typings/visual';
+import type { IComponentSpec } from '../../base/interface';
+import type { IComponent } from '../../interface';
+import type { IFilterMode } from '../constant';
+import type { IDataFilterComponent, IDataFilterComponentSpec } from '../interface';
+export type IDataZoom = IComponent & IDataFilterComponent;
+export interface IDataZoomStyle {
+    showDetail?: 'auto' | boolean;
+    middleHandler?: {
+        visible?: boolean;
+        icon?: ISymbolMarkSpec;
+        background?: {
+            size?: number;
+        } & IRectMarkSpec;
+    };
+    background?: {
+        size?: number;
+    } & IRectMarkSpec;
+    startHandler?: ISymbolMarkSpec;
+    endHandler?: ISymbolMarkSpec;
+    startText?: {
+        padding?: number;
+    } & ITextMarkSpec;
+    endText?: {
+        padding?: number;
+    } & ITextMarkSpec;
+    dragMask?: IRectMarkSpec;
+    selectedBackground?: IRectMarkSpec;
+    backgroundChart?: {
+        line?: ILineMarkSpec;
+        area?: IAreaMarkSpec;
+    };
+    selectedBackgroundChart?: {
+        line?: ILineMarkSpec;
+        area?: IAreaMarkSpec;
+    };
+}
+export interface IDataZoomSpec extends IDataZoomStyle, IDataFilterComponentSpec {
+    filterMode?: IFilterMode;
+    valueField?: string;
+    startText?: {
+        padding?: number;
+        style?: IMarkSpec<ITextMarkSpec>;
+        formatMethod?: (text: string | number) => string | string[];
+    };
+    endText?: {
+        padding?: number;
+        style?: IMarkSpec<ITextMarkSpec>;
+        formatMethod?: (text: string | number) => string | string[];
+    };
+    brushSelect?: boolean;
+    ignoreBandSize?: boolean;
+    customDomain?: any[];
+    updateDataAfterChange?: (start: number, end: number, startValue: any, endValue: any) => void;
+    tolerance?: number;
+}
+export type IDataZoomCommonTheme = IComponentSpec & IDataZoomStyle & {
+    orient?: IDataZoomSpec['orient'];
+    width?: IDataZoomSpec['width'];
+    height?: IDataZoomSpec['height'];
+    brushSelect?: boolean;
+};
+export type IDataZoomTheme = IDataZoomCommonTheme & {
+    horizontal?: Omit<IDataZoomCommonTheme, 'orient'>;
+    vertical?: Omit<IDataZoomCommonTheme, 'orient'>;
+};

package/types/component/data-zoom/index.d.ts

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

package/types/component/data-zoom/interface.d.ts

@@ -0,0 +1,59 @@
+import type { IOrientType } from '../../typings';
+import type { IDelayType } from '../../typings/event';
+import type { IComponentSpec } from '../base/interface';
+import type { IComponent } from '../interface';
+export interface IDataFilterComponentSpec extends Omit<IComponentSpec, 'width' | 'height'> {
+    visible?: boolean;
+    orient?: IOrientType;
+    width?: 'auto' | number;
+    height?: 'auto' | number;
+    field?: string;
+    axisId?: string;
+    axisIndex?: number;
+    regionIndex?: number | number[];
+    start?: number;
+    end?: number;
+    startValue?: number | string;
+    endValue?: number | string;
+    valueField?: string;
+    rangeMode?: [string, string];
+    autoIndent?: boolean;
+    auto?: boolean;
+    zoomLock?: boolean;
+    minSpan?: number;
+    maxSpan?: number;
+    minValueSpan?: number;
+    maxValueSpan?: number;
+    delayType?: IDelayType;
+    delayTime?: number;
+    roamZoom?: IRoamZoomSpec | boolean;
+    roamDrag?: IRoamDragSpec | boolean;
+    roamScroll?: IRoamScrollSpec | boolean;
+    realTime?: boolean;
+}
+export interface IRoamDragSpec extends IRoamSpec {
+    reverse?: boolean;
+}
+export interface IRoamScrollSpec extends IRoamSpec {
+    reverse?: boolean;
+}
+export interface IRoamZoomSpec extends IRoamSpec {
+    focus?: boolean;
+}
+export interface IRoamSpec {
+    enable?: boolean;
+    rate?: number;
+}
+export interface IDataFilterComponent extends IComponent {
+    setStartAndEnd: (start: number | string, end: number | string, rangeMode: ['percent' | 'value', 'percent' | 'value']) => void;
+    enableInteraction: () => void;
+    disableInteraction: () => void;
+    zoomIn: (location?: {
+        x: number;
+        y: number;
+    }) => void;
+    zoomOut: (location?: {
+        x: number;
+        y: number;
+    }) => void;
+}

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

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

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

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

package/types/component/data-zoom/scroll-bar/scroll-bar.d.ts

@@ -0,0 +1,36 @@
+import type { Maybe } from '@visactor/vutils';
+import type { IComponentOption } from '../../interface';
+import { ComponentTypeEnum } from '../../interface/type';
+import { DataFilterBaseComponent } from '../data-filter-base-component';
+import type { ScrollBarAttributes } from '@visactor/vrender-components';
+import { ScrollBar as ScrollBarComponent } from '@visactor/vrender-components';
+import type { IGraphic } from '@visactor/vrender-core';
+import type { IScrollBarSpec } from './interface';
+import type { ILayoutType } from '../../../typings/layout';
+import type { IModelSpecInfo } from '../../../model/interface';
+export declare class ScrollBar<T extends IScrollBarSpec = IScrollBarSpec> extends DataFilterBaseComponent<T> {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    static specKey: string;
+    specKey: string;
+    layoutZIndex: number;
+    layoutLevel: number;
+    layoutType: ILayoutType;
+    protected _component: ScrollBarComponent;
+    static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
+    constructor(spec: T, options: IComponentOption);
+    setAttrFromSpec(): void;
+    onLayoutEnd(ctx: any): void;
+    protected _updateScaleRange(): void;
+    protected _computeWidth(): number;
+    protected _computeHeight(): number;
+    private _getAttrs;
+    protected _createOrUpdateComponent(): void;
+    protected _handleChange(start: number, end: number, updateComponent?: boolean): void;
+    protected _handleDataCollectionChange(): void;
+    protected _initCommonEvent(): void;
+    protected _getComponentAttrs(): Partial<ScrollBarAttributes>;
+    protected _getNeedClearVRenderComponents(): IGraphic[];
+}
+export declare const registerScrollBar: () => void;

package/types/component/data-zoom/util.d.ts

@@ -0,0 +1,23 @@
+import type { IOrientType } from '../../typings';
+import type { ComponentTypeEnum } from '../interface';
+import type { ITheme } from '../../theme';
+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[];
+export declare const getDataFilterTheme: (orient: IOrientType, type: ComponentTypeEnum, chartTheme: ITheme) => any;

package/types/component/geo/geo-coordinate.d.ts

@@ -0,0 +1,61 @@
+import type { IPoint } from '../../typings/coordinate';
+import { Projection } from './projection';
+import type { IEffect, IModelLayoutOption, IModelRenderOption, IModelSpecInfo } from '../../model/interface';
+import { ComponentTypeEnum } from '../interface/type';
+import { BaseComponent } from '../base/base-component';
+import type { IGeoRegionSpec, IRegion } from '../../region/interface';
+import type { IGeoCoordinate, IGeoCoordinateSpec, IProjectionSpec } from './interface';
+import type { StringOrNumber } from '../../typings';
+import type { Maybe } from '@visactor/vutils';
+import type { IGraphic } from '@visactor/vrender-core';
+export declare function projectionName(key: string, id: number): string;
+export declare class GeoCoordinate extends BaseComponent<IGeoRegionSpec> implements IGeoCoordinate {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    layoutType: 'none';
+    protected layoutZIndex: number;
+    _longitudeField?: string;
+    get longitudeField(): string;
+    _latitudeField?: string;
+    get latitudeField(): string;
+    protected _projectionSpec: IProjectionSpec;
+    get projectionSpec(): IProjectionSpec;
+    setProjection(projectionSpec: IGeoCoordinateSpec['projection']): void;
+    protected _projection: Projection;
+    protected _centerCache: Map<StringOrNumber, {
+        x: number;
+        y: number;
+    }>;
+    private _actualScale;
+    getZoom(): number;
+    private _initialScale;
+    static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
+    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 _getNeedClearVRenderComponents(): IGraphic[];
+    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;
+    invert(point: [number, number]): any;
+    private evaluateProjection;
+    protected _initCenterCache(): void;
+    release(): void;
+}
+export declare const registerGeoCoordinate: () => void;

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

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

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

@@ -0,0 +1,27 @@
+import type { IPoint } from '../../typings/coordinate';
+import type { ProjectionType } from '@visactor/vgrammar-core';
+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/types/component/geo/projection.d.ts

@@ -0,0 +1,17 @@
+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;
+    invert(point: [number, number]): 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/types/component/index.d.ts

@@ -0,0 +1,47 @@
+import type { IComponent } from './interface/common';
+import type { IScrollBarSpec, IScrollBarTheme } from './data-zoom/scroll-bar';
+import { ScrollBar, registerScrollBar } from './data-zoom/scroll-bar/scroll-bar';
+import type { IDataZoomSpec, IDataZoomTheme } from './data-zoom/data-zoom';
+import { DataZoom, registerDataZoom } from './data-zoom/data-zoom/data-zoom';
+import { CustomMark, registerCustomMark } from './custom-mark/custom-mark';
+import type { IBrushSpec, IBrushTheme } from './brush';
+import { Brush, registerBrush } from './brush/brush';
+import type { IMapLabelSpec, IMapLabelTheme } from './map-label';
+import { MapLabelComponent, registerMapLabel } from './map-label/component';
+import type { ICartesianLinearAxisSpec, ICartesianBandAxisSpec, ICartesianTimeAxisSpec, ICartesianAxisSpec, ICartesianLogAxisSpec, ICartesianAxisCommonTheme } from './axis/cartesian/index';
+import { CartesianAxis, CartesianLinearAxis, CartesianBandAxis, CartesianTimeAxis, CartesianLogAxis, CartesianSymlogAxis, registerCartesianBandAxis, registerCartesianLinearAxis, registerCartesianLogAxis, registerCartesianSymlogAxis, registerCartesianTimeAxis } from './axis/cartesian/index';
+import type { IPolarAxisCommonTheme, IPolarAxisSpec, IPolarBandAxisSpec, IPolarLinearAxisSpec } from './axis/polar';
+import { PolarAxis, PolarBandAxis, PolarLinearAxis, registerPolarBandAxis, registerPolarLinearAxis } from './axis/polar';
+import type { IDiscreteLegendSpec, IDiscreteLegendTheme } from './legend/discrete';
+import { DiscreteLegend, registerDiscreteLegend } from './legend/discrete';
+import type { IColorLegendTheme, IContinuousLegendSpec, IContinuousLegendTheme, ISizeLegendTheme } from './legend/continuous';
+import { ContinuousLegend, registerContinuousLegend } from './legend/continuous';
+import type { IIndicatorSpec, IIndicatorTheme } from './indicator';
+import { Indicator, registerIndicator } from './indicator';
+import type { ITitleSpec, ITitleTheme } from './title';
+import { Title, registerTitle } from './title';
+import type { IGeoCoordinateSpec } from './geo';
+import { GeoCoordinate, registerGeoCoordinate } from './geo';
+import type { ICartesianCrosshairSpec, ICrosshairTheme, IPolarCrosshairSpec } from './crosshair';
+import { CartesianCrossHair, PolarCrossHair, registerCartesianCrossHair, registerPolarCrossHair } from './crosshair';
+import type { IPlayerSpec, IPlayerTheme } from './player';
+import { Player, registerPlayer } from './player';
+import type { IMarkLineSpec, IStepMarkLineSpec, IMarkLineTheme } from './marker/mark-line';
+import { MarkLine, registerMarkLine } from './marker/mark-line';
+import type { IMarkAreaSpec, IMarkAreaTheme } from './marker/mark-area';
+import { MarkArea, registerMarkArea } from './marker/mark-area';
+import type { IMarkPointSpec, IMarkPointTheme } from './marker/mark-point';
+import { MarkPoint, registerMarkPoint } from './marker/mark-point';
+import type { ITooltipSpec, ITooltipTheme } from './tooltip';
+import { Tooltip, registerTooltip } from './tooltip';
+import type { ILabelSpec, ITotalLabelTheme } from './label';
+import { Label, registerLabel } from './label';
+import { TotalLabel, registerTotalLabel } from './label/total-label';
+import { registerPoptip } from './poptip/index';
+import type { IComponentTheme } from './interface';
+import type { IAxisCommonTheme, IAxisItemTheme, IBandAxisTheme } from './axis/interface';
+import type { IPoptipTheme } from './poptip/interface';
+export { ScrollBar, DataZoom, CustomMark, Brush, MapLabelComponent, CartesianAxis, CartesianBandAxis, CartesianLinearAxis, CartesianTimeAxis, CartesianLogAxis, CartesianSymlogAxis, PolarAxis, PolarBandAxis, PolarLinearAxis, DiscreteLegend, ContinuousLegend, Indicator, Title, GeoCoordinate, CartesianCrossHair, PolarCrossHair, Player, MarkArea, MarkLine, MarkPoint, Tooltip, Label, TotalLabel };
+export { registerBrush, registerScrollBar, registerTitle, registerTooltip, registerCartesianBandAxis, registerCartesianCrossHair, registerCartesianLinearAxis, registerCartesianLogAxis, registerCartesianSymlogAxis, registerCartesianTimeAxis, registerContinuousLegend, registerCustomMark, registerDataZoom, registerDiscreteLegend, registerGeoCoordinate, registerIndicator, registerLabel, registerTotalLabel, registerMapLabel, registerMarkArea, registerMarkLine, registerMarkPoint, registerPlayer, registerPolarBandAxis, registerPolarCrossHair, registerPolarLinearAxis, registerPoptip };
+export type { IComponent, IScrollBarSpec, IBrushSpec, ICartesianAxisSpec, ICartesianBandAxisSpec, ICartesianCrosshairSpec, ICartesianLinearAxisSpec, ICartesianTimeAxisSpec, ICartesianLogAxisSpec, IContinuousLegendSpec, IDataZoomSpec, IDiscreteLegendSpec, IGeoCoordinateSpec, IIndicatorSpec, ILabelSpec, IMapLabelSpec, IMarkAreaSpec, IMarkLineSpec, IStepMarkLineSpec, IMarkPointSpec, IPlayerSpec, IPolarAxisSpec, IPolarBandAxisSpec, IPolarCrosshairSpec, IPolarLinearAxisSpec, ITitleSpec, ITooltipSpec };
+export type { IComponentTheme, ICrosshairTheme, IAxisItemTheme, IAxisCommonTheme, IBandAxisTheme, IPolarAxisCommonTheme, ICartesianAxisCommonTheme, IBrushTheme, IDataZoomTheme, IScrollBarTheme, IIndicatorTheme, IMapLabelTheme, ITotalLabelTheme, ISizeLegendTheme, IColorLegendTheme, IDiscreteLegendTheme, IContinuousLegendTheme, IMarkAreaTheme, IMarkLineTheme, IMarkPointTheme, IPlayerTheme, IPoptipTheme, ITitleTheme, ITooltipTheme };

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

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

package/types/component/indicator/indicator.d.ts

@@ -0,0 +1,43 @@
+import { ComponentTypeEnum } from '../interface/type';
+import { BaseComponent } from '../base/base-component';
+import type { IRegion } from '../../region/interface';
+import type { IIndicator, IIndicatorSpec } from './interface';
+import type { Maybe } from '../../typings';
+import type { IModelSpecInfo } from '../../model/interface';
+import { Indicator as IndicatorComponents } from '@visactor/vrender-components';
+import type { IGraphic } from '@visactor/vrender-core';
+export declare class Indicator<T extends IIndicatorSpec> extends BaseComponent<T> implements IIndicator {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    static specKey: string;
+    specKey: string;
+    layoutType: 'none';
+    layoutZIndex: number;
+    layoutLevel: number;
+    private _gap;
+    private _activeDatum;
+    private _displayData;
+    private _title;
+    private _content;
+    private _indicatorComponent;
+    private _cacheAttrs;
+    static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
+    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 _computeLayoutRadius;
+    private isRelativeModel;
+    protected _getNeedClearVRenderComponents(): IGraphic[];
+    clear(): void;
+    getIndicatorComponent(): IndicatorComponents;
+}
+export declare const registerIndicator: () => void;