@visactor/vchart-types 1.12.4-alpha.1 → 1.12.4-alpha.2

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

@@ -7,6 +7,7 @@ import type { Datum } from '@visactor/vrender-components';
 import type { ICartesianSeries, IGeoSeries, IPolarSeries } from '../../series/interface';
 import type { IOptionAggr, IOptionAggrField, IOptionSeries, IOptionWithCoordinates } from '../../data/transforms/aggregation';
 import type { IOptionRegr } from '../../data/transforms/regression';
+import type { VChart } from '../../vchart-all';
 export type IMarkerSupportSeries = ICartesianSeries | IPolarSeries | IGeoSeries;
 export type IPolarPoint = {
     angle: number;
@@ -98,8 +99,8 @@ export type IMarkerSymbol = IMarkerRef & {
     symbolType?: SymbolType;
     size?: number;
 } & Partial<IMarkerState<Omit<ISymbolMarkSpec, 'visible'>>>;
-export type MarkerStyleCallback<T> = (markerData: DataView) => T;
-export type MarkerStateCallback<T> = (markerData: DataView) => T;
+export type MarkerStyleCallback<T> = (markerData: DataView, context: IMarkerAttributeContext) => T;
+export type MarkerStateCallback<T> = (markerData: DataView, context: IMarkerAttributeContext) => T;
 export type MarkerStateValue = 'hover' | 'hover_reverse' | 'selected' | 'selected_reverse';
 export type IMarkerState<T> = {
     style?: T | MarkerStyleCallback<T>;
@@ -112,3 +113,9 @@ export type IMarkProcessOptions = {
     needRegr?: boolean;
     processData?: DataView;
 };
+export type IMarkerAttributeContext = {
+    vchart: VChart;
+    relativeSeries: IMarkerSupportSeries;
+    startRelativeSeries: IMarkerSupportSeries;
+    endRelativeSeries: IMarkerSupportSeries;
+};

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

@@ -1,7 +1,7 @@
 import type { DataView } from '@visactor/vdataset';
 import { type IPointLike } from '@visactor/vutils';
 import type { Datum, IPoint } from '../../typings';
-import type { IDataPos, IMarkerLabelSpec, IMarkerState, IMarkerSupportSeries, IPolarPoint, MarkerPositionPoint, MarkerStateValue } from './interface';
+import type { IDataPos, IMarkerAttributeContext, IMarkerLabelSpec, IMarkerState, IMarkerSupportSeries, IPolarPoint, MarkerPositionPoint, MarkerStateValue } from './interface';
 import type { IRegion } from '../../region/interface';
 import type { OffsetPoint } from './interface';
 export declare function isAggrSpec(spec: IDataPos): boolean;
@@ -17,9 +17,9 @@ export declare function computeClipRange(regions: IRegion[]): {
     minY: number;
     maxY: number;
 };
-export declare function transformLabelAttributes(label: IMarkerLabelSpec, markerData: any): any;
-export declare function transformState(state: {} | Record<MarkerStateValue, any | IMarkerState<any>>, markerData: DataView): {} | Record<MarkerStateValue, any>;
-export declare function transformStyle(style: any, markerData: DataView): any;
+export declare function transformLabelAttributes(label: IMarkerLabelSpec, markerData: any, markAttributeContext: IMarkerAttributeContext): any;
+export declare function transformState(state: {} | Record<MarkerStateValue, any | IMarkerState<any>>, markerData: DataView, markerAttributeContext: IMarkerAttributeContext): {} | Record<MarkerStateValue, any>;
+export declare function transformStyle(style: any, markerData: DataView, markerAttributeContext: IMarkerAttributeContext): any;
 export declare function transformOffset(offset: string | number | Function, region: IRegion): any;
 export declare function computeOffsetFromRegion(point: IPointLike, offset: string | number, region: IRegion): number;
 export declare function getMarkLineProcessInfo(spec: any): {

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

@@ -1,6 +1,5 @@
 import type { IGraphic } from '@visactor/vrender-core';
-import type { Maybe } from '@visactor/vutils';
-import type { IModelRenderOption, IModelSpecInfo } from '../../model/interface';
+import type { IModelRenderOption } from '../../model/interface';
 import type { IRegion } from '../../region/interface';
 import type { IPlayer } from './interface';
 import type { IComponent } from '../interface';
@@ -28,7 +27,6 @@ export declare class Player extends BaseComponent<IPlayer> implements IComponent
     private _position;
     get orient(): IOrientType;
     set layoutOrient(v: IOrientType);
-    static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
     setAttrFromSpec(): void;
     afterSetLayoutStartPoint(pos: IPoint): void;
     getBoundsInRect(rect: ILayoutRect, fullSpace: ILayoutRect): {

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

@@ -1,5 +1,5 @@
 import type { IComponent } from '../../interface';
-import type { ITextGraphicAttribute, IRichTextCharacter, RichTextWordBreak } from '@visactor/vrender-core';
+import type { ITextGraphicAttribute, IRichTextCharacter, ITextAttribute } from '@visactor/vrender-core';
 import type { IOrientType, IPadding } from '../../../typings';
 import type { IComponentSpec } from '../../base/interface';
 interface ITitleSpecWithoutText extends Omit<IComponentSpec, 'orient'> {
@@ -21,7 +21,7 @@ interface ITitleSpecWithoutText extends Omit<IComponentSpec, 'orient'> {
         height?: number;
         align?: string;
         verticalAlign?: string;
-        wordBreak?: RichTextWordBreak;
+        wordBreak?: ITextAttribute['wordBreak'];
         maxLineWidth?: number;
         heightLimit?: number;
         lineClamp?: number;
@@ -32,7 +32,7 @@ interface ITitleSpecWithoutText extends Omit<IComponentSpec, 'orient'> {
         height?: number;
         align?: string;
         verticalAlign?: string;
-        wordBreak?: RichTextWordBreak;
+        wordBreak?: ITextAttribute['wordBreak'];
         maxLineWidth?: number;
         heightLimit?: number;
         lineClamp?: number;

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

@@ -12,7 +12,7 @@ export interface ITitleTextTheme {
     fontWeight?: StringOrNumber;
     textAlign?: TextAlign;
     textBaseline?: TextBaseLine;
-    lineHeight?: number;
+    lineHeight?: number | ITokenKey;
 }
 export interface ITitleTheme extends ILayoutItemSpec {
     textStyle?: ITitleTextTheme;

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

@@ -1,9 +1,10 @@
 import type { ITooltipLineActual, TooltipActiveType } from '../../typings';
-export declare class TooltipHandlerType {
-    static dom: string;
-    static canvas: string;
-}
+export declare const TooltipHandlerType: {
+    dom: string;
+    canvas: string;
+};
 export declare const TOOLTIP_EL_CLASS_NAME = "vchart-tooltip-element";
 export declare const TOOLTIP_MAX_LINE_COUNT = 20;
 export declare const TOOLTIP_OTHERS_LINE: ITooltipLineActual;
 export declare const TOOLTIP_TYPES: TooltipActiveType[];
+export declare const DEFAULT_SHOW_DELAY = 50;

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

@@ -7,7 +7,7 @@ export type TooltipHandlerParams = DimensionEventParams & {
     changePositionOnly?: boolean;
     tooltip: ITooltip;
     tooltipSpec?: ITooltipSpec;
-    tooltipActual?: ITooltipActual;
+    activeTooltipSpec?: ITooltipActual;
     groupDatum?: Datum[];
 };
 export interface ITooltipActiveTypeAsKeys<T, K, U> {

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

@@ -1,11 +1,24 @@
+import type { EventSourceType, EventType } from '../../../event/interface';
 import type { IGroupTooltipPattern, ITooltipActual, ITooltipPattern, Maybe, MaybeArray, TooltipActiveType, TooltipData } from '../../../typings';
 import type { ITooltipActiveTypeAsKeys, TooltipHandlerParams, TooltipResult } from './common';
 import type { ITooltipTheme } from './theme';
-export interface ITooltipSpec extends Partial<ITooltipActiveTypeAsKeys<ITooltipPattern, ITooltipPattern, IGroupTooltipPattern>> {
+export interface ITooltipSpec extends Partial<ITooltipActiveTypeAsKeys<ITooltipPattern & {
+    checkOverlap?: boolean;
+}, ITooltipPattern, IGroupTooltipPattern>> {
     visible?: boolean;
     activeType?: TooltipActiveType | TooltipActiveType[];
-    trigger?: MaybeArray<'hover' | 'click'> | 'none';
-    triggerOff?: MaybeArray<'hover' | 'click'> | 'none';
+    trigger?: MaybeArray<'hover' | 'click' | {
+        eventType: EventType;
+        source?: EventSourceType;
+        consume?: boolean;
+    }> | 'none';
+    triggerOff?: MaybeArray<'hover' | 'click' | {
+        eventType: EventType;
+        source?: EventSourceType;
+        consume?: boolean;
+        checkOutside?: boolean;
+    }> | 'none';
+    showDelay?: number;
     hideTimer?: number;
     lockAfterClick?: boolean;
     style?: Omit<ITooltipTheme<string>, 'offset' | 'transitionDuration'>;
@@ -23,9 +36,16 @@ export interface ITooltipSpec extends Partial<ITooltipActiveTypeAsKeys<ITooltipP
         y?: number;
     };
 }
+type ISeriesToolipPattern = Pick<ITooltipPattern, 'visible' | 'title' | 'content' | 'hasShape' | 'shapeColor' | 'shapeFill' | 'shapeHollow' | 'shapeLineWidth' | 'shapeSize' | 'shapeStroke' | 'shapeType' | 'updateContent' | 'updateTitle' | 'updatePosition'>;
+export interface ISeriesTooltipSpec extends Pick<ITooltipSpec, 'visible' | 'activeType' | 'handler'> {
+    dimension?: ISeriesToolipPattern;
+    mark?: ISeriesToolipPattern;
+    group?: Pick<IGroupTooltipPattern, 'triggerMark'> & ISeriesToolipPattern;
+}
 export interface ITooltipHandlerSpec {
     showTooltip: (activeType: TooltipActiveType, tooltipData: TooltipData, params: TooltipHandlerParams) => Maybe<TooltipResult>;
     hideTooltip: (params: TooltipHandlerParams) => Maybe<TooltipResult>;
     release: () => void;
     isTooltipShown?: () => boolean;
 }
+export {};

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

@@ -1,4 +1,4 @@
-import type { RichTextWordBreak } from '@visactor/vrender-core';
+import type { ITextAttribute } from '@visactor/vrender-core';
 import type { ITooltipShapePattern, StringOrNumber, TextAlign, TextBaseLine } from '../../../typings';
 import type { Padding } from '@visactor/vrender-components';
 import type { ITokenKey } from '../../../theme/token';
@@ -14,7 +14,7 @@ export interface ITooltipTextTheme<ColorType = string> {
     spacing?: number;
     multiLine?: boolean;
     maxWidth?: number;
-    wordBreak?: RichTextWordBreak;
+    wordBreak?: ITextAttribute['wordBreak'];
     autoWidth?: boolean;
 }
 export interface ITooltipTheme<ColorType = string> {

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

@@ -1,6 +1,6 @@
 import type { BaseEventParams } from '../../../event/interface';
 import type { ITooltipActual, TooltipActiveType, TooltipData } from '../../../typings';
-import type { ITooltipSpec, TooltipHandlerParams } from '../interface';
+import type { TooltipHandlerParams } from '../interface';
 import { TooltipResult } from '../interface/common';
 import type { Tooltip } from '../tooltip';
 import type { MouseEventData, TooltipInfo } from './interface';
@@ -8,15 +8,13 @@ import type { IDimensionInfo } from '../../../event/events/dimension';
 export declare abstract class BaseTooltipProcessor {
     readonly component: Tooltip;
     abstract activeType: TooltipActiveType;
-    protected _cacheViewSpec: ITooltipSpec | undefined;
-    protected _cacheActualTooltip: ITooltipActual | undefined;
+    protected _cacheActiveSpec: ITooltipActual | undefined;
     constructor(component: Tooltip);
     abstract showTooltip(info: TooltipInfo, params: BaseEventParams, changePositionOnly: boolean): TooltipResult;
     abstract getMouseEventData(params: BaseEventParams): MouseEventData;
     protected _showTooltipByHandler: (data: TooltipData | undefined, params: TooltipHandlerParams) => TooltipResult;
     protected _preprocessDimensionInfo(dimensionInfo?: IDimensionInfo[]): IDimensionInfo[] | undefined;
-    protected _updateViewSpec(params: TooltipHandlerParams): void;
-    protected _updateActualTooltip(data: TooltipData, params: TooltipHandlerParams): void;
+    protected _updateViewSpec(data: TooltipData, params: TooltipHandlerParams): void;
     shouldHandleTooltip(params: BaseEventParams, info: TooltipInfo): boolean;
     clearCache(): void;
 }

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

@@ -1,5 +1,5 @@
 import { ComponentTypeEnum } from '../interface/type';
-import type { IModelLayoutOption, IModelRenderOption, IModelSpecInfo } from '../../model/interface';
+import type { IModelLayoutOption, IModelRenderOption } from '../../model/interface';
 import type { IRegion } from '../../region/interface';
 import { BaseComponent } from '../base/base-component';
 import type { BaseEventParams, EventCallback, EventQuery, EventType } from '../../event/interface';
@@ -8,7 +8,6 @@ import type { Datum, IShowTooltipOption } from '../../typings';
 import type { ITooltip, ITooltipActiveTypeAsKeys, ITooltipSpec, TooltipHandlerParams, TotalMouseEventData } from './interface';
 import { TooltipResult } from './interface/common';
 import { GroupTooltipProcessor, DimensionTooltipProcessor, MarkTooltipProcessor } from './processor';
-import type { Maybe } from '@visactor/vutils';
 import type { IGraphic } from '@visactor/vrender-core';
 import { TooltipSpecTransformer } from './tooltip-transformer';
 export declare class Tooltip extends BaseComponent<any> implements ITooltip {
@@ -21,18 +20,24 @@ export declare class Tooltip extends BaseComponent<any> implements ITooltip {
     static specKey: string;
     specKey: string;
     layoutType: 'none';
-    private _timer?;
+    private _hideTimer?;
+    private _outTimer?;
+    private _showTimer?;
+    private _needInitEventOfTooltip?;
+    private _enterable;
+    private _isReleased;
     protected _spec: ITooltipSpec;
-    static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
     tooltipHandler?: ITooltipHandler;
     processor: ITooltipActiveTypeAsKeys<MarkTooltipProcessor, DimensionTooltipProcessor, GroupTooltipProcessor>;
     private _alwaysShow;
     private _cacheInfo;
     private _cacheParams;
     private _cacheActiveType;
+    private _cacheEnterableRect;
     private _eventList;
     protected _isTooltipShown: boolean;
     protected _clickLock: boolean;
+    private _handleMouseMove;
     isTooltipShown(): boolean;
     changeRegions(regions: IRegion[]): void;
     protected _getNeedClearVRenderComponents(): IGraphic[];
@@ -45,22 +50,24 @@ export declare class Tooltip extends BaseComponent<any> implements ITooltip {
     release(): void;
     beforeRelease(): void;
     protected _initHandler(): void;
+    protected _initEventOfTooltipContent(): void;
     protected _initProcessor(): void;
     protected _initEvent(): void;
+    protected _throttle(callback: (...args: any[]) => any): (...args: any[]) => any;
     protected _mountEvent: (eType: EventType, query: EventQuery, callback: EventCallback<any>) => void;
     protected _handleClickToLock: (params: BaseEventParams) => void;
     protected _getMouseOutHandler: (needPointerDetection?: boolean) => (params: BaseEventParams) => void;
     protected _handleChartMouseOut: (params?: BaseEventParams) => void;
     protected _getMouseMoveHandler: (isClick: boolean) => (params: BaseEventParams) => void;
+    protected _handleChartMouseMove: (params: BaseEventParams, isClick: boolean) => void;
     protected _showTooltipByMouseEvent: (activeType: TooltipActiveType, mouseEventData: TotalMouseEventData, params: BaseEventParams, isClick: boolean, useCache?: boolean) => boolean;
     protected _getMouseEventData: (params: BaseEventParams) => TotalMouseEventData;
     protected _hideTooltipByHandler: (params: TooltipHandlerParams) => TooltipResult;
     reInit(spec?: any): void;
     showTooltip(datum: Datum, options: IShowTooltipOption): false | "none" | TooltipActiveType;
-    hideTooltip(): boolean;
+    hideTooltip: () => boolean;
     private _isSameAsCache;
     private _isPointerInChart;
-    private _isPointerOnTooltip;
     getVisible(): boolean;
 }
 export declare const registerTooltip: () => void;

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

@@ -1,7 +1,9 @@
-import type { ITooltipPattern, TooltipActiveType } from '../../../typings';
-import type { ITooltipSpec } from '../interface';
+import type { Datum, ITooltipActual, ITooltipLineActual, ITooltipLinePattern, MaybeArray, TooltipActiveType, TooltipContentProperty, TooltipData, TooltipPatternProperty } from '../../../typings';
+import type { ISeriesTooltipSpec, ITooltipSpec, TooltipHandlerParams } from '../interface';
 import type { BaseEventParams } from '../../../event/interface';
 export declare const getTooltipActualActiveType: (spec?: ITooltipSpec) => TooltipActiveType[];
-export declare const isActiveTypeVisible: (type: TooltipActiveType, spec?: ITooltipSpec) => boolean;
+export declare const isActiveTypeVisible: (type: TooltipActiveType, spec?: ISeriesTooltipSpec) => boolean;
 export declare function isEmptyPos(params: BaseEventParams): boolean;
-export declare function combinePattern(patternList: ITooltipPattern[]): ITooltipPattern;
+export declare function parseContent(contentSpec: MaybeArray<TooltipPatternProperty<MaybeArray<ITooltipLinePattern>>>, defaultContent: ITooltipLinePattern, shapeAttrs: Record<string, TooltipContentProperty<any>>, data?: TooltipData, datum?: Datum[], params?: TooltipHandlerParams): ITooltipLineActual[];
+export declare function combineContents(patternList: ITooltipActual[]): ITooltipActual;
+export declare const getTimeString: (value: any, timeFormat?: string, timeFormatMode?: 'local' | 'utc') => any;

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

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

package/types/component/tooltip/utils/get-value.d.ts

@@ -1,6 +1,5 @@
-import type { Datum, ITooltipLinePattern, ITooltipPattern, TooltipContentProperty, TooltipData, TooltipPatternProperty } from '../../../typings';
+import type { Datum, TooltipContentProperty, TooltipData, TooltipPatternProperty } from '../../../typings';
 import type { TooltipHandlerParams } from '../interface';
 export declare const getTooltipContentValue: <T>(field?: TooltipContentProperty<T>, datum?: any, params?: TooltipHandlerParams, formatter?: string) => T;
 export declare const getTooltipPatternValue: <T>(field?: TooltipPatternProperty<T>, data?: TooltipData, params?: TooltipHandlerParams) => T;
-export declare const getTooltipContentPattern: (field?: ITooltipPattern['content'], data?: TooltipData, params?: TooltipHandlerParams) => Array<ITooltipLinePattern> | undefined;
 export declare function getFirstDatumFromTooltipData(data: TooltipData): Datum;

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

@@ -2,4 +2,3 @@ export * from './show-tooltip';
 export * from './common';
 export * from './get-spec';
 export * from './get-value';
-export * from './compose';

package/types/component/util.d.ts

@@ -1,5 +1,7 @@
+import type { Maybe } from '@visactor/vutils';
 import type { ITheme } from '../theme';
 import type { Datum } from '../typings';
+import type { IModelSpecInfo } from '../model/interface';
 export declare function getComponentThemeFromOption(type: string, chartTheme: ITheme): any;
 export declare function getFormatFunction(formatMethod?: any, formatter?: string | string[], text?: string | number, datum?: Datum): {
     formatFunc: any;
@@ -8,3 +10,4 @@ export declare function getFormatFunction(formatMethod?: any, formatter?: string
     formatFunc?: undefined;
     args?: undefined;
 };
+export declare const getSpecInfo: <T extends Record<string, any>>(chartSpec: any, specKey: string, compType: string, filter?: (spec: T) => boolean) => IModelSpecInfo<T>[];

package/types/core/vchart.d.ts

@@ -74,6 +74,7 @@ export declare class VChart implements IVChart {
     private _context;
     private _isReleased;
     private _chartPlugin?;
+    private _onResize?;
     constructor(spec: ISpec, options: IInitOption);
     private _setNewSpec;
     private _getSpecFromOriginalSpec;
@@ -89,7 +90,6 @@ export declare class VChart implements IVChart {
         height: number;
     };
     private _doResize;
-    private _onResize;
     private _initDataSet;
     updateCustomConfigAndRerender(updateSpecResult: IUpdateSpecResult | (() => IUpdateSpecResult), sync?: boolean, option?: IVChartRenderOption): IVChart | Promise<IVChart>;
     protected _updateCustomConfigAndRecompile(updateSpecResult: IUpdateSpecResult, option?: IVChartRenderOption): boolean;

package/types/data/initialize.d.ts

@@ -1,4 +1,3 @@
-import type { utilFunctionCtx } from '../typings/params';
 import { DataSet, DataView } from '@visactor/vdataset';
 import type { IDataViewOptions } from '@visactor/vdataset';
 import type { IDataValues } from '../typings/spec/common';
@@ -7,7 +6,7 @@ export declare function initCSVData(): void;
 export declare function initData(): void;
 export declare function initFoldData(): void;
 export declare function dataViewFromDataView(rawData: DataView, dataSet?: DataSet, op?: IDataViewOptions): DataView;
-export declare function dataToDataView(data: DataView | IDataValues, dataSet: DataSet, sourceDataViews?: DataView[], ctx?: utilFunctionCtx): DataView;
+export declare function dataToDataView(data: DataView | IDataValues, dataSet: DataSet, sourceDataViews?: DataView[]): DataView;
 export declare function updateDataViewInData(dataView: DataView, data: IDataValues, forceMerge: boolean): void;
 export declare enum TransformLevel {
     copyDataView = -10,

package/types/data/transforms/pie.d.ts

@@ -1,4 +1,5 @@
 import type { DataView } from '@visactor/vdataset';
+import type { Datum } from '../../typings';
 export interface IPieOpt {
     angleField: () => string;
     startAngle: () => number;
@@ -13,7 +14,9 @@ export interface IPieOpt {
     asK: string;
     showAllZero: boolean;
     supportNegative: boolean;
+    showEmptyCircle: boolean;
 }
 export declare const pie: (originData: Array<DataView>, op: IPieOpt) => {
     [x: string]: any;
 }[];
+export declare const isDataEmpty: (data: Datum[], angleField: string, supportNegative: boolean) => boolean;

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

@@ -5,6 +5,8 @@ import type { IBaseScale } from '@visactor/vscale';
 import type { MarkType } from './type';
 import type { ICompilableMark, ICompilableMarkOption, IModelMarkAttributeContext, StateValueType } from '../../compile/mark';
 import type { StringOrNumber } from '../../typings';
+import type { IMarkConfig } from '@visactor/vgrammar-core';
+import type { ICustomPath2D } from '@visactor/vrender-core';
 export interface VisualScaleType {
     scale: IBaseScale;
     field: StringOrNumber;
@@ -42,6 +44,14 @@ export interface IMarkRaw<T extends ICommonSpec> extends ICompilableMark {
     setPostProcess: <U extends keyof T, A>(key: U, postProcessFunc: IAttrConfig<A, T>['postProcess'], state?: StateValueType) => void;
 }
 export type IMark = IMarkRaw<ICommonSpec>;
+export interface ICompileMarkConfig extends IMarkConfig {
+    morph?: boolean;
+    morphElementKey?: string;
+    support3d?: boolean;
+    setCustomizedShape?: (datum: any[], attrs: any, path: ICustomPath2D) => ICustomPath2D;
+    clip?: boolean;
+    skipTheme?: boolean;
+}
 export interface IMarkOption extends ICompilableMarkOption {
     model: IModel;
     map: Map<StringOrNumber, IModel | IMark>;

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

@@ -1,7 +1,7 @@
 import type { IEvent } from '../event/interface';
 import type { IEffect, IModel, IModelInitOption, IModelOption, IModelRenderOption, IModelEvaluateOption, IModelSpec, IModelMarkInfo, IModelSpecInfo } from './interface';
 import type { CoordinateType } from '../typings/coordinate';
-import type { IMark, IMarkOption, IMarkRaw, IMarkStyle } from '../mark/interface';
+import type { ICompileMarkConfig, IMark, IMarkOption, IMarkRaw, IMarkStyle } from '../mark/interface';
 import type { Datum, StateValueType, ConvertToMarkStyleSpec, ICommonSpec, StringOrNumber, IRect, ILayoutRect } from '../typings';
 import type { CompilableData } from '../compile/data/compilable-data';
 import type { IGroupMark } from '@visactor/vgrammar-core';
@@ -72,7 +72,7 @@ export declare abstract class BaseModel<T extends IModelSpec> extends Compilable
     protected stateKeyToSignalName(key: string, opt?: string): string;
     compileData(): void;
     compileMarks(group?: string | IGroupMark): void;
-    protected _createMark<T extends IMark>(markInfo: IModelMarkInfo, option?: Partial<IMarkOption>): T;
+    protected _createMark<T extends IMark>(markInfo: IModelMarkInfo, option?: Partial<IMarkOption>, config?: ICompileMarkConfig): T;
     protected _getDataIdKey(): string | ((datum: Datum) => string) | undefined;
     getColorScheme(): import("..").IThemeColorScheme;
     getSpecInfo(): IModelSpecInfo<any>;

package/types/model/interface.d.ts

@@ -20,6 +20,8 @@ import type { ILayoutItem, ILayoutItemSpec } from '../layout/interface';
 import type { ILayoutPoint, ILayoutRect } from '../typings/layout';
 import type { ComponentTypeEnum } from '../component/interface';
 import type { SeriesTypeEnum } from '../series';
+import type { ITooltipSpec } from '../component/tooltip/interface';
+import type { TooltipActiveType } from '../typings';
 export interface IModelInitOption {
 }
 export interface IModelLayoutOption {
@@ -152,3 +154,15 @@ export interface IBaseModelSpecTransformer {
     getTheme: (spec: any, chartSpec: any) => any;
     transformSpec: (spec: any, chartSpec: any, chartSpecInfo?: IChartSpecInfo) => IBaseModelSpecTransformerResult<any, any>;
 }
+export interface ITooltipHelper {
+    spec: ITooltipSpec | undefined;
+    activeType: TooltipActiveType[];
+    activeTriggerSet: {
+        mark?: Set<IMark>;
+        group?: Set<IMark>;
+    };
+    ignoreTriggerSet: {
+        mark?: Set<IMark>;
+    };
+    updateTooltipSpec: () => void;
+}

package/types/plugin/chart/media-query/media-query.d.ts

@@ -19,6 +19,7 @@ export declare class MediaQuery extends BasePlugin implements IChartPlugin {
     onInit(service: IChartPluginService, chartSpec: any): void;
     onBeforeResize(service: IChartPluginService, width: number, height: number): void;
     onAfterChartSpecTransform(service: IChartPluginService, chartSpec: any, actionSource: VChartRenderActionSource): void;
+    onAfterModelSpecTransform(service: IChartPluginService, chartSpec: any, chartInfo: IChartSpecInfo, actionSource: VChartRenderActionSource): void;
     onBeforeInitChart(service: IChartPluginService, chartSpec: any, actionSource: VChartRenderActionSource): void;
     protected _changeSize(width: number, height: number, compile?: boolean, render?: boolean): boolean;
     protected _applyQueries(compile?: boolean, render?: boolean): boolean;

package/types/plugin/chart/plugin-service.d.ts

@@ -2,12 +2,14 @@ import type { IChartPlugin, IChartPluginService } from './interface';
 import type { IVChart } from '../../core';
 import { BasePluginService } from '../base/base-plugin-service';
 import type { VChartRenderActionSource } from '../../core/interface';
+import type { IChartSpecInfo } from '../../chart/interface/common';
 export declare class ChartPluginService<T extends IChartPlugin = IChartPlugin> extends BasePluginService<T> implements IChartPluginService<T> {
     globalInstance: IVChart;
     constructor(globalInstance: IVChart);
     onInit(chartSpec: any): void;
     onBeforeResize(width: number, height: number): void;
     onAfterChartSpecTransform(chartSpec: any, actionSource: VChartRenderActionSource): void;
+    onAfterModelSpecTransform(chartSpec: any, chartSpecInfo: IChartSpecInfo, actionSource: VChartRenderActionSource): void;
     onBeforeInitChart(chartSpec: any, actionSource: VChartRenderActionSource): void;
     releaseAll(): void;
 }

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

@@ -8,6 +8,7 @@ type ScaleInfo = {
     extendable_min: boolean;
     extendable_max: boolean;
     domain: number[];
+    break?: boolean;
 };
 export declare function isValidAlignDomain(domain: number[]): boolean;
 export declare function getScaleInfo(axis: LinearAxisMixin, domain: number[]): ScaleInfo;

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

@@ -1,5 +1,5 @@
 import type { Options } from './constants';
-import type { Maybe, ILayoutPoint, RenderMode } from '../../../typings';
+import type { Maybe, RenderMode } from '../../../typings';
 import type { TooltipData, ITooltipActual, TooltipActiveType, ITooltipHandler, ITooltipPositionActual } from '../../../typings/tooltip';
 import type { IGroup } from '@visactor/vrender-core';
 import type { Compiler } from '../../../compile/compiler';
@@ -25,34 +25,19 @@ export declare abstract class BaseTooltipHandler extends BasePlugin implements I
     protected _attributes?: ITooltipAttributes | null;
     protected _chartContainer: Maybe<HTMLElement>;
     protected _compiler: Compiler;
-    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 abstract _updateTooltip(visible: boolean, params: TooltipHandlerParams): void;
     protected abstract _removeTooltip(): void;
-    protected _throttle(callback: any): (...args: unknown[]) => unknown;
     protected _getDefaultOption(): Options;
     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(): HTMLElement | IGroup;
     protected _initFromSpec(): void;

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

@@ -27,6 +27,5 @@ export declare class DomTooltipHandler extends BaseTooltipHandler {
     isTooltipShown(): boolean;
     reInit(): void;
     protected _updatePosition({ x, y }: ITooltipPositionActual): void;
-    protected _initEvent(el: HTMLElement): void;
 }
 export declare const registerDomTooltipHandler: () => void;

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

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

package/types/plugin/components/tooltip-handler/utils/position.d.ts

@@ -2,11 +2,9 @@ import type { IDimensionData } from '../../../../event';
 import { type ILayoutPoint } from '../../../../typings';
 import type { IFixedTooltipPositionPattern, IGlobalTooltipPositionPattern, TooltipFixedPosition } from '../../../../typings/tooltip/position';
 export declare const getActualTooltipPositionValue: (position: number | ((event: MouseEvent) => number), event: MouseEvent) => number;
-export type TooltipHorizontalPositionType = 'left' | 'right' | 'center' | 'centerLeft' | 'centerRight';
-export type TooltipVerticalPositionType = 'top' | 'bottom' | 'center' | 'centerTop' | 'centerBottom';
-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;
+export type TooltipPositionType = -2 | -1 | 0 | 1 | 2;
+export declare const positionType: Record<TooltipFixedPosition, [TooltipPositionType, TooltipPositionType]>;
+export declare const getPositionType: (position: TooltipFixedPosition, dim: 'x' | 'y', defaultCase?: TooltipPositionType) => TooltipPositionType;
 export declare const getCartesianCrosshairRect: (dimensionData: IDimensionData, layoutStartPoint: ILayoutPoint) => {
     visible: boolean;
     start: {

package/types/region/interface.d.ts

@@ -53,7 +53,9 @@ export interface IRegionSpec extends ILayoutItemSpec {
 }
 export interface IGeoRegionSpec extends IRegionSpec {
     coordinate?: 'geo';
-    roam?: boolean;
+    roam?: boolean | {
+        blank?: boolean;
+    };
     longitudeField?: string;
     latitudeField?: string;
     projection?: Partial<Omit<IProjectionSpec, 'name'>>;

package/types/series/area/area.d.ts

@@ -22,6 +22,8 @@ export declare class AreaSeries<T extends IAreaSeriesSpec = IAreaSeriesSpec> ext
     initMarkStyle(): void;
     initAreaMarkStyle(): void;
     initAnimation(): void;
+    protected _isAreaVisible(): boolean;
+    protected _isLineVisible(): boolean;
     protected initTooltip(): void;
     viewDataStatisticsUpdate(d: DataView): void;
     compile(): void;

package/types/series/bar/bar.d.ts

@@ -1,6 +1,6 @@
 import type { IBaseScale } from '@visactor/vscale';
 import { CartesianSeries } from '../cartesian/cartesian';
-import type { IMark, IMarkProgressiveConfig } from '../../mark/interface';
+import type { IMark } from '../../mark/interface';
 import { MarkTypeEnum } from '../../mark/interface/type';
 import type { Datum, DirectionType } from '../../typings';
 import type { IBarSeriesSpec } from './interface';
@@ -27,7 +27,7 @@ export declare class BarSeries<T extends IBarSeriesSpec = IBarSeriesSpec> extend
     protected _barBackgroundMark: IRectMark;
     protected _barBackgroundViewData: SeriesData;
     initMark(): void;
-    protected _initBarBackgroundMark(progressive?: IMarkProgressiveConfig): void;
+    protected _initBarBackgroundMark(): void;
     initMarkStyle(): void;
     initLabelMarkStyle(textMark: ITextMark): void;
     protected initTooltip(): void;
@@ -40,8 +40,8 @@ export declare class BarSeries<T extends IBarSeriesSpec = IBarSeriesSpec> extend
     protected _dataToPosX1(datum: Datum): number;
     protected _dataToPosY(datum: Datum): number;
     protected _dataToPosY1(datum: Datum): number;
-    protected _getBarXStart: (datum: Datum, scale: IBaseScale) => any;
-    protected _getBarXEnd: (datum: Datum, scale: IBaseScale) => any;
+    protected _getBarXStart: (datum: Datum, scale: IBaseScale, useWholeRange?: boolean) => any;
+    protected _getBarXEnd: (datum: Datum, scale: IBaseScale, useWholeRange?: boolean) => any;
     protected _getBarYStart: (datum: Datum, scale: IBaseScale) => any;
     protected _getBarYEnd: (datum: Datum, scale: IBaseScale) => any;
     initBandRectMarkStyle(): void;