@visactor/vchart-types 1.8.10-alpha.0 → 1.9.0-alpha.1

package/types/component/crosshair/base.d.ts

@@ -39,7 +39,10 @@ export declare abstract class BaseCrossHair<T extends ICartesianCrosshairSpec |
     trigger: CrossHairTrigger;
     enable: boolean;
     showDefault: boolean;
-    triggerOff: CrossHairTrigger | 'none';
+    triggerOff: 'none' | number;
+    private _timer?;
+    private _clickLock?;
+    private _hasActive?;
     get enableRemain(): boolean;
     private _limitBounds;
     constructor(spec: T, options: IComponentOption);
@@ -62,7 +65,10 @@ export declare abstract class BaseCrossHair<T extends ICartesianCrosshairSpec |
     private _registerEvent;
     private _eventOff;
     updateLayoutAttribute(): void;
-    private _handleEvent;
+    private _handleIn;
+    private _handleClickInEvent;
+    private _handleHoverInEvent;
+    private _handleOutEvent;
     private _getTriggerEvent;
     protected _getAxisInfoByField<T = IAxis>(field: 'x' | 'y' | 'category' | 'value'): IAxisInfo<T>;
     changeRegions(regions: IRegion[]): void;
@@ -73,4 +79,6 @@ export declare abstract class BaseCrossHair<T extends ICartesianCrosshairSpec |
     protected _parseCrosshairSpec(): void;
     protected _parseField(field: ICrosshairCategoryFieldSpec, fieldName: string): any;
     protected _filterAxisByPoint<T>(axisMap: IAxisInfo<T>, relativeX: number, relativeY: number): IAxisInfo<T>;
+    protected clearEvent(): void;
+    clear(): void;
 }

package/types/component/crosshair/cartesian.d.ts

@@ -2,6 +2,7 @@ import type { Maybe } from '@visactor/vutils';
 import type { IComponentOption } from '../interface';
 import { ComponentTypeEnum } from '../interface/type';
 import type { ICartesianCrosshairSpec } from './interface';
+import type { IBound } from './base';
 import { BaseCrossHair } from './base';
 import type { IGraphic } from '@visactor/vrender-core';
 import type { IAxis } from '../axis/interface';
@@ -35,6 +36,10 @@ export declare class CartesianCrossHair<T extends ICartesianCrosshairSpec = ICar
     private _getAllAxisValues;
     protected _layoutCrosshair(relativeX: number, relativeY: number): void;
     hide(): void;
+    _setRegionArea(outRegion: IBound, currentValue: Map<number, {
+        v: StringOrNumber;
+        axis: IAxis;
+    }>): void;
     layoutByValue(tag?: number): void;
     private _layoutVertical;
     private _layoutHorizontal;

package/types/component/crosshair/config.d.ts

@@ -13,6 +13,5 @@ export declare function getDefaultCrosshairTriggerEventByMode(mode: RenderMode):
 export declare enum LayoutType {
     ALL = 3,
     HORIZONTAL = 2,
-    VERTICAL = 1,
-    NONE = 0
+    VERTICAL = 1
 }

package/types/component/crosshair/interface/spec.d.ts

@@ -11,7 +11,8 @@ export interface ICrossHair extends IComponent {
 export type CrossHairTrigger = 'click' | 'hover' | ['click', 'hover'];
 export interface ICommonCrosshairSpec extends IComponentSpec {
     trigger?: CrossHairTrigger;
-    triggerOff?: CrossHairTrigger | 'none';
+    triggerOff?: CrossHairTrigger | 'none' | number;
+    lockAfterClick?: boolean;
     labelZIndex?: number;
     gridZIndex?: number;
 }

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

@@ -4,6 +4,7 @@ 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;
@@ -37,5 +38,6 @@ export declare class Indicator<T extends IIndicatorSpec> extends BaseComponent<T
     private isRelativeModel;
     protected _getNeedClearVRenderComponents(): IGraphic[];
     clear(): void;
+    getIndicatorComponent(): IndicatorComponents;
 }
 export declare const registerIndicator: () => void;

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

@@ -10,6 +10,7 @@ export interface IIndicatorItemSpec {
     autoLimit?: boolean;
     autoFit?: boolean;
     fitPercent?: number;
+    fitStrategy?: 'default' | 'inscribed';
     style?: Omit<ConvertToMarkStyleSpec<ITextMarkSpec>, 'visible' | 'text'> & {
         type?: 'text' | 'rich' | 'html';
         text?: string | string[] | number | number[] | IRichTextCharacter[];

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

@@ -19,6 +19,7 @@ export interface IComponentOption extends IModelOption {
     getComponentByIndex: (key: string, index: number) => IComponent | undefined;
     getComponentByUserId: (userId: StringOrNumber) => IComponent | undefined;
     getComponentsByKey: (key: string) => IComponent[];
+    getComponentsByType: (type: string) => IComponent[];
 }
 export interface IComponent extends ILayoutModel {
     readonly name: string;

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

@@ -21,9 +21,6 @@ export declare abstract class BaseLabelComponent<T = any> extends BaseComponent<
             selected?: Partial<import("../..").ITextMarkSpec>;
             selected_reverse?: Partial<import("../..").ITextMarkSpec>;
         };
-    } | {
-        hover: boolean;
-        select: boolean;
     };
     _compareSpec(spec: T, prevSpec: T): {
         change: boolean;

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

@@ -26,6 +26,7 @@ export interface ILabelSpec extends IComponentSpec {
     labelLayout?: 'series' | 'region';
     centerOffset?: number;
     support3d?: boolean;
+    syncState?: boolean;
 }
 type LabelStateStyle<T> = {
     hover?: T;

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

@@ -17,7 +17,7 @@ export declare abstract class BaseLegend<T extends ILegendCommonSpec> extends Ba
     protected _visible: boolean;
     get visible(): boolean;
     protected _position: 'start' | 'middle' | 'end';
-    get position(): "middle" | "start" | "end";
+    get position(): "start" | "end" | "middle";
     protected _legendData: CompilableData;
     getLegendData(): any;
     private _preSelectedData;

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

@@ -21,6 +21,6 @@ export declare function transformLegendTitleAttributes(title: ITitle): {
     maxWidth?: number;
     minWidth?: number;
     space?: number;
-    align?: "center" | "start" | "end";
+    align?: "start" | "end" | "center";
 };
 export declare function getLayout(spec: ILegendCommonSpec): "vertical" | "horizontal";

package/types/core/factory.d.ts

@@ -8,6 +8,7 @@ import type { Transform, Parser } from '@visactor/vdataset';
 import type { ILayoutConstructor } from '../layout/interface';
 import type { MarkAnimationSpec } from '@visactor/vgrammar-core';
 import type { IChartPluginConstructor } from '../plugin/chart/interface';
+import type { IComponentPluginConstructor } from '../plugin/components/interface';
 export declare class Factory {
     private static _charts;
     private static _series;
@@ -17,6 +18,7 @@ export declare class Factory {
     private static _animations;
     private static _implements;
     private static _chartPlugin;
+    private static _componentPlugin;
     static transforms: {
         [key: string]: Transform;
     };
@@ -36,6 +38,7 @@ export declare class Factory {
     static registerAnimation(key: string, animation: (params?: any, preset?: any) => MarkAnimationSpec): void;
     static registerImplement(key: string, implement: (...args: any) => void): void;
     static registerChartPlugin(key: string, plugin: IChartPluginConstructor): void;
+    static registerComponentPlugin(key: string, plugin: IComponentPluginConstructor): void;
     static createChart(chartType: string, spec: any, options: IChartOption): IChart | null;
     static createChartSpecTransformer(chartType: string, option: IChartSpecTransformerOption): IChartSpecTransformer | null;
     static createRegion(regionType: string, spec: any, options: IModelOption): IRegion | null;
@@ -57,4 +60,6 @@ export declare class Factory {
     static getImplementInKey(key: string): (...args: any) => void;
     static getSeriesMarkMap(seriesType: string): Partial<Record<SeriesMarkNameEnum, ISeriesMarkInfo>>;
     static getChartPlugins(): IChartPluginConstructor[];
+    static getComponentPlugins(): IComponentPluginConstructor[];
+    static getComponentPluginInType(type: string): IComponentPluginConstructor;
 }

package/types/core/vchart.d.ts

@@ -6,8 +6,8 @@ import type { DimensionIndexOption, IChart, IChartConstructor, IChartSpecInfo }
 import type { IComponentConstructor } from '../component/interface';
 import type { EventCallback, EventParams, EventQuery, EventType } from '../event/interface';
 import type { IParserOptions } from '@visactor/vdataset/es/parser';
-import type { Transform } from '@visactor/vdataset';
-import { DataSet, DataView } from '@visactor/vdataset';
+import type { Transform, DataView } from '@visactor/vdataset';
+import { DataSet } from '@visactor/vdataset';
 import type { Stage } from '@visactor/vrender-core';
 import type { GeoSourceType } from '../typings/geo';
 import type { GeoSourceOption } from '../series/map/geo-source';
@@ -102,12 +102,13 @@ export declare class VChart implements IVChart {
     private _updateAnimateState;
     release(): void;
     updateData(id: StringOrNumber, data: DataView | Datum[] | string, options?: IParserOptions): Promise<IVChart>;
+    private _updateDataById;
     updateDataInBatches(list: {
         id: string;
         data: Datum[];
         options?: IParserOptions;
     }[]): Promise<IVChart>;
-    updateDataSync(id: StringOrNumber, data: DataView | Datum[], options?: IParserOptions): IVChart;
+    updateDataSync(id: StringOrNumber, data: DataView | Datum[] | string, options?: IParserOptions): IVChart;
     updateFullDataSync(data: IDataValues | IDataValues[], reRender?: boolean): IVChart;
     updateFullData(data: IDataValues | IDataValues[], reRender?: boolean): Promise<IVChart>;
     updateSpec(spec: ISpec, forceMerge?: boolean, morphConfig?: IMorphConfig): Promise<IVChart>;
@@ -124,6 +125,9 @@ export declare class VChart implements IVChart {
     } | ((model: IModel) => boolean), spec: unknown, forceMerge?: boolean, morphConfig?: IMorphConfig): IVChart;
     protected _updateModelSpec(model: IModel, spec: unknown, sync?: boolean, forceMerge?: boolean, morphConfig?: IMorphConfig): IVChart | Promise<IVChart>;
     resize(width: number, height: number): Promise<IVChart>;
+    resizeSync(width: number, height: number): IVChart;
+    protected _beforeResize(width: number, height: number): boolean;
+    protected _afterResize(): IVChart;
     updateViewBox(viewBox: IBoundsLike, reRender?: boolean, reLayout?: boolean): IVChart;
     on(eType: EventType, handler: EventCallback<EventParams>): void;
     on(eType: EventType, query: EventQuery, handler: EventCallback<EventParams>): void;

package/types/event/events/dimension/util/cartesian.d.ts

@@ -3,6 +3,6 @@ import type { IDimensionInfo } from '../interface';
 import type { CartesianAxis } from '../../../../component/axis/cartesian';
 import type { ICartesianSeries } from '../../../../series/interface';
 import type { ILayoutPoint } from '../../../../typings/layout';
-export declare const getCartesianDimensionInfo: (chart: IChart | undefined, pos: ILayoutPoint) => IDimensionInfo[] | null;
+export declare const getCartesianDimensionInfo: (chart: IChart | undefined, pos: ILayoutPoint, isTooltip?: boolean) => IDimensionInfo[] | null;
 export declare const getDimensionInfoByPosition: (axis: CartesianAxis, posValue: number, posKey: 'x' | 'y', getDimensionField: (series: ICartesianSeries) => string | string[]) => IDimensionInfo | null;
 export declare const getDimensionInfoByValue: (axis: CartesianAxis, value: any, getDimensionField?: (series: ICartesianSeries) => string | string[]) => IDimensionInfo | null;

package/types/interaction/interface.d.ts

@@ -1,9 +1,10 @@
-import type { IElement } from '@visactor/vgrammar-core';
+import type { ElementActiveByLegendSpec, ElementActiveSpec, ElementHighlightByGroupSpec, ElementHighlightByKeySpec, ElementHighlightByLegendSpec, ElementHighlightByNameSpec, ElementHighlightSpec, ElementSelectSpec, IElement } from '@visactor/vgrammar-core';
 import type { IMark } from '../mark/interface';
 import type { RenderMode } from '../typings/spec/common';
 import type { BaseEventParams, IEventDispatcher, EventType } from '../event/interface';
 import type { IModel } from '../model/interface';
 import type { StateValue } from '../compile/mark';
+import type { StringOrNumber } from '../typings/common';
 export interface IInteraction {
     registerMark: (state: StateValue, mark: IMark) => void;
     filterEventMark: (params: BaseEventParams, state: StateValue) => boolean;
@@ -41,10 +42,31 @@ export type ISelectSpec = {
     enable?: boolean;
     mode?: 'single' | 'multiple';
     trigger?: Trigger;
-    triggerOff?: Trigger;
+    triggerOff?: Trigger | number;
 };
 export interface ITriggerSpec {
     hover?: IHoverSpec | boolean;
     select?: ISelectSpec | boolean;
 }
+interface IBaseInteractionSpec {
+    markIds?: StringOrNumber[];
+    markNames?: StringOrNumber[];
+}
+export type IElementActiveSpec = IBaseInteractionSpec & Pick<ElementActiveSpec, 'type' | 'trigger' | 'triggerOff' | 'state'>;
+export type IElementSelectSpec = IBaseInteractionSpec & Pick<ElementSelectSpec, 'type' | 'trigger' | 'triggerOff' | 'state' | 'isMultiple' | 'reverseState'>;
+export type IElementHighlightSpec = IBaseInteractionSpec & Pick<ElementHighlightSpec, 'type' | 'blurState' | 'highlightState' | 'triggerOff' | 'trigger'>;
+export type IElementHighlightByKeySpec = IBaseInteractionSpec & Pick<ElementHighlightByKeySpec, 'type' | 'blurState' | 'highlightState' | 'triggerOff' | 'trigger'>;
+export type IElementHighlightByGroup = IBaseInteractionSpec & Pick<ElementHighlightByGroupSpec, 'type' | 'blurState' | 'highlightState' | 'triggerOff' | 'trigger'>;
+export type IElementActiveByLegend = IBaseInteractionSpec & Pick<ElementActiveByLegendSpec, 'type' | 'filterType' | 'state'>;
+export type IElementHighlightByLegend = IBaseInteractionSpec & Pick<ElementHighlightByLegendSpec, 'type' | 'filterType' | 'blurState' | 'highlightState'>;
+export type IElementHighlightByName = IBaseInteractionSpec & Pick<ElementHighlightByNameSpec, 'type' | 'blurState' | 'highlightState' | 'graphicName' | 'parseData'>;
+export interface ICustomInteraction extends IBaseInteractionSpec {
+    type: string;
+}
+export type IInteractionItemSpec = IElementActiveSpec | IElementSelectSpec | IElementHighlightSpec | IElementHighlightByKeySpec | IElementHighlightByGroup | IElementActiveByLegend | IElementHighlightByLegend | IElementHighlightByName;
+export interface IInteractionSpec {
+    hover?: IHoverSpec | boolean;
+    select?: ISelectSpec | boolean;
+    interactions?: IInteractionItemSpec[];
+}
 export {};

package/types/layout/interface.d.ts

@@ -52,6 +52,7 @@ export interface ILayoutItem {
     layoutBindRegionID: number | number[];
     layoutOrient: IOrientType;
     autoIndent: boolean;
+    alignSelf?: 'start' | 'end' | 'middle';
     layoutPaddingLeft: number;
     layoutPaddingTop: number;
     layoutPaddingRight: number;
@@ -85,8 +86,10 @@ export interface ILayoutItem {
 export interface ILayoutItemSpec {
     layoutType?: ILayoutType;
     layoutLevel?: number;
+    alignSelf?: 'start' | 'end' | 'middle';
     orient?: IOrientType;
     padding?: ILayoutPaddingSpec;
+    indent?: ILayoutPaddingSpec;
     noOuterPadding?: boolean;
     width?: ILayoutNumber;
     maxWidth?: ILayoutNumber;

package/types/layout/layout-item.d.ts

@@ -3,7 +3,7 @@ import type { IRect, IPoint } from '../typings';
 import type { IBoundsLike } from '@visactor/vutils';
 import type { ILayoutItem, ILayoutItemInitOption, ILayoutItemSpec } from './interface';
 import type { IChartLayoutOption } from '../chart/interface/common';
-import type { ILayoutPoint, ILayoutRect } from '../typings/layout';
+import type { ILayoutAlignSelf, ILayoutPoint, ILayoutRect } from '../typings/layout';
 export declare class LayoutItem implements ILayoutItem {
     protected _spec: ILayoutItemSpec;
     getSpec(): ILayoutItemSpec;
@@ -43,6 +43,7 @@ export declare class LayoutItem implements ILayoutItem {
     layoutOffsetY: ILayoutItem['layoutOffsetY'];
     layoutLevel: ILayoutItem['layoutLevel'];
     chartLayoutRect: ILayoutRect;
+    alignSelf: ILayoutAlignSelf;
     protected _model: ILayoutModel;
     get model(): ILayoutModel;
     get type(): string;

package/types/mark/interface/type.d.ts

@@ -19,6 +19,7 @@ export declare enum MarkTypeEnum {
     progressArc = "progressArc",
     cell = "cell",
     ripple = "ripple",
+    liquid = "liquid",
     component = "component",
     label = "label"
 }

package/types/mark/liquid.d.ts

@@ -0,0 +1,13 @@
+import type { ILiquidMarkSpec } from '../typings';
+import type { IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface/type';
+import { BaseMark } from './base';
+import type { ILiquidMark } from '../series/liquid/liquid';
+import type { IGroupMark } from '@visactor/vgrammar-core';
+export declare class LiquidMark extends BaseMark<ILiquidMarkSpec> implements ILiquidMark {
+    static readonly type = MarkTypeEnum.liquid;
+    readonly type = MarkTypeEnum.liquid;
+    protected _getDefaultStyle(): IMarkStyle<ILiquidMarkSpec>;
+    protected _initProduct(group?: string | IGroupMark): void;
+}
+export declare const registerLiquidMark: () => void;

package/types/model/base-model.d.ts

@@ -25,8 +25,6 @@ export declare abstract class BaseModel<T extends IModelSpec> extends Compilable
     getData(): CompilableData;
     protected _layout?: ILayoutItem;
     get layout(): ILayoutItem;
-    protected _specIndex: number;
-    getSpecIndex(): number;
     readonly specKey: string;
     protected _option: IModelOption;
     getOption(): IModelOption;
@@ -79,4 +77,5 @@ export declare abstract class BaseModel<T extends IModelSpec> extends Compilable
     protected _getDataIdKey(): string | ((datum: Datum) => string) | undefined;
     getColorScheme(): import("..").IThemeColorScheme;
     getSpecInfo(): IModelSpecInfo<any>;
+    getSpecIndex(): number;
 }

package/types/model/interface.d.ts

@@ -100,7 +100,7 @@ export interface IModelOption extends ICompilableInitOption {
     map: Map<StringOrNumber, IModel | IMark>;
     mode: RenderMode;
     globalInstance: VChart;
-    specIndex?: number;
+    regionIndexes?: Array<number>;
     specKey?: string;
     specPath?: Array<string | number>;
     specInfoPath?: Array<string | number>;
@@ -120,8 +120,9 @@ export interface IModelSpecInfo<T extends Record<string, unknown> = any> {
     spec: T;
     specPath?: Array<string | number>;
     specInfoPath?: Array<string | number>;
-    specIndex?: number;
     theme?: any;
+    regionIndexes?: number[];
+    seriesIndexes?: number[];
 }
 export interface IModelConstructor {
     readonly transformerConstructor: new (option: IBaseModelSpecTransformerOption) => IBaseModelSpecTransformer;

package/types/plugin/components/axis-sync/axis-sync.d.ts

@@ -0,0 +1,13 @@
+import type { IComponentPlugin, IComponentPluginService } from '../interface';
+import type { CartesianAxis, ILinearAxisSync } from '../../../component/axis/cartesian';
+import { BasePlugin } from '../../base/base-plugin';
+export declare class AxisSyncPlugin extends BasePlugin<IComponentPluginService> implements IComponentPlugin<IComponentPluginService> {
+    static readonly pluginType: 'component';
+    static readonly type: string;
+    readonly type: string;
+    constructor();
+    protected _checkEnableSync(axis: CartesianAxis): ILinearAxisSync | false;
+    private _getTargetAxis;
+    onInit(service: IComponentPluginService, axis: CartesianAxis): void;
+    onDidCompile(service: IComponentPluginService, axis: CartesianAxis): void;
+}

package/types/plugin/components/axis-sync/index.d.ts

@@ -0,0 +1 @@
+export * from './axis-sync';

package/types/plugin/components/axis-sync/tick-align-transform.d.ts

@@ -0,0 +1,7 @@
+import type { Datum } from '../../../typings';
+import type { CartesianAxis } from '../../../component';
+export interface ITickAlignOpt {
+    targetAxis: () => CartesianAxis;
+    currentAxis: () => CartesianAxis;
+}
+export declare const tickAlign: (data: Array<Datum>, op: ITickAlignOpt) => Datum[];

package/types/plugin/components/axis-sync/zero-align-transform.d.ts

@@ -0,0 +1,15 @@
+import type { CartesianAxis } from '../../../component';
+import type { LinearAxisMixin } from '../../../component/axis/mixin/linear-axis-mixin';
+type ScaleInfo = {
+    total: number;
+    negative: number;
+    positive: number;
+    includeZero: boolean;
+    extendable_min: boolean;
+    extendable_max: boolean;
+    domain: number[];
+};
+export declare function isValidAlignDomain(domain: number[]): boolean;
+export declare function getScaleInfo(axis: LinearAxisMixin, domain: number[]): ScaleInfo;
+export declare const zeroAlign: (targetAxis: CartesianAxis, currentAxis: CartesianAxis) => void;
+export {};

package/types/plugin/components/index.d.ts

@@ -1,4 +1,4 @@
-import { AxisSyncPlugin } from './axis-sync-plugin/';
+import { AxisSyncPlugin } from './axis-sync';
 declare const _default: {
     AxisSyncPlugin: typeof AxisSyncPlugin;
 };

package/types/plugin/components/register.d.ts

@@ -0,0 +1,2 @@
+import type { IComponentPluginConstructor } from './interface';
+export declare const registerComponentPlugin: (plugin: IComponentPluginConstructor) => void;

package/types/plugin/components/tooltip-handler/base.d.ts

@@ -0,0 +1,65 @@
+import type { Options } from './constants';
+import type { Maybe, ILayoutPoint, RenderMode } from '../../../typings';
+import type { TooltipData, IToolTipActual, TooltipActiveType, ITooltipHandler, ITooltipPattern, ITooltipPositionActual } from '../../../typings/tooltip';
+import type { IGroup } from '@visactor/vrender-core';
+import type { Compiler } from '../../../compile/compiler';
+import type { IContainerSize, TooltipAttributes } from '@visactor/vrender-components';
+import type { IChartOption } from '../../../chart/interface';
+import type { ITooltipSpec, Tooltip, TooltipHandlerParams } from '../../../component/tooltip';
+import { TooltipResult } from '../../../component/tooltip';
+import type { IComponentPlugin, IComponentPluginService } from '../interface';
+import { BasePlugin } from '../../base/base-plugin';
+type ChangeTooltipFunc = (visible: boolean, params: TooltipHandlerParams, changePositionOnly?: boolean, activeType?: TooltipActiveType, data?: TooltipData) => TooltipResult;
+type ChangeTooltipPositionFunc = (changePositionOnly: boolean, data: TooltipData, params: TooltipHandlerParams) => TooltipResult;
+export declare abstract class BaseTooltipHandler extends BasePlugin implements ITooltipHandler, IComponentPlugin {
+    static readonly pluginType: 'component';
+    static readonly specKey = "tooltip";
+    readonly type: string;
+    protected _visible: boolean;
+    protected _option: Options;
+    protected _chartOption: IChartOption;
+    protected _env: RenderMode;
+    get env(): "desktop-browser" | "mobile-browser" | "node" | "worker" | "miniApp" | "wx" | "desktop-miniApp" | "lynx";
+    protected _component: Tooltip;
+    protected _attributes?: TooltipAttributes | null;
+    protected _chartContainer: Maybe<HTMLElement>;
+    protected _compiler: Compiler;
+    protected _cacheViewSpec: ITooltipSpec | undefined;
+    protected _cacheActualTooltip: IToolTipActual | undefined;
+    protected _isTooltipPaused: boolean;
+    protected _isPointerEscaped: boolean;
+    protected _cachePointerTimer: number;
+    protected _cachePointerPosition: ILayoutPoint;
+    protected _cacheTooltipPosition: ILayoutPoint;
+    protected _cacheTooltipSize: IContainerSize;
+    protected _container: Maybe<IGroup | HTMLElement>;
+    protected _isReleased: boolean;
+    onAdd(service: IComponentPluginService<any>): void;
+    showTooltip: (activeType: TooltipActiveType, data: TooltipData, params: TooltipHandlerParams) => TooltipResult;
+    protected changeTooltip: ChangeTooltipFunc;
+    protected _changeTooltip: ChangeTooltipFunc;
+    protected changeTooltipPosition: ChangeTooltipPositionFunc;
+    protected _changeTooltipPosition: ChangeTooltipPositionFunc;
+    hideTooltip(params: TooltipHandlerParams): TooltipResult;
+    release(): void;
+    protected _clearAllCache(): void;
+    protected _clearCacheOfContent(): void;
+    protected _clearCacheOfPosition(): void;
+    protected abstract _updateTooltip(visible: boolean, params: TooltipHandlerParams, domData?: IToolTipActual): void;
+    protected abstract _removeTooltip(): void;
+    protected _throttle(callback: any): (...args: unknown[]) => unknown;
+    protected _getDefaultOption(): Options;
+    protected _getActualTooltipContent: (pattern: ITooltipPattern, data: TooltipData, params: TooltipHandlerParams) => IToolTipActual;
+    protected _getActualTooltipPosition: (actualTooltip: IToolTipActual, params: TooltipHandlerParams, tooltipBoxSize: IContainerSize | undefined) => ITooltipPositionActual;
+    protected _getTooltipBoxSize(actualTooltip: IToolTipActual, changePositionOnly: boolean): IContainerSize | undefined;
+    protected _getPointerPositionRelativeToTooltipParent(params: TooltipHandlerParams): {
+        x: any;
+        y: any;
+    };
+    protected _isPointerMovingToTooltip(params: TooltipHandlerParams): boolean;
+    protected _getParentElement(spec: ITooltipSpec): HTMLElement;
+    getTooltipContainer(): IGroup | HTMLElement;
+    protected _initFromSpec(): void;
+    reInit(): void;
+}
+export {};

package/types/plugin/components/tooltip-handler/canvas/canvas-tooltip-handler.d.ts

@@ -0,0 +1,22 @@
+import type { IToolTipActual } from '../../../../typings/tooltip';
+import { BaseTooltipHandler } from '../base';
+import { Tooltip as TooltipComponent } from '@visactor/vrender-components';
+import type { TooltipHandlerParams } from '../../../../component/tooltip';
+import type { IComponentPluginService } from '../../interface';
+export declare class CanvasTooltipHandler extends BaseTooltipHandler {
+    static readonly type: string;
+    readonly type: string;
+    private _layer;
+    protected _el?: HTMLCanvasElement;
+    protected _tooltipCanvasId?: string;
+    protected _tooltipComponent: TooltipComponent;
+    constructor();
+    onAdd(service: IComponentPluginService<any>): void;
+    private _initTooltipComponent;
+    private _getLayer;
+    protected _removeTooltip(): void;
+    protected _updateTooltip(visible: boolean, params: TooltipHandlerParams, actualTooltip: IToolTipActual): void;
+    isTooltipShown(): boolean;
+    release(): void;
+}
+export declare const registerCanvasTooltipHandler: () => void;

package/types/plugin/components/tooltip-handler/canvas/index.d.ts

@@ -0,0 +1 @@
+export * from './canvas-tooltip-handler';

package/types/plugin/components/tooltip-handler/constants.d.ts

@@ -0,0 +1,17 @@
+import type { IToolTipLineActual } from '../../../typings';
+import { escapeHTML } from './utils/common';
+export declare const TOOLTIP_EL_CLASS_NAME = "vchart-tooltip-element";
+export declare const TOOLTIP_CONTAINER_EL_CLASS_NAME = "vchart-tooltip-container";
+export declare const TOOLTIP_MAX_LINE_COUNT = 20;
+export declare const TOOLTIP_EMPTY_STRING = "";
+export declare const TOOLTIP_OTHERS_LINE: IToolTipLineActual;
+export declare const DEFAULT_OPTIONS: {
+    offsetX: number;
+    offsetY: number;
+    sanitize: typeof escapeHTML;
+};
+export type Options = typeof DEFAULT_OPTIONS;
+export declare class TooltipHandlerType {
+    static dom: string;
+    static canvas: string;
+}

package/types/plugin/components/tooltip-handler/dom/dom-tooltip-handler.d.ts

@@ -0,0 +1,28 @@
+import type { IToolTipActual } from '../../../../typings/tooltip';
+import { BaseTooltipHandler } from '../base';
+import type { IDomTooltipStyle } from './interface';
+import { TooltipModel } from './model/tooltip-model';
+import type { Maybe } from '@visactor/vutils';
+import type { ITooltipSpec, TooltipHandlerParams } from '../../../../component/tooltip';
+import type { IComponentPluginService } from '../../interface';
+export declare class DomTooltipHandler extends BaseTooltipHandler {
+    static readonly type: string;
+    readonly type: string;
+    protected _tooltipContainer: HTMLElement;
+    protected _domStyle: IDomTooltipStyle;
+    protected _tooltipActual?: IToolTipActual;
+    protected _container: Maybe<HTMLDivElement>;
+    protected model: TooltipModel;
+    getVisibility(): boolean;
+    setVisibility(_value: boolean): void;
+    constructor();
+    onAdd(service: IComponentPluginService<any>): void;
+    initEl(): void;
+    protected _removeTooltip(): void;
+    protected _updateTooltip(visible: boolean, params: TooltipHandlerParams, actualTooltip: IToolTipActual): void;
+    protected _initStyle(): void;
+    protected _getParentElement(spec: ITooltipSpec): HTMLElement;
+    isTooltipShown(): boolean;
+    reInit(): void;
+}
+export declare const registerDomTooltipHandler: () => void;

package/types/plugin/components/tooltip-handler/dom/index.d.ts

@@ -0,0 +1 @@
+export * from './dom-tooltip-handler';

package/types/plugin/components/tooltip-handler/dom/interface.d.ts

@@ -0,0 +1,57 @@
+import type { FontWeight, TextAlign } from '../../../../typings/visual';
+export interface IDomTooltipStyle {
+    panel: IPadding & IBorder & {
+        width?: string;
+        height?: string;
+        minHeight?: string;
+        backgroundColor?: string;
+        boxShadow?: string;
+        pointerEvents?: 'auto' | 'none';
+        transitionDuration?: string;
+        transitionProperty?: string;
+        transitionTimingFunction?: string;
+    };
+    title: ILabelStyle;
+    content: IMargin;
+    shapeColumn: TooltipColumnStyle<IShapeStyle>;
+    keyColumn: TooltipColumnStyle<ILabelStyle>;
+    valueColumn: TooltipColumnStyle<ILabelStyle>;
+}
+export type TooltipColumnStyle<T> = IMargin & {
+    width?: string;
+    common?: T;
+    items?: T[];
+};
+export interface ILabelStyle extends IMargin {
+    fontFamily?: string;
+    fontSize?: string;
+    color?: string;
+    textAlign?: TextAlign;
+    lineHeight?: string;
+    fontWeight?: FontWeight;
+    whiteSpace?: string;
+    wordBreak?: string;
+    maxWidth?: string;
+    width?: string;
+}
+export interface IShapeStyle extends IMargin {
+    width?: string;
+    height?: string;
+}
+export interface IMargin {
+    marginLeft?: string;
+    marginRight?: string;
+    marginTop?: string;
+    marginBottom?: string;
+}
+export interface IPadding {
+    paddingTop?: string;
+    paddingRight?: string;
+    paddingBottom?: string;
+    paddingLeft?: string;
+}
+export interface IBorder {
+    borderColor?: string;
+    borderWidth?: string;
+    borderRadius?: string;
+}