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

package/build/es5/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/build/es5/component/marker/mark-point/interface/theme.d.ts

@@ -0,0 +1,37 @@
+import type { IImageGraphicAttribute, IRichTextGraphicAttribute } from '@visactor/vrender';
+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/build/es5/component/marker/mark-point/mark-point.d.ts

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

package/build/es5/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/build/es5/component/player/index.d.ts

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

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

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

package/build/es5/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/build/es5/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 '../../../model/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/build/es5/component/player/player.d.ts

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

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

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

package/build/es5/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/build/es5/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/build/es5/component/title/index.d.ts

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

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

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

package/build/es5/component/title/interface/spec.d.ts

@@ -0,0 +1,45 @@
+import type { IComponent } from '../../interface';
+import type { ITextGraphicAttribute, IRichTextCharacter, RichTextWordBreak } from '@visactor/vrender';
+import type { IModelSpec } from '../../../model/interface';
+import type { IOrientType, IPadding, StringOrNumber } from '../../../typings';
+export interface ITitleSpec extends Omit<IModelSpec, '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/build/es5/component/title/interface/theme.d.ts

@@ -0,0 +1,19 @@
+import type { ILayoutItemSpec } from '../../../model/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/build/es5/component/title/title.d.ts

@@ -0,0 +1,47 @@
+import { BaseComponent } from '../base';
+import { ComponentTypeEnum } from '../interface';
+import type { IComponentOption } from '../interface';
+import type { ITitle, ITitleSpec, ITitleTheme } from './interface';
+import type { IRegion } from '../../region/interface';
+import type { ILayoutRect } from '../../model/interface';
+import type { IPoint, IOrientType } from '../../typings';
+import type { LayoutItem } from '../../model/layout-item';
+export declare class Title extends BaseComponent implements ITitle {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    layoutType: LayoutItem['layoutType'];
+    layoutZIndex: LayoutItem['layoutZIndex'];
+    layoutLevel: number;
+    protected _spec: ITitleSpec;
+    protected _theme: ITitleTheme;
+    protected _orient: IOrientType;
+    private _titleComponent;
+    private _cacheAttrs;
+    get orient(): IOrientType;
+    get layoutOrient(): IOrientType;
+    set layoutOrient(v: IOrientType);
+    constructor(spec: ITitleSpec, options: IComponentOption);
+    static createComponent(spec: any, options: IComponentOption): Title | Title[];
+    onRender(ctx: any): void;
+    updateSpec(spec: any): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    changeRegions(regions: IRegion[]): void;
+    update(ctx: IComponentOption): void;
+    resize(ctx: IComponentOption): void;
+    setLayoutStartPosition(pos: Partial<IPoint>): void;
+    boundsInRect(rect: ILayoutRect): {
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+    };
+    private _getTitleLayoutRect;
+    private _getTitleAttrs;
+    private _createOrUpdateTitleComponent;
+    clear(): void;
+}

package/build/es5/component/title/utils.d.ts

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

package/build/es5/component/tooltip/handler/base.d.ts

@@ -0,0 +1,52 @@
+import type { Options } from './constants';
+import type { Maybe } from '../../../typings';
+import type { TooltipData, IToolTipActual, TooltipActiveType, ITooltipHandler, ITooltipPattern, ITooltipPositionActual, TooltipPosition } from '../../../typings/tooltip';
+import type { Tooltip } from '../tooltip';
+import type { ITooltipSpec, TooltipHandlerParams } from '../interface';
+import { TooltipResult } from '../interface';
+import type { ITooltipStyle } from './interface';
+import type { IGroup } from '@visactor/vrender';
+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, actualTooltip: IToolTipActual, spec: ITooltipSpec, activeType: TooltipActiveType, 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" | "desktop-miniApp" | "lynx";
+    get env(): "desktop-browser" | "mobile-browser" | "node" | "worker" | "miniApp" | "desktop-miniApp" | "lynx";
+    protected _component: Tooltip;
+    protected _chartContainer: Maybe<HTMLElement>;
+    protected _compiler: Compiler;
+    private _cacheViewSpec;
+    private _cacheActualTooltip;
+    protected _attributeCache?: TooltipAttributes | null;
+    protected _style: ITooltipStyle;
+    protected _container: Maybe<IGroup | HTMLElement>;
+    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, position: TooltipPosition | undefined, params: TooltipHandlerParams, tooltipParentElement: HTMLElement, changePositionOnly: boolean) => ITooltipPositionActual;
+    protected _getTooltipBoxSize(actualTooltip: IToolTipActual, changePositionOnly: boolean): IContainerSize | undefined;
+    protected _getStyle(): ITooltipStyle;
+    protected _getParentElement(spec: ITooltipSpec): HTMLElement;
+    getTooltipContainer(): HTMLElement | IGroup;
+    protected _initFromSpec(): void;
+    reInit(): void;
+}
+export {};

package/build/es5/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/build/es5/component/tooltip/handler/canvas/index.d.ts

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

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

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

package/build/es5/component/tooltip/handler/dom/interface.d.ts

@@ -0,0 +1,61 @@
+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: IMargin & {
+        width?: string;
+        item?: IShapeStyle;
+    };
+    keyColumn: IMargin & {
+        width?: string;
+        item?: ILabelStyle;
+    };
+    valueColumn: IMargin & {
+        width?: string;
+        item?: ILabelStyle;
+    };
+    spaceRow: string;
+}
+export interface ILabelStyle extends IMargin {
+    fontFamily?: string;
+    fontSize?: string;
+    color?: string;
+    textAlign?: TextAlign;
+    lineHeight?: string;
+    fontWeight?: FontWeight;
+    whiteSpace?: string;
+    wordBreak?: string;
+    maxWidth?: 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/build/es5/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/build/es5/component/tooltip/handler/dom/model/content-column-model.d.ts

@@ -0,0 +1,25 @@
+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").IMargin & {
+        width?: string;
+        item?: import("../interface").ILabelStyle;
+    }) | {
+        display?: string;
+        marginLeft?: string;
+        marginRight?: string;
+        marginTop?: string;
+        marginBottom?: string;
+        width?: string;
+        item?: import("../interface").IShapeStyle;
+    };
+    protected _getShapeSvgOption(line: IToolTipLineActual): IShapeSvgOption;
+}

package/build/es5/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/build/es5/component/tooltip/handler/dom/model/interface.d.ts

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

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

@@ -0,0 +1,20 @@
+import type { IGradientColor } from '@visactor/vrender';
+import type { ShapeType } from '../../../../../typings';
+import { BaseTooltipModel } from './base-tooltip-model';
+export interface IShapeSvgOption {
+    hasShape?: boolean;
+    shapeType?: ShapeType;
+    size?: string;
+    color?: string | IGradientColor;
+    hollow?: boolean;
+    marginTop?: string;
+}
+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/build/es5/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/build/es5/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;
+}