@visactor/vchart-types 0.10.0-alpha.3 → 0.11.6-alpha.1

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

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

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

@@ -1,14 +1,10 @@
 import type { IComponent } from '../../interface';
 import type { ITextGraphicAttribute, IRichTextCharacter, RichTextWordBreak } from '@visactor/vrender-core';
-import type { IOrientType, IPadding, StringOrNumber } from '../../../typings';
+import type { IOrientType, IPadding } from '../../../typings';
 import type { IComponentSpec } from '../../base/interface';
-export interface ITitleSpec extends Omit<IComponentSpec, 'orient'> {
+interface ITitleSpecWithoutText extends Omit<IComponentSpec, 'orient'> {
     visible?: boolean;
     orient?: IOrientType;
-    text?: string | number | string[] | number[] | IRichTextCharacter[];
-    textType?: string;
-    subtext?: string | number | string[] | number[] | IRichTextCharacter[];
-    subtextType?: string;
     x?: number;
     y?: number;
     width?: number;
@@ -43,5 +39,20 @@ export interface ITitleSpec extends Omit<IComponentSpec, 'orient'> {
         character?: IRichTextCharacter[];
     } & Partial<ITextGraphicAttribute>;
 }
-export type Text = StringOrNumber;
+export type ITitleTextSpec = {
+    textType?: 'text';
+    text: string | number | string[] | number[];
+} | {
+    textType: 'rich';
+    text: IRichTextCharacter[];
+};
+export type ISubTitleTextSpec = {
+    subtextType?: 'text';
+    subtext?: string | number | string[] | number[];
+} | {
+    subtextType?: 'rich';
+    subtext?: IRichTextCharacter[];
+};
+export type ITitleSpec = ITitleSpecWithoutText & ITitleTextSpec & ISubTitleTextSpec;
 export type ITitle = IComponent;
+export {};

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

@@ -1,12 +1,13 @@
 import type { ILayoutItemSpec } from '../../../layout/interface';
 import type { IColorKey } from '../../../theme/color-scheme/interface';
+import type { ITokenKey } from '../../../theme/token';
 import type { StringOrNumber } from '../../../typings';
 import type { TextAlign, TextBaseLine } from '../../../typings/visual';
 export interface ITitleTextTheme {
     width?: number;
     height?: number;
     fontFamily?: string;
-    fontSize?: number;
+    fontSize?: number | ITokenKey;
     fill?: string | IColorKey;
     fontWeight?: StringOrNumber;
     textAlign?: TextAlign;

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

@@ -0,0 +1,8 @@
+import type { ITooltipLineActual } from '../../typings';
+export declare class TooltipHandlerType {
+    static dom: string;
+    static 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;

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

@@ -1,3 +1,4 @@
 export * from './tooltip';
 export * from './interface';
 export * from './tooltip-transformer';
+export * from './constant';

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

@@ -1,20 +1,25 @@
 import type { DimensionEventParams } from '../../../event/events/dimension/interface';
-import type { BaseEventParams } from '../../../event/interface';
-import type { DimensionTooltipInfo, MarkTooltipInfo } from '../processor/interface';
-import type { Datum, IShowTooltipOption } from '../../../typings';
+import type { DimensionTooltipInfo, GroupTooltipInfo, MarkTooltipInfo } from '../processor/interface';
+import type { Datum, IShowTooltipOption, ITooltipActual } from '../../../typings';
 import type { IComponent } from '../../interface';
-export type TooltipHandlerParams = (BaseEventParams | DimensionEventParams) & {
+import type { ITooltipSpec } from './spec';
+export type TooltipHandlerParams = DimensionEventParams & {
     changePositionOnly?: boolean;
+    tooltip: ITooltip;
+    tooltipSpec?: ITooltipSpec;
+    tooltipActual?: ITooltipActual;
+    groupDatum?: Datum[];
 };
-export interface ITooltipActiveTypeAsKeys<T, K> {
+export interface ITooltipActiveTypeAsKeys<T, K, U> {
     mark: T;
     dimension: K;
+    group: U;
 }
 export type TotalMouseEventData = {
-    tooltipInfo: Partial<ITooltipActiveTypeAsKeys<MarkTooltipInfo, DimensionTooltipInfo>>;
-    ignore: Partial<ITooltipActiveTypeAsKeys<boolean, boolean>>;
+    tooltipInfo: Partial<ITooltipActiveTypeAsKeys<MarkTooltipInfo, DimensionTooltipInfo, GroupTooltipInfo>>;
+    ignore: Partial<ITooltipActiveTypeAsKeys<boolean, boolean, boolean>>;
 };
-export declare enum TooltipResult {
+export declare const enum TooltipResult {
     success = 0,
     failed = 1
 }

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

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

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

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

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

@@ -1,11 +1,12 @@
-import type { IToolTipActual, ITooltipPattern, Maybe, TooltipActiveType, TooltipData } from '../../../typings';
+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>> {
+export interface ITooltipSpec extends Partial<ITooltipActiveTypeAsKeys<ITooltipPattern, ITooltipPattern, IGroupTooltipPattern>> {
     visible?: boolean;
     activeType?: TooltipActiveType | TooltipActiveType[];
-    trigger?: 'hover' | 'click' | 'none';
-    triggerOff?: 'hover' | 'click' | 'none';
+    trigger?: MaybeArray<'hover' | 'click'> | 'none';
+    triggerOff?: MaybeArray<'hover' | 'click'> | 'none';
+    lockAfterClick?: boolean;
     style?: Omit<ITooltipTheme<string>, 'offset'>;
     handler?: Partial<ITooltipHandlerSpec>;
     renderMode?: 'html' | 'canvas';
@@ -15,7 +16,7 @@ export interface ITooltipSpec extends Partial<ITooltipActiveTypeAsKeys<ITooltipP
     enterable?: boolean;
     transitionDuration?: number;
     throttleInterval?: number;
-    updateElement?: (tooltipElement: HTMLElement, actualTooltip: IToolTipActual, params: TooltipHandlerParams) => void;
+    updateElement?: (tooltipElement: HTMLElement, actualTooltip: ITooltipActual, params: TooltipHandlerParams) => void;
     offset?: {
         x?: number;
         y?: number;

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

@@ -1,15 +1,16 @@
 import type { RichTextWordBreak } from '@visactor/vrender-core';
-import type { StringOrNumber, TextAlign, TextBaseLine } from '../../../typings';
-import type { Padding } from '@visactor/vrender-components/es/core/type';
+import type { ITooltipShapeActual, StringOrNumber, TextAlign, TextBaseLine } from '../../../typings';
+import type { Padding } from '@visactor/vrender-components';
+import type { ITokenKey } from '../../../theme/token';
 export interface ITooltipTextTheme<ColorType = string> {
     fontFamily?: string;
-    fontSize?: number;
+    fontSize?: number | ITokenKey;
     fill?: ColorType;
     fontColor?: ColorType;
     fontWeight?: StringOrNumber;
     textAlign?: TextAlign;
     textBaseline?: TextBaseLine;
-    lineHeight?: number | string;
+    lineHeight?: number | string | ITokenKey;
     spacing?: number;
     multiLine?: boolean;
     maxWidth?: number;
@@ -36,7 +37,7 @@ export interface ITooltipTheme<ColorType = string> {
     shape?: {
         size?: number;
         spacing?: number;
-    };
+    } & ITooltipShapeActual;
     titleLabel?: ITooltipTextTheme<ColorType>;
     keyLabel?: Omit<ITooltipTextTheme<ColorType>, 'autoWidth'>;
     valueLabel?: ITooltipTextTheme<ColorType>;
@@ -46,4 +47,5 @@ export interface ITooltipTheme<ColorType = string> {
         x?: number;
         y?: number;
     };
+    align?: 'left' | 'right';
 }

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

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

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

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

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

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

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

@@ -3,13 +3,14 @@ import type { IMark } from '../../../mark/interface';
 import type { ISeries } from '../../../series/interface';
 import type { IDimensionInfo } from '../../../event/events/dimension/interface';
 export type DimensionTooltipInfo = IDimensionInfo[];
-export type MarkTooltipInfo = {
-    datum: Datum;
+export type MarkTooltipInfo<T = Datum> = {
+    datum: T;
     mark: IMark;
     series: ISeries;
     dimensionInfo: DimensionTooltipInfo;
 };
-export type TooltipInfo = DimensionTooltipInfo | MarkTooltipInfo;
+export type GroupTooltipInfo = MarkTooltipInfo<Datum | Datum[]>;
+export type TooltipInfo = DimensionTooltipInfo | MarkTooltipInfo | GroupTooltipInfo;
 export type MouseEventData = {
     tooltipInfo: TooltipInfo;
     ignore: boolean;

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

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

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

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

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

@@ -1,3 +1,4 @@
+import type { IChartSpecInfo } from '../../chart/interface';
 import { BaseComponentSpecTransformer } from '../base';
 export declare class TooltipSpecTransformer extends BaseComponentSpecTransformer<any> {
     protected _shouldMergeThemeToSpec(): boolean;
@@ -5,4 +6,5 @@ export declare class TooltipSpecTransformer extends BaseComponentSpecTransformer
         spec: any;
         theme: any;
     };
+    protected _transformSpecAfterMergingTheme(spec: any, chartSpec: any, chartSpecInfo?: IChartSpecInfo): void;
 }

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

@@ -3,19 +3,14 @@ import type { IModelLayoutOption, IModelRenderOption, IModelSpecInfo } from '../
 import type { IRegion } from '../../region/interface';
 import { BaseComponent } from '../base/base-component';
 import type { BaseEventParams, EventCallback, EventQuery, EventType } from '../../event/interface';
-import type { ITooltipHandler, IToolTipLineActual, TooltipActiveType } from '../../typings/tooltip';
+import type { ITooltipHandler, TooltipActiveType } from '../../typings/tooltip';
 import type { Datum, IShowTooltipOption } from '../../typings';
 import type { ITooltip, ITooltipActiveTypeAsKeys, ITooltipSpec, TooltipHandlerParams, TotalMouseEventData } from './interface';
 import { TooltipResult } from './interface/common';
-import { DimensionTooltipProcessor } from './processor/dimension-tooltip';
-import { MarkTooltipProcessor } from './processor/mark-tooltip';
+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 type TooltipActualTitleContent = {
-    title?: IToolTipLineActual;
-    content?: IToolTipLineActual[];
-};
 export declare class Tooltip extends BaseComponent<any> implements ITooltip {
     protected layoutZIndex: number;
     static type: ComponentTypeEnum;
@@ -29,12 +24,14 @@ export declare class Tooltip extends BaseComponent<any> implements ITooltip {
     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 _eventList;
-    protected _processor: ITooltipActiveTypeAsKeys<MarkTooltipProcessor, DimensionTooltipProcessor>;
     protected _isTooltipShown: boolean;
+    protected _clickLock: boolean;
     isTooltipShown(): boolean;
     changeRegions(regions: IRegion[]): void;
     protected _getNeedClearVRenderComponents(): IGraphic[];
@@ -52,12 +49,11 @@ export declare class Tooltip extends BaseComponent<any> implements ITooltip {
     protected _mountEvent: (eType: EventType, query: EventQuery, callback: EventCallback<any>) => void;
     protected _getMouseOutHandler: (needPointerDetection?: boolean) => (params: BaseEventParams) => void;
     protected _handleChartMouseOut: (params: BaseEventParams) => void;
-    protected _handleMouseMove: (params: BaseEventParams) => void;
-    protected _showTooltipByMouseEvent: (activeType: TooltipActiveType, mouseEventData: TotalMouseEventData, params: BaseEventParams, useCache?: boolean) => boolean;
+    protected _getMouseMoveHandler: (isClick: boolean) => (params: BaseEventParams) => 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;
-    setAttrFromSpec(): void;
     showTooltip(datum: Datum, options: IShowTooltipOption): false | "none" | TooltipActiveType;
     hideTooltip(): boolean;
     private _isSameAsCache;

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

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

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

@@ -0,0 +1,5 @@
+import type { TooltipActiveType } 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;

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

@@ -0,0 +1,6 @@
+import type { Datum, ITooltipLinePattern, ITooltipPattern, 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

@@ -1,2 +1,6 @@
 export * from './show-tooltip';
 export * from './common';
+export * from './get-spec';
+export * from './get-value';
+export * from './compose';
+export * from './pattern';

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

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

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

@@ -1,3 +1,21 @@
-import type { Datum, IShowTooltipOption, ITooltipHandler, TooltipActiveType } from '../../../typings';
-import type { IComponentOption } from '../../interface';
-export declare function showTooltip(datum: Datum, options: IShowTooltipOption, tooltipHandler: ITooltipHandler, componentOptions: IComponentOption): TooltipActiveType | 'none';
+import { type Datum, type IPoint, type IShowTooltipOption, type TooltipActiveType } from '../../../typings';
+import type { ISeries } from '../../../series/interface';
+import type { IRegion } from '../../../region';
+import type { Tooltip } from '../tooltip';
+type MarkInfo = {
+    pos: IPoint;
+    data: {
+        dimensionFields: string[];
+        measureFields: string[];
+        dimensionData?: any[];
+        measureData?: any[];
+        hasMeasureData?: boolean;
+        groupField?: string;
+        groupData?: any;
+    };
+    series: ISeries;
+    dimType?: string;
+};
+export declare function showTooltip(datum: Datum, options: IShowTooltipOption, component: Tooltip): TooltipActiveType | 'none';
+export declare const getMarkInfoList: (datum: Datum, region: IRegion) => MarkInfo[];
+export {};

package/types/component/util.d.ts

@@ -1,2 +1,10 @@
 import type { ITheme } from '../theme';
+import type { Datum } from '../typings';
 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;
+    args: (string | number | Datum)[];
+} | {
+    formatFunc?: undefined;
+    args?: undefined;
+};

package/types/constant/index.d.ts

@@ -15,6 +15,7 @@ export declare enum AttributeLevel {
     User_Mark = 8,
     Built_In = 99
 }
+export declare const STACK_FIELD_KEY: string;
 export declare const STACK_FIELD_START: string;
 export declare const STACK_FIELD_END: string;
 export declare const STACK_FIELD_START_PERCENT: string;

package/types/core/factory.d.ts

@@ -19,6 +19,7 @@ export declare class Factory {
     private static _implements;
     private static _chartPlugin;
     private static _componentPlugin;
+    private static _formatter;
     static transforms: {
         [key: string]: Transform;
     };
@@ -62,4 +63,6 @@ export declare class Factory {
     static getChartPlugins(): IChartPluginConstructor[];
     static getComponentPlugins(): IComponentPluginConstructor[];
     static getComponentPluginInType(type: string): IComponentPluginConstructor;
+    static registerFormatter(func: typeof Factory['_formatter']): void;
+    static getFormatter(): (text: string | number | number[] | string[], datum: any, formatter: string | string[]) => any;
 }

package/types/core/index.d.ts

@@ -10,6 +10,7 @@ export * from '../theme/interface';
 export * from '../constant';
 export * from './interface';
 export * from '../typings/spec/index';
+export * from '../typings/tooltip';
 export * from '../theme/index';
 export { vglobal } from '@visactor/vrender-core';
 export * from '../plugin';

package/types/core/interface.d.ts

@@ -1,6 +1,6 @@
 import type { DataSet } from '@visactor/vdataset';
-import type { IParserOptions } from '@visactor/vdataset/es/parser';
-import type { Datum, IInitOption, IMarkStateSpec, IPoint, IRegionQuerier, IShowTooltipOption, ISpec, ITooltipHandler, Maybe, MaybeArray, StringOrNumber } from '../typings';
+import type { IParserOptions } from '@visactor/vdataset';
+import type { Datum, IDataValues, IInitOption, IMarkStateSpec, IPoint, IRegionQuerier, IShowTooltipOption, ISpec, ITooltipHandler, Maybe, MaybeArray, StringOrNumber } from '../typings';
 import type { IMorphConfig } from '../animation/spec';
 import type { IBoundsLike } from '@visactor/vutils';
 import type { EventCallback, EventParams, EventQuery, EventType } from '../event/interface';
@@ -13,6 +13,7 @@ import type { Compiler } from '../compile/compiler';
 import type { IChart, IChartSpecInfo } from '../chart/interface';
 import type { Stage } from '@visactor/vrender-core';
 import type { IContainerSize } from '@visactor/vrender-components';
+import type { IBaseScale } from '@visactor/vscale';
 export type DataLinkSeries = {
     seriesId?: StringOrNumber;
     seriesIndex?: number;
@@ -23,6 +24,7 @@ export type DataLinkAxis = {
 };
 export interface IVChartConstructor {
     new (spec: ISpec, options: IInitOption): IVChart;
+    useRegisters: (comps: (() => void)[]) => any;
 }
 export interface IVChart {
     readonly id: number;
@@ -35,6 +37,7 @@ export interface IVChart {
         options?: IParserOptions;
     }[]) => Promise<IVChart>;
     updateDataSync: (id: StringOrNumber, data: Datum[], options?: IParserOptions) => IVChart;
+    updateFullDataSync: (data: IDataValues | IDataValues[], reRender?: boolean) => IVChart;
     updateSpec: (spec: ISpec, forceMerge?: boolean, morphConfig?: IMorphConfig, resetMediaQuery?: boolean) => Promise<IVChart>;
     updateSpecSync: (spec: ISpec, forceMerge?: boolean, morphConfig?: IMorphConfig, resetMediaQuery?: boolean) => void;
     updateModelSpecSync: (filter: string | {
@@ -54,6 +57,9 @@ export interface IVChart {
     updateState: (state: Record<string, Omit<IMarkStateSpec<unknown>, 'style'>>, filter?: (series: ISeries, mark: IMark, stateKey: string) => boolean) => void;
     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;
+    clearSelected: () => void;
+    clearHovered: () => void;
     getCurrentTheme: () => ITheme;
     getCurrentThemeName: () => string;
     setCurrentTheme: (name: string) => Promise<IVChart>;
@@ -81,7 +87,8 @@ export interface IVChart {
     getContainer: () => Maybe<HTMLElement>;
     getComponents: () => IComponent[];
     getDataSet: () => Maybe<DataSet>;
-    convertDatumToPosition: (datum: Datum, dataLinkInfo?: DataLinkSeries, isRelativeToCanvas?: boolean) => IPoint | null;
+    getScale: (scaleId: string) => IBaseScale | null;
+    convertDatumToPosition: (datum: Datum, dataLinkInfo?: DataLinkSeries, isRelativeToCanvas?: boolean, checkInViewData?: boolean) => IPoint | null;
     convertValueToPosition: ((value: StringOrNumber, dataLinkInfo: DataLinkAxis, isRelativeToCanvas?: boolean) => number | null) & ((value: [StringOrNumber, StringOrNumber], dataLinkInfo: DataLinkSeries, isRelativeToCanvas?: boolean) => IPoint | null);
     stopAnimation: () => void;
     pauseAnimation: () => void;

package/types/core/vchart.d.ts

@@ -1,13 +1,13 @@
 import type { ISeries } from '../series/interface/series';
 import type { ILayoutConstructor, LayoutCallBack } from '../layout/interface';
 import type { IDataValues, IMarkStateSpec, IInitOption } from '../typings/spec/common';
+import { RenderModeEnum } from '../typings/spec/common';
 import type { ISeriesConstructor } from '../series/interface';
-import type { DimensionIndexOption, IChart, IChartConstructor, IChartSpecInfo } from '../chart/interface';
+import type { DimensionIndexOption, IChart, IChartConstructor, IChartOption, IChartSpecInfo } from '../chart/interface';
 import type { IComponentConstructor } from '../component/interface';
 import type { EventCallback, EventParams, EventQuery, EventType } from '../event/interface';
-import type { IParserOptions } from '@visactor/vdataset/es/parser';
-import type { Transform, DataView } from '@visactor/vdataset';
-import { DataSet } from '@visactor/vdataset';
+import type { IParserOptions, Transform } from '@visactor/vdataset';
+import { DataSet, DataView } from '@visactor/vdataset';
 import type { Stage } from '@visactor/vrender-core';
 import type { GeoSourceType } from '../typings/geo';
 import type { GeoSourceOption } from '../series/map/geo-source';
@@ -46,6 +46,7 @@ export declare class VChart implements IVChart {
     static readonly Utils: {
         measureText: (text: string, textSpec?: Partial<import("@visactor/vrender-core").ITextGraphicAttribute>, option?: Partial<import("@visactor/vutils").ITextMeasureOption>, useNaiveCanvas?: boolean) => import("@visactor/vutils").ITextSize;
     };
+    static readonly vglobal: import("@visactor/vrender-core").IGlobal;
     protected _originalSpec: any;
     protected _spec: any;
     getSpec(): any;
@@ -135,6 +136,9 @@ export declare class VChart implements IVChart {
     updateState(state: Record<string, Omit<IMarkStateSpec<unknown>, 'style'>>, filter?: (series: ISeries, mark: IMark, stateKey: string) => boolean): void;
     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;
+    clearSelected(): void;
+    clearHovered(): void;
     private _updateCurrentTheme;
     private _shouldChartResize;
     private _getBackground;
@@ -167,11 +171,12 @@ export declare class VChart implements IVChart {
     getCanvas(): HTMLCanvasElement | undefined;
     getContainer(): Maybe<HTMLElement>;
     getComponents(): import("../component/interface").IComponent[];
+    getScale(scaleId: string): import("@visactor/vscale").IBaseScale;
     setDimensionIndex(value: StringOrNumber, opt?: DimensionIndexOption): void;
     stopAnimation(): void;
     pauseAnimation(): void;
     resumeAnimation(): void;
-    convertDatumToPosition(datum: Datum, dataLinkInfo?: DataLinkSeries, isRelativeToCanvas?: boolean): IPoint | null;
+    convertDatumToPosition(datum: Datum, dataLinkInfo?: DataLinkSeries, isRelativeToCanvas?: boolean, checkInViewData?: boolean): IPoint | null;
     convertValueToPosition(value: StringOrNumber, dataLinkInfo: DataLinkAxis, isRelativeToCanvas?: boolean): number | null;
     convertValueToPosition(value: [StringOrNumber, StringOrNumber], dataLinkInfo: DataLinkSeries, isRelativeToCanvas?: boolean): IPoint | null;
     getFunction(key: string): Function | null;
@@ -181,5 +186,7 @@ export declare class VChart implements IVChart {
     setRuntimeSpec(spec: any): void;
     private _initChartPlugin;
     private _chartPluginApply;
+    protected _getMode(): (typeof RenderModeEnum)["desktop-browser"] | "desktop-browser" | "mobile-browser" | "node" | "worker" | "miniApp" | "wx" | "tt" | "harmony" | "desktop-miniApp" | "lynx";
+    protected _getChartOption(type: string): IChartOption;
 }
 export declare const registerVChartCore: () => void;

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

@@ -1,6 +1,5 @@
 import type { DataView } from '@visactor/vdataset';
-import type { IAggrType } from '../../component/marker/interface';
-import type { ICartesianSeries } from '../../series/interface';
+import type { IAggrType, IMarkerSupportSeries } from '../../component/marker/interface';
 import type { StringOrNumber } from '../../typings';
 export type IOption = {
     field: string;
@@ -11,15 +10,18 @@ export type IOptionAggrField = {
 };
 export type IOptionPos = IOptionAggrField | string | number | StringOrNumber[];
 export type IOptionSeries = {
-    getRelativeSeries: () => ICartesianSeries;
-    getStartRelativeSeries: () => ICartesianSeries;
-    getEndRelativeSeries: () => ICartesianSeries;
+    getRelativeSeries: () => IMarkerSupportSeries;
+    getStartRelativeSeries: () => IMarkerSupportSeries;
+    getEndRelativeSeries: () => IMarkerSupportSeries;
 };
-export type IOptionCallback = (relativeSeriesData: any, startRelativeSeriesData: any, endRelativeSeriesData: any, relativeSeries: ICartesianSeries, startRelative: ICartesianSeries, endRelative: ICartesianSeries) => IOptionPos;
+export type IOptionCallback = (relativeSeriesData: any, startRelativeSeriesData: any, endRelativeSeriesData: any, relativeSeries: IMarkerSupportSeries, startRelative: IMarkerSupportSeries, endRelative: IMarkerSupportSeries) => IOptionPos;
 export type IOptionAggr = {
     x?: IOptionPos | IOptionCallback;
     y?: IOptionPos | IOptionCallback;
-    getRefRelativeSeries?: () => ICartesianSeries;
+    angle?: IOptionPos | IOptionCallback;
+    radius?: IOptionPos | IOptionCallback;
+    areaName?: string | IOptionCallback;
+    getRefRelativeSeries?: () => IMarkerSupportSeries;
 } & IOptionSeries;
 export declare const markerMin: (_data: Array<DataView>, opt: IOption) => number;
 export declare const markerMax: (_data: Array<DataView>, opt: IOption) => number;
@@ -31,4 +33,7 @@ export declare function markerMedian(_data: Array<DataView>, opt: IOption): numb
 export declare function markerAggregation(_data: Array<DataView>, options: IOptionAggr[]): {
     x: StringOrNumber[] | StringOrNumber | IOptionCallback | null;
     y: StringOrNumber[] | StringOrNumber | IOptionCallback | null;
+    angle: StringOrNumber[] | StringOrNumber | IOptionCallback | null;
+    radius: StringOrNumber[] | StringOrNumber | IOptionCallback | null;
+    areaName: string | IOptionCallback | null;
 }[];