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

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

@@ -13,7 +13,7 @@ export declare function transformLegendTitleAttributes(title: ITitle): {
     };
     background?: {
         visible?: boolean;
-        style?: Omit<import("./interface").NoVisibleMarkStyle<import("../..").IRectMarkSpec>, "visible" | "width" | "height">;
+        style?: Omit<import("./interface").NoVisibleMarkStyle<import("../..").IRectMarkSpec>, "width" | "height" | "visible">;
     };
     text?: string | number | number[] | string[] | {
         type?: "text";
@@ -33,9 +33,9 @@ export declare function transformLegendTitleAttributes(title: ITitle): {
         } & import("@visactor/vrender-core").SimpleDomStyleOptions & import("@visactor/vrender-core").CommonDomOptions;
     };
     padding?: import("@visactor/vrender-components").Padding;
-    visible?: boolean;
     maxWidth?: number;
     minWidth?: number;
+    visible?: boolean;
     space?: number;
     align?: "start" | "end" | "center";
 };

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

@@ -4,7 +4,7 @@ import type { IModelRenderOption, IModelSpecInfo } from '../../model/interface';
 import type { IRegion } from '../../region/interface';
 import type { CoordinateType, ILayoutRect, ILayoutType, IRect } from '../../typings';
 import { BaseComponent } from '../base/base-component';
-import type { IDataPos, IDataPosCallback, IMarkerSpec, IMarkerSupportSeries } from './interface';
+import type { IDataPos, IDataPosCallback, IMarkerAttributeContext, IMarkerSpec, IMarkerSupportSeries } from './interface';
 import type { IGraphic, IGroup } from '@visactor/vrender-core';
 import type { IOptionWithCoordinates } from '../../data/transforms/aggregation';
 export declare abstract class BaseMarker<T extends IMarkerSpec> extends BaseComponent<T> {
@@ -29,6 +29,9 @@ export declare abstract class BaseMarker<T extends IMarkerSpec> extends BaseComp
     protected abstract _markerLayout(): void;
     static _getMarkerCoordinateType(markerSpec: any): string;
     static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
+    protected _markAttributeContext: IMarkerAttributeContext;
+    getMarkAttributeContext(): IMarkerAttributeContext;
+    protected _buildMarkerAttributeContext(): void;
     created(): void;
     protected _getAllRelativeSeries(): {
         getRelativeSeries: () => IMarkerSupportSeries;

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;
-    shouldHandleTooltip(params: BaseEventParams, mouseEventData: Partial<MouseEventData>): boolean;
+    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/constant/layout.d.ts

@@ -2,6 +2,7 @@ export declare const USER_LAYOUT_RECT_LEVEL = 9;
 export declare const DEFAULT_LAYOUT_RECT_LEVEL = 0;
 export declare const DEFAULT_LAYOUT_RECT_LEVEL_MIN = -1;
 export declare enum LayoutZIndex {
+    SeriesGroup = 0,
     Axis_Grid = 50,
     CrossHair_Grid = 100,
     Region = 450,

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;
@@ -137,6 +137,7 @@ export declare class VChart implements IVChart {
     setSelected(datum: MaybeArray<any> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier): void;
     setHovered(datum: MaybeArray<Datum> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier): void;
     clearState(state: string): void;
+    clearAllStates(): void;
     clearSelected(): void;
     clearHovered(): void;
     private _updateCurrentTheme;

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/interaction/interaction.d.ts

@@ -21,7 +21,9 @@ export declare class Interaction implements IInteraction {
     removeEventElement(stateValue: StateValue, element: IElement): void;
     addEventElement(stateValue: StateValue, element: IElement): void;
     clearEventElement(stateValue: StateValue, clearReverse: boolean): void;
+    clearAllEventElement(): void;
     reverseEventElement(stateValue: StateValue): void;
     startInteraction(stateValue: StateValue, element: IElement): void;
     resetInteraction(stateValue: StateValue, element: IElement): void;
+    resetAllInteraction(): void;
 }

package/types/interaction/interface.d.ts

@@ -16,10 +16,12 @@ export interface IInteraction {
     exchangeEventElement: (stateValue: StateValue, elements: IElement) => void;
     clearEventElement: (stateValue: StateValue, clearReverse: boolean) => void;
     reverseEventElement: (stateValue: StateValue) => void;
+    clearAllEventElement: () => void;
     setDisableActiveEffect: (disable: boolean) => void;
     addVgrammarInteraction: (state: StateValue, i: IVGrammarInteraction) => void;
     startInteraction: (state: StateValue, element: IElement) => void;
     resetInteraction: (state: StateValue, element: IElement) => void;
+    resetAllInteraction: () => void;
 }
 export interface ITrigger {
     init: () => void;

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/model/tooltip-helper.d.ts

@@ -1,4 +1,4 @@
-import type { ITooltipActiveTypeAsKeys, ITooltipSpec } from '../component/tooltip/interface';
+import type { ITooltipSpec } from '../component/tooltip/interface';
 import type { TooltipActiveType } from '../typings';
 import type { IModel } from './interface';
 import type { IMark } from '../mark/interface';
@@ -6,8 +6,13 @@ export type TooltipTrigger = IModel | IMark;
 export interface ITooltipHelper {
     spec: ITooltipSpec | undefined;
     activeType: TooltipActiveType[];
-    activeTriggerSet: ITooltipActiveTypeAsKeys<Set<TooltipTrigger>, Set<TooltipTrigger>, Set<TooltipTrigger>>;
-    ignoreTriggerSet: ITooltipActiveTypeAsKeys<Set<TooltipTrigger>, Set<TooltipTrigger>, Set<TooltipTrigger>>;
+    activeTriggerSet: {
+        mark?: Set<TooltipTrigger>;
+        group?: Set<TooltipTrigger>;
+    };
+    ignoreTriggerSet: {
+        mark?: Set<TooltipTrigger>;
+    };
     updateTooltipSpec: () => void;
 }
 export declare abstract class BaseTooltipHelper implements ITooltipHelper {
@@ -15,13 +20,10 @@ export declare abstract class BaseTooltipHelper implements ITooltipHelper {
     activeType: TooltipActiveType[];
     activeTriggerSet: {
         mark: Set<TooltipTrigger>;
-        dimension: Set<TooltipTrigger>;
         group: Set<TooltipTrigger>;
     };
     ignoreTriggerSet: {
         mark: Set<TooltipTrigger>;
-        dimension: Set<TooltipTrigger>;
-        group: Set<TooltipTrigger>;
     };
     abstract 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;