@visactor/vchart-types 0.16.17-alpha.2

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

@@ -0,0 +1,53 @@
+import type { IComponent } from '../../../interface';
+import type { IAggrType, IMarkerPositionsSpec, IDataPointSpec, IMarkerSpec, IMarkerAxisSpec, IDataPos, IDataPosCallback, IMarkerLabelSpec } from '../../interface';
+import type { IRegressType } from '../../mark-area/interface';
+import type { IMarkLineTheme } from './theme';
+import type { ILineMarkSpec } from '../../../../typings';
+import type { IPointLike } from '@visactor/vutils';
+export type IMarkLine = IComponent;
+export type IMarkLineSpec = (IMarkerSpec & (IMarkLineXSpec | IMarkLineYSpec | IMarkLineCoordinateSpec | IMarkLinePositionsSpec) & IMarkLineTheme) | IStepMarkLineSpec;
+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;
+export type IStepMarkLineSpec = IMarkerSpec & {
+    type: 'type-step';
+    connectDirection: 'top' | 'bottom' | 'left' | 'right';
+    expandDistance?: number;
+    label?: IMarkerLabelSpec;
+    line?: {
+        multiSegment?: boolean;
+        mainSegmentIndex?: number;
+        style?: ILineMarkSpec | ILineMarkSpec[];
+    };
+} & Omit<IMarkLineTheme, 'label' | 'line'> & ({
+    coordinates: [IDataPointSpec, IDataPointSpec];
+    process?: {
+        x: IAggrType;
+    } | {
+        y: IAggrType;
+    } | {
+        xy: IRegressType;
+    };
+} | {
+    positions: [IPointLike, IPointLike];
+});

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

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

package/types/component/marker/mark-line/util.d.ts

@@ -0,0 +1,9 @@
+import type { IPointLike } from '@visactor/vutils';
+export declare function getInsertPoints(start: IPointLike, end: IPointLike, direction: 'top' | 'bottom' | 'left' | 'right', offset?: number): IPointLike[];
+export declare function getTextOffset(start: IPointLike, end: IPointLike, direction: 'top' | 'bottom' | 'left' | 'right', offset?: number): {
+    dx: number;
+    dy: number;
+} | {
+    dx?: undefined;
+    dy?: undefined;
+};

package/types/component/marker/mark-point/index.d.ts

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

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

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

package/types/component/marker/mark-point/interface/spec.d.ts

@@ -0,0 +1,14 @@
+import type { IPointLike } from '@visactor/vutils';
+import type { IComponent } from '../../../interface';
+import type { IDataPointSpec, IMarkerSpec } from '../../interface';
+import type { IMarkPointTheme } from './theme';
+export type IMarkPoint = IComponent;
+export type IMarkPointSpec = IMarkerSpec & (IMarkPointCoordinateSpec | IMarkPointPositionsSpec) & IMarkPointTheme;
+export type IMarkPointCoordinateSpec = {
+    coordinates: IDataPointSpec;
+    relativeRelativeSeriesIndex?: number;
+    relativeRelativeSeriesId?: string;
+};
+export type IMarkPointPositionsSpec = {
+    position: IPointLike;
+};

package/types/component/marker/mark-point/interface/theme.d.ts

@@ -0,0 +1,37 @@
+import type { IImageGraphicAttribute, IRichTextGraphicAttribute } from '@visactor/vrender-core';
+import type { IMarkPointItemPosition } from '@visactor/vrender-components';
+import type { ILineMarkSpec, ISymbolMarkSpec } from '../../../../typings';
+import type { IMarkerLabelSpec, IMarkerRef, IMarkerSymbol } from '../../interface';
+export interface IItemContent extends IMarkerRef {
+    type?: 'symbol' | 'text' | 'image' | 'richText';
+    position?: IMarkPointItemPosition;
+    offsetX?: number;
+    offsetY?: number;
+    symbol?: {
+        style?: ISymbolMarkSpec;
+    };
+    image?: {
+        style?: IImageGraphicAttribute;
+    };
+    text?: IMarkerLabelSpec;
+    richText?: {
+        style?: IRichTextGraphicAttribute;
+    };
+}
+export type IItemLine = {
+    type?: 'type-s' | 'type-do' | 'type-po' | 'type-op';
+    visible?: boolean;
+    decorativeLine?: {
+        visible?: boolean;
+        length?: number;
+    };
+    startSymbol?: IMarkerSymbol;
+    endSymbol?: IMarkerSymbol;
+    line?: {
+        style?: Omit<ILineMarkSpec, 'visible'>;
+    };
+};
+export interface IMarkPointTheme {
+    itemLine?: IItemLine;
+    itemContent?: IItemContent;
+}

package/types/component/marker/mark-point/mark-point.d.ts

@@ -0,0 +1,18 @@
+import type { IMarkPoint, IMarkPointSpec, IMarkPointTheme } from './interface';
+import type { IComponentOption } from '../../interface';
+import { ComponentTypeEnum } from '../../interface/type';
+import { MarkPoint as MarkPointComponent } from '@visactor/vrender-components';
+import { BaseMarker } from '../base-marker';
+export declare class MarkPoint extends BaseMarker<IMarkPointSpec & IMarkPointTheme> implements IMarkPoint {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    layoutZIndex: number;
+    protected _theme: IMarkPointTheme;
+    protected _markerComponent: MarkPointComponent;
+    static createComponent(spec: any, options: IComponentOption): MarkPoint | MarkPoint[];
+    protected _createMarkerComponent(): void;
+    protected _markerLayout(): void;
+    protected _initDataView(): void;
+}
+export declare const registerMarkPoint: () => void;

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

@@ -0,0 +1,6 @@
+import type { ICartesianSeries } from '../../series/interface';
+import type { DataView } from '@visactor/vdataset';
+import type { IPointLike } from '@visactor/vutils';
+export declare function xLayout(data: DataView, startRelativeSeries: ICartesianSeries, endRelativeSeries: ICartesianSeries, relativeSeries: ICartesianSeries, autoRange: boolean): [IPointLike, IPointLike][];
+export declare function yLayout(data: DataView, startRelativeSeries: ICartesianSeries, endRelativeSeries: ICartesianSeries, relativeSeries: ICartesianSeries, autoRange: boolean): [IPointLike, IPointLike][];
+export declare function coordinateLayout(data: DataView, relativeSeries: ICartesianSeries, autoRange: boolean): IPointLike[];

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

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

package/types/component/player/interface/index.d.ts

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

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

@@ -0,0 +1,18 @@
+import type { IChartSpec } from '../../../typings/spec';
+import type { IPlayerTheme } from './theme';
+export interface IPlayerField {
+    playerField?: string;
+}
+export interface IPlayer extends IPlayerTheme {
+    type?: PlayerType;
+    auto?: boolean;
+    loop?: boolean;
+    interval?: number;
+    totalDuration?: number;
+    direction?: DirectionType;
+    alternate?: boolean;
+    specs?: Partial<Omit<IChartSpec, 'player'>>[];
+}
+export type IPlayerSpec = IPlayer;
+export type PlayerType = 'continuous' | 'discrete';
+export type DirectionType = 'default' | 'reverse';

package/types/component/player/interface/theme.d.ts

@@ -0,0 +1,32 @@
+import type { ControllerLayout, OrientType } from '@visactor/vrender-components';
+import type { ISymbolMarkSpec, IRectMarkSpec } from '../../../typings';
+import type { BaseGraphicAttributes } from '@visactor/vrender-components/es/core/type';
+import type { ILayoutItemSpec } from '../../../layout/interface';
+export interface IPlayerTheme extends ILayoutItemSpec {
+    visible?: boolean;
+    dx?: number;
+    dy?: number;
+    width?: number;
+    height?: number;
+    position?: 'start' | 'middle' | 'end';
+    orient?: OrientType;
+    slider?: IPlayerSlider;
+    controller?: IPlayerController;
+}
+export type PlayerAlignType = 'start' | 'middle' | 'end';
+export interface IPlayerSlider {
+    visible?: boolean;
+    space?: number;
+    dx?: number;
+    dy?: number;
+    railStyle?: IRectMarkSpec;
+    trackStyle?: IRectMarkSpec;
+    handlerStyle?: ISymbolMarkSpec;
+}
+export interface IPlayerController {
+    visible?: boolean;
+    start?: Partial<ControllerLayout & BaseGraphicAttributes<ISymbolMarkSpec>>;
+    pause?: Partial<ControllerLayout & BaseGraphicAttributes<ISymbolMarkSpec>>;
+    backward?: Partial<ControllerLayout & BaseGraphicAttributes<ISymbolMarkSpec>>;
+    forward?: Partial<ControllerLayout & BaseGraphicAttributes<ISymbolMarkSpec>>;
+}

package/types/component/player/player.d.ts

@@ -0,0 +1,53 @@
+import type { IGraphic } from '@visactor/vrender-core';
+import type { IModelRenderOption } from '../../model/interface';
+import type { IRegion } from '../../region/interface';
+import type { IComponentOption } from '../interface';
+import type { IPlayer } from './interface';
+import type { IComponent } from '../interface';
+import type { IPoint, IOrientType, ILayoutRect } from '../../typings';
+import { type IChartSpec } from '../..';
+import { ComponentTypeEnum } from '../interface/type';
+import { BaseComponent } from '../base/base-component';
+export declare class Player extends BaseComponent<IPlayer> implements IComponent {
+    layoutZIndex: number;
+    layoutLevel: number;
+    specKey: string;
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    protected _orient: IOrientType;
+    private _specs;
+    private _playerComponent;
+    private _cacheAttrs;
+    private _direction;
+    private _alternate;
+    private _dx;
+    private _dy;
+    private _width;
+    private _height;
+    private _position;
+    get orient(): IOrientType;
+    set layoutOrient(v: IOrientType);
+    static createComponent: (spec: IChartSpec, options: IComponentOption) => Player;
+    setAttrFromSpec(): void;
+    afterSetLayoutStartPoint(pos: IPoint): void;
+    getBoundsInRect(rect: ILayoutRect, fullSpace: ILayoutRect): {
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+    };
+    changeRegions(regions: IRegion[]): void;
+    onRender(ctx: IModelRenderOption): void;
+    getVRenderComponents(): IGraphic[];
+    private _getPlayerAttrs;
+    private _createOrUpdatePlayerComponent;
+    private _computeLayoutRect;
+    private _computeWidth;
+    private _computeHeight;
+    private _computeDx;
+    private _computeDy;
+    private _maxSize;
+    private _sliderExceededSize;
+    private _initEvent;
+}
+export declare const registerPlayer: () => void;

package/types/component/player/utils/index.d.ts

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

package/types/component/player/utils/orient.d.ts

@@ -0,0 +1,3 @@
+import type { IOrientType } from '../../../typings';
+export declare const isVertical: (orient: IOrientType) => boolean;
+export declare const isHorizontal: (orient: IOrientType) => boolean;

package/types/component/player/utils/transform.d.ts

@@ -0,0 +1,4 @@
+import type { ContinuousPlayerAttributes, DiscretePlayerAttributes, Datum } from '@visactor/vrender-components';
+import type { IPlayer } from '../interface';
+export declare const transformContinuousSpecToAttrs: (spec: IPlayer, data: Datum[]) => ContinuousPlayerAttributes;
+export declare const transformDiscreteSpecToAttrs: (spec: IPlayer, data: Datum[]) => DiscretePlayerAttributes;

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

@@ -0,0 +1 @@
+export declare const registerPoptip: () => void;

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

@@ -0,0 +1,15 @@
+import type { PopTipAttributes } from '@visactor/vrender-components';
+import type { IColorKey } from '../../theme/color-scheme/interface';
+export interface IPoptipTheme extends Omit<PopTipAttributes, 'titleStyle' | 'contentStyle' | 'panel'> {
+    titleStyle?: Partial<Omit<PopTipAttributes['titleStyle'], 'fill'>> & {
+        fill?: PopTipAttributes['titleStyle']['fill'] | IColorKey;
+    };
+    contentStyle?: Partial<Omit<PopTipAttributes['contentStyle'], 'fill'>> & {
+        fill?: PopTipAttributes['contentStyle']['fill'] | IColorKey;
+    };
+    panel?: Partial<Omit<PopTipAttributes['panel'], 'fill' | 'stroke' | 'shadowColor'>> & {
+        fill?: PopTipAttributes['panel']['fill'] | IColorKey;
+        stroke?: PopTipAttributes['panel']['stroke'] | IColorKey;
+        shadowColor?: PopTipAttributes['panel']['shadowColor'] | IColorKey;
+    };
+}

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

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

package/types/component/title/interface/index.d.ts

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

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

@@ -0,0 +1,45 @@
+import type { IComponent } from '../../interface';
+import type { ITextGraphicAttribute, IRichTextCharacter, RichTextWordBreak } from '@visactor/vrender-core';
+import type { IOrientType, IPadding, StringOrNumber } from '../../../typings';
+import type { IComponentSpec } from '../../base/interface';
+export interface ITitleSpec extends Omit<IComponentSpec, 'orient'> {
+    visible?: boolean;
+    orient?: IOrientType;
+    text: Text | Text[];
+    subtext?: Text | Text[];
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    minHeight?: number;
+    maxHeight?: number;
+    innerPadding?: IPadding | number | number[];
+    align?: string;
+    verticalAlign?: string;
+    textStyle?: {
+        width?: number;
+        height?: number;
+        align?: string;
+        verticalAlign?: string;
+        wordBreak?: RichTextWordBreak;
+        maxLineWidth?: number;
+        heightLimit?: number;
+        lineClamp?: number;
+        character?: IRichTextCharacter[];
+    } & Partial<ITextGraphicAttribute>;
+    subtextStyle?: {
+        width?: number;
+        height?: number;
+        align?: string;
+        verticalAlign?: string;
+        wordBreak?: RichTextWordBreak;
+        maxLineWidth?: number;
+        heightLimit?: number;
+        lineClamp?: number;
+        character?: IRichTextCharacter[];
+    } & Partial<ITextGraphicAttribute>;
+}
+export type Text = StringOrNumber;
+export type ITitle = IComponent;

package/types/component/title/interface/theme.d.ts

@@ -0,0 +1,19 @@
+import type { ILayoutItemSpec } from '../../../layout/interface';
+import type { IColorKey } from '../../../theme/color-scheme/interface';
+import type { StringOrNumber } from '../../../typings';
+import type { TextAlign, TextBaseLine } from '../../../typings/visual';
+export interface ITitleTextTheme {
+    width?: number;
+    height?: number;
+    fontFamily?: string;
+    fontSize?: number;
+    fill?: string | IColorKey;
+    fontWeight?: StringOrNumber;
+    textAlign?: TextAlign;
+    textBaseline?: TextBaseLine;
+    lineHeight?: number;
+}
+export interface ITitleTheme extends ILayoutItemSpec {
+    textStyle?: ITitleTextTheme;
+    subtextStyle?: ITitleTextTheme;
+}

package/types/component/title/title.d.ts

@@ -0,0 +1,46 @@
+import { BaseComponent } from '../base/base-component';
+import { ComponentTypeEnum } from '../interface/type';
+import type { IComponentOption } from '../interface';
+import type { ITitle, ITitleSpec, ITitleTheme } from './interface';
+import type { IRegion } from '../../region/interface';
+import type { IGraphic } from '@visactor/vrender-core';
+import type { IPoint, IOrientType, ILayoutType, ILayoutRect } from '../../typings';
+export declare class Title extends BaseComponent<ITitleSpec> implements ITitle {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    layoutType: ILayoutType;
+    layoutZIndex: number;
+    layoutLevel: number;
+    protected _theme: ITitleTheme;
+    protected _orient: IOrientType;
+    private _titleComponent;
+    private _cacheAttrs;
+    get orient(): IOrientType;
+    constructor(spec: ITitleSpec, options: IComponentOption);
+    initLayout(): void;
+    static createComponent(spec: any, options: IComponentOption): Title | Title[];
+    onRender(ctx: any): void;
+    _compareSpec(): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    changeRegions(regions: IRegion[]): void;
+    update(ctx: IComponentOption): void;
+    resize(ctx: IComponentOption): void;
+    afterSetLayoutStartPoint(pos: IPoint): void;
+    getBoundsInRect(rect: ILayoutRect): {
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+    };
+    private _getTitleLayoutRect;
+    private _getTitleAttrs;
+    private _createOrUpdateTitleComponent;
+    getVRenderComponents(): IGraphic[];
+    clear(): void;
+}
+export declare const registerTitle: () => void;

package/types/component/title/utils.d.ts

@@ -0,0 +1,2 @@
+import type { IPadding } from '../../typings';
+export declare function transformPadding(padding: number | IPadding): number | number[];

package/types/component/tooltip/handler/base.d.ts

@@ -0,0 +1,50 @@
+import type { Options } from './constants';
+import type { Maybe } from '../../../typings';
+import type { TooltipData, IToolTipActual, TooltipActiveType, ITooltipHandler, ITooltipPattern, ITooltipPositionActual } from '../../../typings/tooltip';
+import type { Tooltip } from '../tooltip';
+import type { ITooltipSpec, TooltipHandlerParams } from '../interface';
+import { TooltipResult } from '../interface/common';
+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';
+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 implements ITooltipHandler {
+    readonly type: string;
+    protected _visible: boolean;
+    protected _option: Options;
+    protected _chartOption: IChartOption;
+    protected _id: string;
+    get id(): string;
+    protected _env: "desktop-browser" | "mobile-browser" | "node" | "worker" | "miniApp" | "wx" | "desktop-miniApp" | "lynx";
+    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 _container: Maybe<IGroup | HTMLElement>;
+    protected _isReleased: boolean;
+    constructor(tooltipId: string, component: Tooltip);
+    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 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 _getParentElement(spec: ITooltipSpec): HTMLElement;
+    getTooltipContainer(): HTMLElement | IGroup;
+    protected _initFromSpec(): void;
+    reInit(): void;
+}
+export {};

package/types/component/tooltip/handler/canvas/canvas-tooltip-handler.d.ts

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

package/types/component/tooltip/handler/canvas/index.d.ts

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

package/types/component/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/component/tooltip/handler/dom/dom-tooltip-handler.d.ts

@@ -0,0 +1,25 @@
+import type { IToolTipActual } from '../../../../typings/tooltip';
+import type { ITooltipSpec, TooltipHandlerParams } from '../../interface';
+import { BaseTooltipHandler } from '../base';
+import type { IDomTooltipStyle } from './interface';
+import { TooltipModel } from './model/tooltip-model';
+import type { Tooltip } from '../../tooltip';
+import type { Maybe } from '@visactor/vutils';
+export declare class DomTooltipHandler extends BaseTooltipHandler {
+    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(tooltipId: string, component: Tooltip);
+    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;
+}

package/types/component/tooltip/handler/dom/index.d.ts

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

package/types/component/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;
+}