@visactor/vchart-types 0.16.17-alpha.0

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;
+}

package/types/component/tooltip/handler/dom/model/base-tooltip-model.d.ts

@@ -0,0 +1,25 @@
+import type { Maybe } from '@visactor/vutils';
+import type { IToolTipLineActual } from '../../../../../typings';
+import type { ITooltipModelOption } from './interface';
+export declare class BaseTooltipModel {
+    static type: string;
+    static isInstance(obj: any): obj is BaseTooltipModel;
+    readonly type: string;
+    readonly parent: BaseTooltipModel | HTMLElement;
+    readonly childIndex: number;
+    protected _option: ITooltipModelOption;
+    setOption(option: ITooltipModelOption): void;
+    protected _renderContentCache: IToolTipLineActual[] | null;
+    children: Record<number, BaseTooltipModel>;
+    product: Maybe<HTMLElement>;
+    getParentEl(): HTMLElement;
+    constructor(parent: BaseTooltipModel | HTMLElement, option: ITooltipModelOption, childIndex?: number);
+    init(classList?: string[], id?: string): void;
+    initAll(): void;
+    setStyle(style?: Partial<CSSStyleDeclaration>): void;
+    setContent(content?: any): void;
+    setVisibility(visibility: boolean): void;
+    getVisibility(): boolean;
+    release(): void;
+    protected createElement(tag: keyof HTMLElementTagNameMap, classList?: string[], style?: Partial<CSSStyleDeclaration>, id?: string): HTMLElement;
+}

package/types/component/tooltip/handler/dom/model/content-column-model.d.ts

@@ -0,0 +1,23 @@
+import { BaseTooltipModel } from './base-tooltip-model';
+import type { ITooltipModelOption } from './interface';
+import type { IShapeSvgOption } from './shape-model';
+import type { IToolTipLineActual } from '../../../../../typings';
+export type ContentColumnType = 'shape-box' | 'key-box' | 'value-box';
+export declare class ContentColumnModel extends BaseTooltipModel {
+    readonly className: ContentColumnType;
+    constructor(parent: BaseTooltipModel | HTMLElement, option: ITooltipModelOption, className: ContentColumnType, childIndex?: number);
+    init(): void;
+    setStyle(): void;
+    setContent(): void;
+    protected _getContentColumnStyle(): import("../interface").TooltipColumnStyle<import("../interface").ILabelStyle> | {
+        display?: string;
+        marginLeft?: string;
+        marginRight?: string;
+        marginTop?: string;
+        marginBottom?: string;
+        width?: string;
+        common?: import("../interface").IShapeStyle;
+        items?: import("../interface").IShapeStyle[];
+    };
+    protected _getShapeSvgOption(line: IToolTipLineActual, index: number): IShapeSvgOption;
+}

package/types/component/tooltip/handler/dom/model/content-model.d.ts

@@ -0,0 +1,15 @@
+import { BaseTooltipModel } from './base-tooltip-model';
+import { ContentColumnModel } from './content-column-model';
+import type { Maybe } from '@visactor/vutils';
+export declare class ContentModel extends BaseTooltipModel {
+    shapeBox: Maybe<ContentColumnModel>;
+    keyBox: Maybe<ContentColumnModel>;
+    valueBox: Maybe<ContentColumnModel>;
+    init(): void;
+    private _initShapeBox;
+    private _initKeyBox;
+    private _initValueBox;
+    setStyle(style?: Partial<CSSStyleDeclaration>): void;
+    setContent(): void;
+    release(): void;
+}

package/types/component/tooltip/handler/dom/model/interface.d.ts

@@ -0,0 +1,9 @@
+import type { TooltipAttributes } from '@visactor/vrender-components';
+import type { IToolTipActual, Maybe } from '../../../../../typings';
+import type { IDomTooltipStyle } from '../interface';
+export interface ITooltipModelOption {
+    valueToHtml: (value: any) => string;
+    getTooltipStyle: () => IDomTooltipStyle;
+    getTooltipActual: () => Maybe<IToolTipActual>;
+    getTooltipAttributes: () => Maybe<TooltipAttributes>;
+}

package/types/component/tooltip/handler/dom/model/shape-model.d.ts

@@ -0,0 +1,23 @@
+import type { IGradientColor } from '@visactor/vrender-core';
+import type { ShapeType } from '../../../../../typings';
+import { BaseTooltipModel } from './base-tooltip-model';
+export interface IShapeSvgOption {
+    hasShape?: boolean;
+    symbolType?: ShapeType | string;
+    size?: string;
+    fill?: string | IGradientColor;
+    stroke?: string;
+    lineWidth?: number;
+    hollow?: boolean;
+    marginTop?: string;
+    index?: number;
+}
+export declare class ShapeModel extends BaseTooltipModel {
+    svg: SVGElement;
+    private _svgHtmlCache;
+    init(classList?: string[], id?: string, tag?: keyof HTMLElementTagNameMap): void;
+    setStyle(style?: Partial<CSSStyleDeclaration>, option?: IShapeSvgOption): void;
+    setContent(option: IShapeSvgOption): void;
+    setSvg(option?: IShapeSvgOption): void;
+    release(): void;
+}

package/types/component/tooltip/handler/dom/model/style-constants.d.ts

@@ -0,0 +1,8 @@
+export declare const defaultH2Style: Partial<CSSStyleDeclaration>;
+export declare const defaultContainerStyle: Partial<CSSStyleDeclaration>;
+export declare const defaultContentContainerStyle: Partial<CSSStyleDeclaration>;
+export declare const defaultContentColumnStyle: Partial<CSSStyleDeclaration>;
+export declare const defaultKeyStyle: Partial<CSSStyleDeclaration>;
+export declare const defaultAdaptiveKeyStyle: Partial<CSSStyleDeclaration>;
+export declare const defaultValueStyle: Partial<CSSStyleDeclaration>;
+export declare const defaultShapeStyle: Partial<CSSStyleDeclaration>;

package/types/component/tooltip/handler/dom/model/text-model.d.ts

@@ -0,0 +1,5 @@
+import { BaseTooltipModel } from './base-tooltip-model';
+export declare class TextModel extends BaseTooltipModel {
+    init(classList?: string[], id?: string, tag?: keyof HTMLElementTagNameMap): void;
+    setContent(content?: any, multiLine?: boolean): void;
+}

package/types/component/tooltip/handler/dom/model/title-model.d.ts

@@ -0,0 +1,15 @@
+import type { Maybe } from '@visactor/vutils';
+import { BaseTooltipModel } from './base-tooltip-model';
+import { ShapeModel } from './shape-model';
+import { TextModel } from './text-model';
+export declare class TitleModel extends BaseTooltipModel {
+    shape: Maybe<ShapeModel>;
+    textSpan: Maybe<TextModel>;
+    init(): void;
+    private _initShape;
+    private _releaseShape;
+    private _initTextSpan;
+    setStyle(style?: Partial<CSSStyleDeclaration>): void;
+    setContent(): void;
+    release(): void;
+}

package/types/component/tooltip/handler/dom/model/tooltip-model.d.ts

@@ -0,0 +1,21 @@
+import { BaseTooltipModel } from './base-tooltip-model';
+import { ContentModel } from './content-model';
+import type { ITooltipModelOption } from './interface';
+import { TitleModel } from './title-model';
+export declare class TooltipModel extends BaseTooltipModel {
+    title: TitleModel | null;
+    content: ContentModel | null;
+    private _classList;
+    private _id;
+    constructor(parent: BaseTooltipModel | HTMLElement, option: ITooltipModelOption, classList: string[], id: string);
+    setVisibility(visibility: boolean): void;
+    init(): void;
+    private _initPanel;
+    private _initTitle;
+    private _releaseTitle;
+    private _initContent;
+    private _releaseContent;
+    setStyle(): void;
+    setContent(): void;
+    release(): void;
+}

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

@@ -0,0 +1,6 @@
+import type { Maybe } from '@visactor/vutils';
+import type { IDomTooltipStyle } from './interface';
+import type { TooltipAttributes } from '@visactor/vrender-components';
+export declare const getPixelPropertyStr: (num?: number | number[], defaultStr?: string) => string;
+export declare const pixelPropertyStrToNumber: (str: string) => number | number[];
+export declare function getDomStyles(attributes?: Maybe<TooltipAttributes>): IDomTooltipStyle;

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

@@ -0,0 +1,2 @@
+export * from './dom';
+export * from './canvas';

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

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

package/types/component/tooltip/handler/interface/style.d.ts

@@ -0,0 +1,8 @@
+import type { ITextAttribute, IFillStyle, RichTextWordBreak } from '@visactor/vrender-core';
+export interface ITooltipTextStyle extends Partial<ITextAttribute & IFillStyle> {
+    spacing?: number;
+    multiLine?: boolean;
+    maxWidth?: number;
+    wordBreak?: RichTextWordBreak;
+    autoWidth?: boolean;
+}

package/types/component/tooltip/handler/utils/attribute.d.ts

@@ -0,0 +1,9 @@
+import type { TooltipAttributes, TooltipPanelAttrs } from '@visactor/vrender-components';
+import type { IToolTipActual } from '../../../../typings';
+import type { ITooltipTextStyle } from '../interface';
+import type { ITooltipSpec } from '../../interface/spec';
+import type { ITooltipTextTheme, ITooltipTheme } from '../../interface/theme';
+import type { IChartLevelTheme } from '../../../../core/interface';
+export declare function getTextAttributes(style?: ITooltipTextTheme, globalTheme?: IChartLevelTheme, defaultAttributes?: Partial<ITooltipTextStyle>): ITooltipTextStyle;
+export declare const getPanelAttributes: (style: ITooltipTheme['panel']) => TooltipPanelAttrs;
+export declare const getTooltipAttributes: (actualTooltip: IToolTipActual, spec: ITooltipSpec, globalTheme: IChartLevelTheme) => TooltipAttributes;

package/types/component/tooltip/handler/utils/common.d.ts

@@ -0,0 +1,18 @@
+import type { Datum } from '@visactor/vgrammar-core';
+import type { MaybeArray, TooltipContentProperty, TooltipData, TooltipPatternProperty } from '../../../../typings';
+import type { TooltipHandlerParams } from '../../interface';
+import type { ITooltipTextStyle } from '../interface/style';
+export declare function escapeHTML(value: any): string;
+export declare const getTooltipContentValue: <T>(field?: TooltipContentProperty<T>, datum?: any, params?: TooltipHandlerParams) => T;
+export declare const getTooltipPatternValue: <T>(field?: MaybeArray<TooltipPatternProperty<T>>, data?: TooltipData, params?: TooltipHandlerParams) => MaybeArray<TooltipPatternProperty<T>> extends TooltipPatternProperty<T>[] ? MaybeArray<T> : T;
+export declare function getFirstDatumFromTooltipData(data: TooltipData): Datum;
+export declare function pickFirstValidValue<T>(isValid: (element?: T) => any, ...elements: T[]): T | undefined;
+export declare function convertToColorString(color: any, defaultColor?: string): string;
+export declare const getScale: (element: HTMLElement, boundingClientRect?: DOMRect) => number;
+interface ITooltipTextInfo {
+    width: number;
+    height: number;
+    text: MaybeArray<number> | MaybeArray<string>;
+}
+export declare const measureTooltipText: (text: string, style: ITooltipTextStyle) => ITooltipTextInfo;
+export {};

package/types/component/tooltip/handler/utils/compose.d.ts

@@ -0,0 +1,5 @@
+import type { TooltipActualTitleContent } from '../../tooltip';
+import type { IToolTipLinePattern, ITooltipPattern, TooltipData, IToolTipLineActual } from '../../../../typings/tooltip';
+import type { TooltipHandlerParams } from '../../interface';
+export declare const getShowContent: (pattern: ITooltipPattern, data: TooltipData, params: TooltipHandlerParams) => TooltipActualTitleContent | null;
+export declare const getOneLineData: (datum: any, config: IToolTipLinePattern, params: TooltipHandlerParams) => IToolTipLineActual;

package/types/component/tooltip/handler/utils/get-spec.d.ts

@@ -0,0 +1,5 @@
+import type { ITooltipSpec } from '../../interface';
+import type { TooltipActiveType } from '../../../../typings';
+import type { ISeries } from '../../../../series/interface';
+import type { IDimensionInfo } from '../../../../event/events/dimension/interface';
+export declare const getTooltipSpecForShow: (activeType: TooltipActiveType, globalSpec: ITooltipSpec, series?: ISeries, dimensionInfo?: IDimensionInfo[]) => ITooltipSpec;

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

@@ -0,0 +1,6 @@
+export * from './common';
+export * from './compose';
+export * from './pattern';
+export * from './get-spec';
+export * from './position';
+export * from './attribute';

package/types/component/tooltip/handler/utils/pattern.d.ts

@@ -0,0 +1,4 @@
+import type { IDimensionInfo } from '../../../../event/events/dimension/interface';
+import type { ISeries } from '../../../../series/interface';
+import type { ITooltipPattern, TooltipActiveType } from '../../../../typings';
+export declare const makeDefaultPattern: (series: ISeries, activeType: TooltipActiveType, dimensionInfo?: IDimensionInfo[]) => ITooltipPattern | null;

package/types/component/tooltip/handler/utils/position.d.ts

@@ -0,0 +1,7 @@
+import { TooltipFixedPosition } from '../../../../typings/tooltip/position';
+export declare const getActualTooltipPositionValue: (position: number | ((event: MouseEvent) => number), event: MouseEvent) => number;
+export type TooltipHorizontalPositionType = 'left' | 'right' | 'middle';
+export type TooltipVerticalPositionType = 'top' | 'bottom' | 'middle';
+export declare const positionType: Record<TooltipFixedPosition, [TooltipHorizontalPositionType, TooltipVerticalPositionType]>;
+export declare const getHorizontalPositionType: (position: TooltipFixedPosition, defaultCase?: TooltipHorizontalPositionType) => TooltipHorizontalPositionType;
+export declare const getVerticalPositionType: (position: TooltipFixedPosition, defaultCase?: TooltipVerticalPositionType) => TooltipVerticalPositionType;

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

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

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

@@ -0,0 +1,24 @@
+import type { DimensionEventParams } from '../../../event/events/dimension/interface';
+import type { BaseEventParams } from '../../../event/interface';
+import type { DimensionTooltipInfo, MarkTooltipInfo } from '../processor/interface';
+import type { Datum, IShowTooltipOption } from '../../../typings';
+import type { IComponent } from '../../interface';
+export type TooltipHandlerParams = (BaseEventParams | DimensionEventParams) & {
+    changePositionOnly?: boolean;
+};
+export interface ITooltipActiveTypeAsKeys<T, K> {
+    mark: T;
+    dimension: K;
+}
+export type TotalMouseEventData = {
+    tooltipInfo: Partial<ITooltipActiveTypeAsKeys<MarkTooltipInfo, DimensionTooltipInfo>>;
+    ignore: Partial<ITooltipActiveTypeAsKeys<boolean, boolean>>;
+};
+export declare enum TooltipResult {
+    success = 0,
+    failed = 1
+}
+export interface ITooltip extends IComponent {
+    getVisible: () => boolean;
+    showTooltip: (datum: Datum, options: IShowTooltipOption) => void;
+}

package/types/component/tooltip/interface/event.d.ts

@@ -0,0 +1,8 @@
+import type { TooltipActiveType, TooltipData } from '../../../typings';
+import type { IComponent } from '../../interface/common';
+import type { TooltipHandlerParams } from './common';
+export type TooltipEventParams = TooltipHandlerParams & {
+    activeType?: TooltipActiveType;
+    tooltipData?: TooltipData;
+    tooltip: IComponent;
+};

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

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

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

@@ -0,0 +1,29 @@
+import type { IToolTipActual, ITooltipPattern, Maybe, TooltipActiveType, TooltipData } from '../../../typings';
+import type { ITooltipActiveTypeAsKeys, TooltipHandlerParams, TooltipResult } from './common';
+import type { ITooltipTheme } from './theme';
+export interface ITooltipSpec extends Partial<ITooltipActiveTypeAsKeys<ITooltipPattern, ITooltipPattern>> {
+    visible?: boolean;
+    activeType?: TooltipActiveType | TooltipActiveType[];
+    trigger?: 'hover' | 'click' | 'none';
+    triggerOff?: 'hover' | 'click' | 'none';
+    style?: Omit<ITooltipTheme, 'offset'>;
+    handler?: Partial<ITooltipHandlerSpec>;
+    renderMode?: 'html' | 'canvas';
+    confine?: boolean;
+    className?: string;
+    parentElement?: Maybe<string | HTMLElement | HTMLCanvasElement>;
+    enterable?: boolean;
+    transitionDuration?: number;
+    throttleInterval?: number;
+    updateElement?: (tooltipElement: HTMLElement, actualTooltip: IToolTipActual, params: TooltipHandlerParams) => void;
+    offset?: {
+        x?: number;
+        y?: number;
+    };
+}
+export interface ITooltipHandlerSpec {
+    showTooltip: (activeType: TooltipActiveType, tooltipData: TooltipData, params: TooltipHandlerParams) => Maybe<TooltipResult>;
+    hideTooltip: (params: TooltipHandlerParams) => Maybe<TooltipResult>;
+    release: () => void;
+    isTooltipShown?: () => boolean;
+}

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

@@ -0,0 +1,49 @@
+import type { RichTextWordBreak } from '@visactor/vrender-core';
+import type { StringOrNumber, TextAlign, TextBaseLine } from '../../../typings';
+import type { IColorKey } from '../../../theme/color-scheme/interface';
+import type { Padding } from '@visactor/vrender-components/es/core/type';
+export interface ITooltipTextTheme {
+    fontFamily?: string;
+    fontSize?: number;
+    fill?: string | IColorKey;
+    fontColor?: string | IColorKey;
+    fontWeight?: StringOrNumber;
+    textAlign?: TextAlign;
+    textBaseline?: TextBaseLine;
+    lineHeight?: number | string;
+    spacing?: number;
+    multiLine?: boolean;
+    maxWidth?: number;
+    wordBreak?: RichTextWordBreak;
+    autoWidth?: boolean;
+}
+export interface ITooltipTheme {
+    panel?: {
+        padding?: Padding;
+        backgroundColor?: string | IColorKey;
+        border?: {
+            color?: string | IColorKey;
+            width?: number;
+            radius?: number;
+        };
+        shadow?: {
+            x: number;
+            y: number;
+            blur: number;
+            spread: number;
+            color: string | IColorKey;
+        };
+    };
+    shape?: {
+        size?: number;
+        spacing?: number;
+    };
+    titleLabel?: ITooltipTextTheme;
+    keyLabel?: Omit<ITooltipTextTheme, 'autoWidth'>;
+    valueLabel?: ITooltipTextTheme;
+    spaceRow?: number;
+    offset?: {
+        x?: number;
+        y?: number;
+    };
+}

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

@@ -0,0 +1,18 @@
+import type { BaseEventParams } from '../../../event/interface';
+import type { TooltipActiveType, TooltipData } from '../../../typings';
+import type { TooltipHandlerParams } from '../interface';
+import { TooltipResult } from '../interface/common';
+import type { Tooltip } from '../tooltip';
+import type { MouseEventData, TooltipInfo } from './interface';
+import type { IDimensionInfo } from '../../../event/events/dimension';
+export declare abstract class BaseTooltipProcessor {
+    readonly component: Tooltip;
+    activeType: TooltipActiveType;
+    constructor(component: Tooltip);
+    abstract showTooltip(info: TooltipInfo, params: BaseEventParams, changePositionOnly: boolean): TooltipResult;
+    abstract shouldHandleTooltip(params: BaseEventParams, mouseEventData: Partial<MouseEventData>): boolean;
+    abstract getMouseEventData(params: BaseEventParams): MouseEventData;
+    protected _showTooltipByHandler: (data: TooltipData | undefined, params: TooltipHandlerParams) => TooltipResult;
+    protected _preprocessDimensionInfo(dimensionInfo?: IDimensionInfo[]): IDimensionInfo[] | undefined;
+    protected _getDimensionInfo(params: BaseEventParams): IDimensionInfo[];
+}

package/types/component/tooltip/processor/dimension-tooltip.d.ts

@@ -0,0 +1,10 @@
+import type { BaseEventParams } from '../../../event/interface';
+import type { TooltipActiveType } from '../../../typings';
+import type { DimensionTooltipInfo, MouseEventData } from './interface';
+import { BaseTooltipProcessor } from './base';
+export declare class DimensionTooltipProcessor extends BaseTooltipProcessor {
+    activeType: TooltipActiveType;
+    showTooltip(info: DimensionTooltipInfo, params: BaseEventParams, changePositionOnly: boolean): import("../interface").TooltipResult;
+    shouldHandleTooltip(params: BaseEventParams, mouseEventData: Partial<MouseEventData>): boolean;
+    getMouseEventData(params: BaseEventParams): MouseEventData;
+}

package/types/component/tooltip/processor/index.d.ts

@@ -0,0 +1,5 @@
+export * from './base';
+export * from './dimension-tooltip';
+export * from './mark-tooltip';
+export * from './interface';
+export * from './util';

package/types/component/tooltip/processor/interface.d.ts

@@ -0,0 +1,16 @@
+import type { Datum } from '@visactor/vgrammar-core';
+import type { IMark } from '../../../mark/interface';
+import type { ISeries } from '../../../series/interface';
+import type { IDimensionInfo } from '../../../event/events/dimension/interface';
+export type DimensionTooltipInfo = IDimensionInfo[];
+export type MarkTooltipInfo = {
+    datum: Datum;
+    mark: IMark;
+    series: ISeries;
+    dimensionInfo: DimensionTooltipInfo;
+};
+export type TooltipInfo = DimensionTooltipInfo | MarkTooltipInfo;
+export type MouseEventData = {
+    tooltipInfo: TooltipInfo;
+    ignore: boolean;
+};

package/types/component/tooltip/processor/mark-tooltip.d.ts

@@ -0,0 +1,10 @@
+import type { BaseEventParams } from '../../../event/interface';
+import type { TooltipActiveType } from '../../../typings';
+import type { MarkTooltipInfo, MouseEventData } from './interface';
+import { BaseTooltipProcessor } from './base';
+export declare class MarkTooltipProcessor extends BaseTooltipProcessor {
+    activeType: TooltipActiveType;
+    showTooltip(info: MarkTooltipInfo, params: BaseEventParams, changePositionOnly: boolean): import("../interface").TooltipResult;
+    shouldHandleTooltip(params: BaseEventParams, mouseEventData: Partial<MouseEventData>): boolean;
+    getMouseEventData(params: BaseEventParams): MouseEventData;
+}

package/types/component/tooltip/processor/util.d.ts

@@ -0,0 +1,4 @@
+import type { Maybe } from '@visactor/vutils';
+import type { DimensionTooltipInfo, MarkTooltipInfo, TooltipInfo } from './interface';
+export declare const isMarkInfo: (info: Maybe<TooltipInfo>) => info is MarkTooltipInfo;
+export declare const isDimensionInfo: (info: Maybe<TooltipInfo>) => info is DimensionTooltipInfo;

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

@@ -0,0 +1,64 @@
+import type { IComponentOption } from '../interface';
+import { ComponentTypeEnum } from '../interface/type';
+import type { IModelLayoutOption, IModelRenderOption, ILayoutItem } from '../../model/interface';
+import type { IRegion } from '../../region/interface';
+import { BaseComponent } from '../base/base-component';
+import type { BaseEventParams, EventCallback, EventQuery, EventType } from '../../event/interface';
+import type { ITooltipHandler, IToolTipLineActual, TooltipActiveType } from '../../typings/tooltip';
+import type { Datum, IShowTooltipOption } from '../../typings';
+import type { ITooltip, ITooltipActiveTypeAsKeys, ITooltipSpec, ITooltipTheme, TooltipHandlerParams, TotalMouseEventData } from './interface';
+import { TooltipResult } from './interface/common';
+import { DimensionTooltipProcessor } from './processor/dimension-tooltip';
+import { MarkTooltipProcessor } from './processor/mark-tooltip';
+import type { IGraphic } from '@visactor/vrender-core';
+export type TooltipActualTitleContent = {
+    title?: IToolTipLineActual;
+    content?: IToolTipLineActual[];
+};
+export declare class Tooltip extends BaseComponent<any> implements ITooltip {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    layoutType: ILayoutItem['layoutType'];
+    protected _spec: ITooltipSpec;
+    static createComponent(spec: any, options: IComponentOption): Tooltip | Tooltip[];
+    tooltipHandler?: ITooltipHandler;
+    private _alwaysShow;
+    private _cacheInfo;
+    private _eventList;
+    protected _theme: ITooltipTheme;
+    protected _processor: ITooltipActiveTypeAsKeys<MarkTooltipProcessor, DimensionTooltipProcessor>;
+    protected _isTooltipShown: boolean;
+    isTooltipShown(): boolean;
+    changeRegions(regions: IRegion[]): void;
+    getVRenderComponents(): IGraphic[];
+    protected _registerEvent(): void;
+    protected _releaseEvent(): void;
+    onLayout(ctx: IModelLayoutOption): void;
+    onLayoutEnd(ctx: IModelLayoutOption): void;
+    onRender(ctx: IModelRenderOption): void;
+    created(): void;
+    release(): void;
+    beforeRelease(): void;
+    protected _initHandler(): void;
+    protected _initProcessor(): void;
+    protected _initEvent(): void;
+    protected _mountEvent: (eType: EventType, query: EventQuery, callback: EventCallback<any>) => void;
+    protected _getMouseOutHandler: (needPointerDetection?: boolean) => (params: BaseEventParams) => void;
+    protected _handleChartMouseOut: (params: BaseEventParams) => void;
+    protected _handleMouseMove: (params: BaseEventParams) => void;
+    protected _showTooltipByMouseEvent: (activeType: TooltipActiveType, mouseEventData: TotalMouseEventData, params: BaseEventParams, useCache?: boolean) => boolean;
+    protected _getMouseEventData: (params: BaseEventParams) => TotalMouseEventData;
+    protected _hideTooltipByHandler: (params: TooltipHandlerParams) => TooltipResult;
+    protected _initTheme(theme?: any): void;
+    protected _shouldMergeThemeToSpec(): boolean;
+    reInit(theme?: any): void;
+    setAttrFromSpec(): void;
+    showTooltip(datum: Datum, options: IShowTooltipOption): false | "none" | TooltipActiveType;
+    hideTooltip(): boolean;
+    private _isSameAsCacheInfo;
+    private _isPointerInChart;
+    private _isPointerOnTooltip;
+    getVisible(): boolean;
+}
+export declare const registerTooltip: () => void;

package/types/component/tooltip/utils/common.d.ts

@@ -0,0 +1,5 @@
+import type { TooltipActiveType } from '../../../typings';
+import type { ITooltipSpec } from '../interface';
+import type { BaseEventParams } from '../../../event/interface';
+export declare const getTooltipActualActiveType: (spec?: ITooltipSpec) => TooltipActiveType[];
+export declare function isEmptyPos(params: BaseEventParams): boolean;

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

@@ -0,0 +1,2 @@
+export * from './show-tooltip';
+export * from './common';

package/types/component/tooltip/utils/show-tooltip.d.ts

@@ -0,0 +1,3 @@
+import type { Datum, IShowTooltipOption, ITooltipHandler, TooltipActiveType } from '../../../typings';
+import type { IComponentOption } from '../../interface';
+export declare function showTooltip(datum: Datum, options: IShowTooltipOption, tooltipHandler: ITooltipHandler, componentOptions: IComponentOption): TooltipActiveType | 'none';

package/types/component/util.d.ts

@@ -0,0 +1,4 @@
+import type { IModelOption } from '../model/interface';
+import type { ComponentTypeEnum } from './interface';
+import type { IComponentTheme } from './interface/theme';
+export declare function getComponentThemeFromOption(type: keyof IComponentTheme | ComponentTypeEnum, option: Partial<IModelOption>): any;

package/types/constant/base.d.ts

@@ -0,0 +1,3 @@
+export declare const PREFIX = "__VCHART";
+export declare const DEFAULT_CHART_WIDTH = 500;
+export declare const DEFAULT_CHART_HEIGHT = 500;

package/types/constant/box-plot.d.ts

@@ -0,0 +1,10 @@
+export declare const BOX_PLOT_OUTLIER_VALUE_FIELD: string;
+export declare enum BOX_PLOT_TOOLTIP_KEYS {
+    OUTLIER = "outlier",
+    MAX = "max",
+    MIN = "min",
+    MEDIAN = "median",
+    Q1 = "q1",
+    Q3 = "q3",
+    SERIES_FIELD = "seriesField"
+}

package/types/constant/correlation.d.ts

@@ -0,0 +1,3 @@
+export declare const CORRELATION_X: string;
+export declare const CORRELATION_Y: string;
+export declare const CORRELATION_SIZE: string;