@visactor/vchart-types 1.15.5-alpha.8 → 2.0.0-alpha.1

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

@@ -1,6 +1,6 @@
 import type { DimensionEventParams } from '../../../event/events/dimension/interface';
 import type { DimensionTooltipInfo, GroupTooltipInfo, MarkTooltipInfo } from '../processor/interface';
-import type { Datum, IShowTooltipOption, ITooltipActual } from '../../../typings';
+import type { Datum, IShowTooltipOption, ITooltipActual, ITooltipHandler } from '../../../typings';
 import type { IComponent } from '../../interface';
 import type { ITooltipSpec } from './spec';
 export type TooltipHandlerParams = DimensionEventParams & {
@@ -24,6 +24,7 @@ export declare const enum TooltipResult {
     failed = 1
 }
 export interface ITooltip extends IComponent {
+    tooltipHandler?: ITooltipHandler;
     getVisible: () => boolean;
     showTooltip: (datum: Datum, options: IShowTooltipOption) => void;
 }

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

@@ -1,15 +1,14 @@
 import type { BaseEventParams } from '../../../event/interface';
 import type { ITooltipActual, TooltipActiveType, TooltipData } from '../../../typings';
-import type { TooltipHandlerParams } from '../interface';
+import type { ITooltip, TooltipHandlerParams } from '../interface';
 import { TooltipResult } from '../interface/common';
-import type { Tooltip } from '../tooltip';
 import type { MouseEventData, TooltipInfo } from './interface';
-import type { IDimensionInfo } from '../../../event/events/dimension';
+import type { IDimensionInfo } from '../../../event/events/dimension/interface';
 export declare abstract class BaseTooltipProcessor {
-    readonly component: Tooltip;
+    readonly component: ITooltip;
     abstract activeType: TooltipActiveType;
     protected _cacheActiveSpec: ITooltipActual | undefined;
-    constructor(component: Tooltip);
+    constructor(component: ITooltip);
     abstract showTooltip(info: TooltipInfo, params: BaseEventParams, changePositionOnly: boolean): TooltipResult;
     abstract getMouseEventData(params: BaseEventParams): MouseEventData;
     protected _showTooltipByHandler: (data: TooltipData | undefined, params: TooltipHandlerParams) => TooltipResult;

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

@@ -9,3 +9,4 @@ export declare class DimensionTooltipProcessor extends BaseTooltipProcessor {
     protected _getDimensionInfo(params: BaseEventParams): IDimensionInfo[];
     getMouseEventData(params: BaseEventParams): MouseEventData;
 }
+export declare const registerDimensionTooltipProcessor: () => void;

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

@@ -8,3 +8,4 @@ export declare class GroupTooltipProcessor extends BaseTooltipProcessor {
     getMouseEventData(params: BaseEventParams): MouseEventData;
     protected _getGroupDatum(params: BaseEventParams): any;
 }
+export declare const registerGroupTooltipProcessor: () => void;

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

@@ -1,7 +1,9 @@
-import type { Datum } from '@visactor/vgrammar-core';
 import type { IMark } from '../../../mark/interface';
 import type { ISeries } from '../../../series/interface';
 import type { IDimensionInfo } from '../../../event/events/dimension/interface';
+import type { Datum } from '../../../typings/common';
+import type { BaseEventParams } from '../../../event/interface';
+import type { ITooltip, TooltipResult } from '../interface/common';
 export type DimensionTooltipInfo = IDimensionInfo[];
 export type MarkTooltipInfo<T = Datum> = {
     datum: T;
@@ -14,3 +16,12 @@ export type MouseEventData = {
     tooltipInfo: TooltipInfo;
     ignore: boolean;
 };
+export interface ITooltipProcessor<T> {
+    shouldHandleTooltip: (params: BaseEventParams, info: TooltipInfo) => boolean;
+    clearCache: () => void;
+    showTooltip: (info: T, params: BaseEventParams, changePositionOnly: boolean) => TooltipResult;
+    getMouseEventData: (params: BaseEventParams) => MouseEventData;
+}
+export interface ITooltipProcessorConstructor {
+    new (comp: ITooltip): ITooltipProcessor<DimensionTooltipInfo> | ITooltipProcessor<MarkTooltipInfo> | ITooltipProcessor<GroupTooltipInfo>;
+}

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

@@ -7,3 +7,4 @@ export declare class MarkTooltipProcessor extends BaseTooltipProcessor {
     showTooltip(info: MarkTooltipInfo, params: BaseEventParams, changePositionOnly: boolean): import("../interface").TooltipResult;
     getMouseEventData(params: BaseEventParams): MouseEventData;
 }
+export declare const registerMarkTooltipProcessor: () => void;

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<any>;
+export declare const isMarkInfo: (info: Maybe<TooltipInfo>) => info is MarkTooltipInfo<import("../../..").Datum>;
 export declare const isDimensionInfo: (info: Maybe<TooltipInfo>) => info is DimensionTooltipInfo;

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

@@ -1,5 +1,5 @@
 import { ComponentTypeEnum } from '../interface/type';
-import type { IModelLayoutOption, IModelRenderOption } from '../../model/interface';
+import type { 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';
@@ -7,7 +7,7 @@ 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 { GroupTooltipProcessor, DimensionTooltipProcessor, MarkTooltipProcessor } from './processor';
+import type { DimensionTooltipInfo, GroupTooltipInfo, ITooltipProcessor, MarkTooltipInfo } from './processor/interface';
 import type { IGraphic } from '@visactor/vrender-core';
 import { TooltipSpecTransformer } from './tooltip-transformer';
 export declare class Tooltip extends BaseComponent<any> implements ITooltip {
@@ -17,6 +17,9 @@ export declare class Tooltip extends BaseComponent<any> implements ITooltip {
     type: ComponentTypeEnum;
     name: string;
     readonly transformerConstructor: typeof TooltipSpecTransformer;
+    static readonly builtInTheme: {
+        tooltip: import("./interface").ITooltipTheme<string | import("../..").IColorKey>;
+    };
     static specKey: string;
     specKey: string;
     layoutType: 'none';
@@ -26,9 +29,10 @@ export declare class Tooltip extends BaseComponent<any> implements ITooltip {
     private _needInitEventOfTooltip?;
     private _enterable;
     private _isReleased;
+    private _isEnterTooltip;
     protected _spec: ITooltipSpec;
     tooltipHandler?: ITooltipHandler;
-    processor: ITooltipActiveTypeAsKeys<MarkTooltipProcessor, DimensionTooltipProcessor, GroupTooltipProcessor>;
+    processor: ITooltipActiveTypeAsKeys<ITooltipProcessor<MarkTooltipInfo>, ITooltipProcessor<DimensionTooltipInfo>, ITooltipProcessor<GroupTooltipInfo>>;
     private _alwaysShow;
     private _cacheInfo;
     private _cacheParams;
@@ -43,8 +47,7 @@ export declare class Tooltip extends BaseComponent<any> implements ITooltip {
     protected _getNeedClearVRenderComponents(): IGraphic[];
     protected _registerEvent(): void;
     protected _releaseEvent(): void;
-    onLayout(ctx: IModelLayoutOption): void;
-    onLayoutEnd(ctx: IModelLayoutOption): void;
+    onLayoutEnd(): void;
     onRender(ctx: IModelRenderOption): void;
     created(): void;
     release(): void;

package/types/component/util.d.ts

@@ -1,8 +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 getComponentThemeFromOption(type: string, getTheme: (...keys: string[]) => any): any;
 export declare function getFormatFunction(formatMethod?: any, formatter?: string | string[], text?: string | number, datum?: Datum): {
     formatFunc: any;
     args: (string | number | Datum)[];

package/types/constant/data.d.ts

@@ -20,3 +20,4 @@ export declare const MOSAIC_CAT_START_PERCENT: string;
 export declare const MOSAIC_CAT_END_PERCENT: string;
 export declare const SEGMENT_FIELD_START: string;
 export declare const SEGMENT_FIELD_END: string;
+export declare const DEFAULT_KEY: string;

package/types/constant/event.d.ts

@@ -1,4 +1,54 @@
-export { HOOK_EVENT as VGRAMMAR_HOOK_EVENT } from '@visactor/vgrammar-core';
+export declare enum HOOK_EVENT {
+    BEFORE_EVALUATE_DATA = "beforeEvaluateData",
+    AFTER_EVALUATE_DATA = "afterEvaluateData",
+    BEFORE_EVALUATE_SCALE = "beforeEvaluateScale",
+    AFTER_EVALUATE_SCALE = "afterEvaluateScale",
+    BEFORE_PARSE_VIEW = "beforeParseView",
+    AFTER_PARSE_VIEW = "afterParseView",
+    BEFORE_TRANSFORM = "beforeTransform",
+    AFTER_TRANSFORM = "afterTransform",
+    BEFORE_CREATE_VRENDER_STAGE = "beforeCreateVRenderStage",
+    AFTER_CREATE_VRENDER_STAGE = "afterCreateVRenderStage",
+    BEFORE_CREATE_VRENDER_LAYER = "beforeCreateVRenderLayer",
+    AFTER_CREATE_VRENDER_LAYER = "afterCreateVRenderLayer",
+    BEFORE_STAGE_RESIZE = "beforeStageResize",
+    AFTER_STAGE_RESIZE = "afterStageResize",
+    BEFORE_VRENDER_DRAW = "beforeVRenderDraw",
+    AFTER_VRENDER_DRAW = "afterVRenderDraw",
+    BEFORE_MARK_JOIN = "beforeMarkJoin",
+    AFTER_MARK_JOIN = "afterMarkJoin",
+    BEFORE_MARK_UPDATE = "beforeMarkUpdate",
+    AFTER_MARK_UPDATE = "afterMarkUpdate",
+    BEFORE_MARK_STATE = "beforeMarkState",
+    AFTER_MARK_STATE = "afterMarkState",
+    BEFORE_MARK_ENCODE = "beforeMarkEncode",
+    AFTER_MARK_ENCODE = "afterMarkEncode",
+    BEFORE_DO_LAYOUT = "beforeDoLayout",
+    AFTER_DO_LAYOUT = "afterDoLayout",
+    BEFORE_MARK_LAYOUT_END = "beforeMarkLayoutEnd",
+    AFTER_MARK_LAYOUT_END = "afterMarkLayoutEnd",
+    BEFORE_DO_RENDER = "beforeDoRender",
+    AFTER_DO_RENDER = "afterDoRender",
+    BEFORE_MARK_RENDER_END = "beforeMarkRenderEnd",
+    AFTER_MARK_RENDER_END = "afterMarkRenderEnd",
+    BEFORE_CREATE_VRENDER_MARK = "beforeCreateVRenderMark",
+    AFTER_CREATE_VRENDER_MARK = "afterCreateVRenderMark",
+    BEFORE_ADD_VRENDER_MARK = "beforeAddVRenderMark",
+    AFTER_ADD_VRENDER_MARK = "afterAddVRenderMark",
+    AFTER_VRENDER_NEXT_RENDER = "afterVRenderNextRender",
+    BEFORE_ELEMENT_UPDATE_DATA = "beforeElementUpdateData",
+    AFTER_ELEMENT_UPDATE_DATA = "afterElementUpdateData",
+    BEFORE_ELEMENT_STATE = "beforeElementState",
+    AFTER_ELEMENT_STATE = "afterElementState",
+    BEFORE_ELEMENT_ENCODE = "beforeElementEncode",
+    AFTER_ELEMENT_ENCODE = "afterElementEncode",
+    ANIMATION_START = "animationStart",
+    ANIMATION_END = "animationEnd",
+    ELEMENT_ANIMATION_START = "elementAnimationStart",
+    ELEMENT_ANIMATION_END = "elementAnimationEnd",
+    ALL_ANIMATION_START = "allAnimationStart",
+    ALL_ANIMATION_END = "allAnimationEnd"
+}
 export declare const BASE_EVENTS: string[];
 export declare enum ChartEvent {
     initialized = "initialized",
@@ -33,6 +83,7 @@ export declare enum ChartEvent {
     brushChange = "brushChange",
     brushEnd = "brushEnd",
     brushClear = "brushClear",
+    brushActive = "brushActive",
     legendSelectedDataChange = "legendSelectedDataChange",
     legendFilter = "legendFilter",
     legendItemClick = "legendItemClick",
@@ -43,7 +94,8 @@ export declare enum ChartEvent {
     tooltipRelease = "tooltipRelease",
     afterResize = "afterResize",
     afterRender = "afterRender",
-    afterLayout = "afterLayout"
+    afterLayout = "afterLayout",
+    afterMarkLayoutEnd = "afterMarkLayoutEnd"
 }
 export declare enum Event_Source_Type {
     chart = "chart",
@@ -56,3 +108,4 @@ export declare enum Event_Bubble_Level {
     model = "model",
     mark = "mark"
 }
+export declare const EventBubbleLevels: Event_Bubble_Level[];

package/types/core/factory.d.ts

@@ -6,13 +6,20 @@ import type { IRegion, IRegionConstructor } from '../region/interface';
 import type { IBaseModelSpecTransformer, IBaseModelSpecTransformerOption, IModelOption } from '../model/interface';
 import type { Transform, Parser } from '@visactor/vdataset';
 import type { ILayoutConstructor } from '../layout/interface';
-import type { MarkAnimationSpec } from '@visactor/vgrammar-core';
 import type { IChartPluginConstructor } from '../plugin/chart/interface';
 import type { IComponentPluginConstructor } from '../plugin/components/interface';
+import type { IGraphic } from '@visactor/vrender-core';
+import type { GrammarTransformOption, IStageEventPlugin, VRenderComponentOptions } from './interface';
+import type { MarkAnimationSpec } from '../animation/interface';
+import type { IBaseTriggerOptions, ITriggerConstructor } from '../interaction/interface/trigger';
+import type { IComposedEventConstructor } from '../index-harmony-simple';
+import type { ITooltipProcessorConstructor } from '../component/tooltip/processor/interface';
+import type { ITooltip } from '../component';
 export declare class Factory {
     private static _charts;
     private static _series;
     private static _components;
+    private static _graphicComponents;
     private static _marks;
     private static _regions;
     private static _animations;
@@ -31,16 +38,22 @@ export declare class Factory {
     };
     static registerChart(key: string, chart: IChartConstructor): void;
     static registerSeries(key: string, series: ISeriesConstructor): void;
-    static registerComponent(key: string, cmp: IComponentConstructor, alwaysCheck?: boolean): void;
+    static registerComponent(key: string, cmp: IComponentConstructor, alwaysCheck?: boolean, createOrder?: number): void;
+    static registerGraphicComponent(key: string, creator: (attrs: any, options?: VRenderComponentOptions) => IGraphic): void;
+    static createGraphicComponent(componentType: string, attrs: any, options?: VRenderComponentOptions): IGraphic<Partial<import("@visactor/vrender-core").IGraphicAttribute>>;
     static registerMark(key: string, mark: MarkConstructor): void;
     static registerRegion(key: string, region: IRegionConstructor): void;
     static registerTransform(key: string, transform: Transform): void;
+    private static _grammarTransforms;
+    static registerGrammarTransform(type: string, transform: GrammarTransformOption): void;
+    static getGrammarTransform(type: string): GrammarTransformOption;
     static registerLayout(key: string, layout: ILayoutConstructor): void;
     static registerAnimation(key: string, animation: (params?: any, preset?: any) => MarkAnimationSpec): void;
     static registerImplement(key: string, implement: (...args: any) => void): void;
     static registerChartPlugin(key: string, plugin: IChartPluginConstructor): void;
     static registerComponentPlugin(key: string, plugin: IComponentPluginConstructor): void;
     static createChart(chartType: string, spec: any, options: IChartOption): IChart | null;
+    static getChart(chartType: string): IChartConstructor;
     static createChartSpecTransformer(chartType: string, option: IChartSpecTransformerOption): IChartSpecTransformer | null;
     static createRegion(regionType: string, spec: any, options: IModelOption): IRegion | null;
     static createRegionSpecTransformer(regionType: string, options: IBaseModelSpecTransformerOption): IBaseModelSpecTransformer | null;
@@ -50,6 +63,7 @@ export declare class Factory {
     static getComponents(): {
         cmp: IComponentConstructor;
         alwaysCheck?: boolean;
+        createOrder: number;
     }[];
     static getComponentInKey(name: string): IComponentConstructor;
     static getLayout(): ILayoutConstructor[];
@@ -60,9 +74,24 @@ export declare class Factory {
     static getAnimationInKey(key: string): (params?: any, preset?: any) => MarkAnimationSpec;
     static getImplementInKey(key: string): (...args: any) => void;
     static getSeriesMarkMap(seriesType: string): Partial<Record<SeriesMarkNameEnum, ISeriesMarkInfo>>;
+    static getSeriesBuiltInTheme(themeKey: string): Record<string, any>;
+    static getComponentBuiltInTheme(themeKey: string): Record<string, any>;
     static getChartPlugins(): IChartPluginConstructor[];
     static getComponentPlugins(): IComponentPluginConstructor[];
     static getComponentPluginInType(type: string): IComponentPluginConstructor;
     static registerFormatter(func: typeof Factory['_formatter']): void;
     static getFormatter(): (text: string | number | string[] | number[], datum: any, formatter: string | string[]) => any;
+    private static _stageEventPlugins;
+    static registerStageEventPlugin: (type: string, Plugin: IStageEventPlugin<any>) => void;
+    static getStageEventPlugin: (type: string) => IStageEventPlugin<any>;
+    private static _interactionTriggers;
+    static registerInteractionTrigger: (interactionType: string, interaction: ITriggerConstructor) => void;
+    static createInteractionTrigger(interactionType: string, options?: IBaseTriggerOptions): import("../interaction/interface/trigger").ITrigger<IBaseTriggerOptions>;
+    static hasInteractionTrigger(interactionType: string): boolean;
+    private static _composedEventMap;
+    static registerComposedEvent: (eType: string, composedEvent: IComposedEventConstructor) => void;
+    static getComposedEvent(eType: string): IComposedEventConstructor;
+    private static _tooltipProcessors;
+    static registerTooltipProcessor: (type: string, processor: ITooltipProcessorConstructor) => void;
+    static createTooltipProcessor: (type: string, tooltip: ITooltip) => import("../component/tooltip/processor/interface").ITooltipProcessor<import("../component/tooltip/processor/interface").DimensionTooltipInfo> | import("../component/tooltip/processor/interface").ITooltipProcessor<import("../component/tooltip/processor/interface").MarkTooltipInfo<import("../index-harmony-simple").Datum>>;
 }

package/types/core/index.d.ts

@@ -5,13 +5,29 @@ export declare const version: string;
 export type { IVChart } from './interface';
 export type { IStateSpec, StateValueType } from '../compile/mark';
 export type { IRegion } from '../region/interface';
-export * from '../typings/spec/common';
 export * from '../event/interface';
 export * from '../theme/interface';
+export * from '../model/interface';
 export * from './interface';
+export * from '../typings';
+export type { IMarkGraphic, IGraphicContext } from '../mark/interface/';
 export * from '../constant/base';
 export * from '../constant/data';
+export * from '../constant/layout';
+export { AttributeLevel } from '../constant/attribute';
+export { TransformLevel } from '../data/initialize';
+export { STATE_VALUE_ENUM } from '../compile/mark/interface';
+export { ChartEvent } from '../constant/event';
 export * from '../typings/spec/index';
+export * from '../typings/visual';
 export * from '../typings/tooltip';
 export * from '../theme/index';
-export { vglobal } from '@visactor/vrender-core';
+export { vglobal, createGroup, createRichText, createText, createArc, createArea, createRect, createLine, createSymbol } from '@visactor/vrender-core';
+export { ManualTicker, StreamLight } from '@visactor/vrender-animate';
+export * from '../util/space';
+export { transformToGraphic } from '../util/style';
+export { getSpecInfo } from '../component/util';
+export { registerDataSetInstanceParser, registerDataSetInstanceTransform } from '../data/register';
+export { lookup } from '../data/transforms/lookup';
+export { warn } from '../util/debug';
+export { measureText } from '../util/text';

package/types/core/interface.d.ts

@@ -2,14 +2,14 @@ import type { DataSet, 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';
-import type { IMark } from '../mark/interface';
+import type { EventCallback, EventQuery, EventType, ExtendEventParam } from '../event/interface';
+import type { IMark, IMarkDataTransform } from '../mark/interface';
 import type { ISeries } from '../series/interface/series';
 import type { ITheme } from '../theme/interface';
 import type { IComponent } from '../component/interface';
 import type { LayoutCallBack } from '../layout/interface';
 import type { DimensionIndexOption, IChart, IChartSpecInfo } from '../chart/interface';
-import type { IStage } from '@visactor/vrender-core';
+import type { IEventTarget, IStage } from '@visactor/vrender-core';
 import type { IContainerSize } from '@visactor/vrender-components';
 import type { IBaseScale } from '@visactor/vscale';
 import type { IUpdateSpecResult } from '../model/interface';
@@ -53,8 +53,8 @@ export interface IVChart {
     updateViewBox: (viewBox: IBoundsLike, reRender?: boolean) => IVChart;
     resize: (width: number, height: number) => Promise<IVChart>;
     release: () => void;
-    on: ((eType: EventType, handler: EventCallback<EventParams>) => void) & ((eType: EventType, query: EventQuery, handler: EventCallback<EventParams>) => void);
-    off: (eType: EventType, handler?: EventCallback<EventParams>) => void;
+    on: ((eType: EventType, handler: EventCallback<ExtendEventParam>) => void) & ((eType: EventType, query: EventQuery, handler: EventCallback<ExtendEventParam>) => void);
+    off: (eType: EventType, handler?: EventCallback<ExtendEventParam>) => void;
     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;
@@ -123,3 +123,17 @@ export interface IVChartRenderOption {
     actionSource?: VChartRenderActionSource;
 }
 export type VChartRenderActionSource = 'render' | 'updateSpec' | 'updateModelSpec' | 'setCurrentTheme' | 'updateSpecAndRecompile';
+export interface VRenderComponentOptions {
+    skipDefault?: boolean;
+    mode?: '2d' | '3d';
+}
+export interface IStageEventPlugin<T> {
+    new (taget: IEventTarget, cfg?: T): {
+        release: () => void;
+    };
+}
+export interface GrammarTransformOption {
+    canProgressive?: boolean;
+    transform: IMarkDataTransform;
+    runType?: 'beforeJoin' | 'afterEncode';
+}

package/types/core/vchart.d.ts

@@ -5,7 +5,7 @@ import { RenderModeEnum } from '../typings/spec/common';
 import type { ISeriesConstructor } from '../series/interface';
 import { type DimensionIndexOption, type IChart, type IChartConstructor, type IChartOption, type IChartSpecInfo } from '../chart/interface';
 import type { IComponentConstructor } from '../component/interface';
-import type { EventCallback, EventParams, EventQuery, EventType } from '../event/interface';
+import type { EventCallback, EventQuery, EventType, ExtendEventParam } from '../event/interface';
 import type { IParserOptions, Transform } from '@visactor/vdataset';
 import { DataSet, DataView } from '@visactor/vdataset';
 import type { IStage } from '@visactor/vrender-core';
@@ -40,7 +40,6 @@ export declare class VChart implements IVChart {
     static getMap(key: string): GeoSourceType;
     static registerSVG(key: string, source: GeoSourceType, option?: GeoSourceOption): void;
     static unregisterSVG(key: string): void;
-    static getSVG(key: string): any;
     static hideTooltip(excludeId?: MaybeArray<number>): void;
     static getLogger(): ILogger;
     static readonly InstanceManager: typeof InstanceManager;
@@ -73,6 +72,7 @@ export declare class VChart implements IVChart {
     private _observer;
     private _currentThemeName;
     private _currentTheme;
+    private _cachedProcessedTheme;
     private _onError?;
     private _context;
     private _isReleased;
@@ -85,7 +85,7 @@ export declare class VChart implements IVChart {
     private _updateSpecInfo;
     private _initChart;
     private _releaseData;
-    private _bindVGrammarViewEvent;
+    private _bindViewEvent;
     private _bindResizeEvent;
     private _unBindResizeEvent;
     getCurrentSize(): {
@@ -133,9 +133,9 @@ export declare class VChart implements IVChart {
     protected _beforeResize(width: number, height: number): boolean;
     protected _afterResize(): IVChart;
     updateViewBox(viewBox: IBoundsLike, reRender?: boolean, reLayout?: boolean): IVChart;
-    on(eType: EventType, handler: EventCallback<EventParams>): void;
-    on(eType: EventType, query: EventQuery, handler: EventCallback<EventParams>): void;
-    off(eType: EventType, handler?: EventCallback<EventParams>): void;
+    on(eType: EventType, handler: EventCallback<ExtendEventParam>): void;
+    on(eType: EventType, query: EventQuery, handler: EventCallback<ExtendEventParam>): void;
+    off(eType: EventType, handler?: EventCallback<ExtendEventParam>): void;
     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;
@@ -205,7 +205,8 @@ export declare class VChart implements IVChart {
     }): void;
     private _initChartPlugin;
     private _chartPluginApply;
-    protected _getMode(): "node" | (typeof RenderModeEnum)["desktop-browser"] | "desktop-browser" | "mobile-browser" | "worker" | "miniApp" | "wx" | "tt" | "harmony" | "desktop-miniApp" | "lynx";
+    protected _getMode(): (typeof RenderModeEnum)["desktop-browser"] | "desktop-browser" | "mobile-browser" | "node" | "worker" | "miniApp" | "wx" | "tt" | "harmony" | "desktop-miniApp" | "lynx";
+    protected getTheme: (...keys: string[]) => any;
     protected _getChartOption(type: string): IChartOption;
 }
 export declare const registerVChartCore: () => void;

package/types/data/transforms/circle-packing.d.ts

@@ -1,5 +1,5 @@
 import type { Datum } from '../../typings';
-import type { CirclePackingOptions } from '@visactor/vgrammar-hierarchy';
+import type { CirclePackingOptions } from '@visactor/vlayouts';
 export interface ICirclePackingOpt extends CirclePackingOptions {
     width: number;
     height: number;

package/types/data/transforms/data-key.d.ts

@@ -7,7 +7,7 @@ export declare function initKeyMap(this: BaseSeries<any>): {
     keyMap: Map<any, any>;
     needDefaultSeriesField: boolean;
     defaultSeriesField: string;
-    getKey: (datum: import("../../typings").Datum, index: number, context: AddVChartPropertyContext) => unknown;
+    getKey: (datum: import("../..").Datum, index: number, context: AddVChartPropertyContext) => unknown;
 };
 export declare function addDataKey(d: any, i: number, context: AddVChartPropertyContext): void;
 export declare function initHierarchyKeyMap(this: TreemapSeries | SunburstSeries | CirclePackingSeries): {

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

@@ -1,5 +1,5 @@
 import type { Datum } from '../../typings';
-import type { TreemapNodeElement, SunburstNodeElement } from '@visactor/vgrammar-hierarchy';
+import type { TreemapNodeElement, SunburstNodeElement } from '@visactor/vlayouts';
 export type FlattenNodeElement = TreemapNodeElement | SunburstNodeElement;
 export interface IFlattenOpt {
     output?: Datum[];

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

@@ -32,17 +32,12 @@ export declare const funnel: (originData: Array<DataView>, op: IFunnelOpt) => {
     historyData: any[];
     parserData: any;
     latestData: any;
-    _diffMap: Map<string, any>;
-    _diffRank: number;
     latestDataAUD: {
         add: any;
         update: any;
         del: any;
     };
-    reRunAllTransform: (opt?: {
-        pushHistory: boolean;
-        emitMessage: boolean;
-    }) => DataView;
+    reRunAllTransform: (opt?: import("@visactor/vdataset/es/data-view").DataViewTransformOptions) => DataView;
     markRunning: () => void;
 }[];
 export interface IFunnelTransformOpt {

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

@@ -1,14 +1,6 @@
 import type { DataView } from '@visactor/vdataset';
 export declare const graphicAttributeTransform: {
-    group: (attributes: Record<string, any>) => {
-        visibleAll: boolean;
-        x: number;
-        y: number;
-        fillStrokeOrder: boolean;
-        fill: any;
-        lineWidth: number;
-        stroke: any;
-    };
+    group: (attributes: Record<string, any>) => any;
     rule: (attributes: Record<string, any>) => {
         x: number;
         y: number;
@@ -50,9 +42,9 @@ export declare const graphicAttributeTransform: {
     path: (attributes: Record<string, any>) => {
         path: any;
         fillStrokeOrder: boolean;
+        fill: any;
         x: number;
         y: number;
-        fill: any;
         lineWidth: number;
         stroke: any;
     };

package/types/data/transforms/sankey-links.d.ts

@@ -1,2 +1 @@
-import type { SankeyData } from '@visactor/vgrammar-sankey';
-export declare const sankeyLinks: (data: SankeyData) => any;
+export declare const sankeyLinks: (data: any) => any;

package/types/data/transforms/sankey-nodes.d.ts

@@ -1,2 +1 @@
-import type { SankeyData } from '@visactor/vgrammar-sankey';
-export declare const sankeyNodes: (data: SankeyData) => any;
+export declare const sankeyNodes: (data: any) => any;

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

@@ -1,4 +1,4 @@
-import type { SankeyOptions, SankeyData } from '@visactor/vgrammar-sankey';
+import type { SankeyOptions, SankeyData } from '@visactor/vlayouts';
 export interface ISankeyOpt extends SankeyOptions {
     targetField: string;
     sourceField: string;
@@ -13,7 +13,7 @@ export interface ISankeyOpt extends SankeyOptions {
 export declare const collectHierarchyField: (set: Set<any>, data: any[], field: string) => void;
 export declare const sankeyFormat: (data: any[]) => SankeyData[];
 export declare const sankeyLayout: (data: SankeyData[], op: ISankeyOpt) => {
-    nodes: import("@visactor/vgrammar-sankey").SankeyNodeElement[];
-    links: import("@visactor/vgrammar-sankey").SankeyLinkElement[];
-    columns: import("@visactor/vgrammar-sankey").SankeyNodeElement[][];
+    nodes: import("@visactor/vlayouts").SankeyNodeElement[];
+    links: import("@visactor/vlayouts").SankeyLinkElement[];
+    columns: import("@visactor/vlayouts").SankeyNodeElement[][];
 }[];

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

@@ -1,4 +1,4 @@
-import type { SunburstOptions } from '@visactor/vgrammar-hierarchy';
+import type { SunburstOptions } from '@visactor/vlayouts';
 import type { Datum } from '../../typings';
 export interface ISunburstOpt extends SunburstOptions {
     width: number;

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

@@ -1,11 +1,10 @@
-import type { TreemapOptions } from '@visactor/vgrammar-hierarchy';
-import type { Datum } from '../../typings';
-export interface ITreemapOpt extends TreemapOptions {
-    range: () => {
+import type { TreemapNodeElement, TreemapOptions } from '@visactor/vlayouts';
+export declare const treemapLayout: (data: Array<any>, op: TreemapOptions & {
+    getViewBox: () => {
         x0: number;
         x1: number;
         y0: number;
         y1: number;
     };
-}
-export declare const treemap: (data: Array<Datum>, op: ITreemapOpt) => Datum[];
+    nameField: string;
+}) => TreemapNodeElement[];

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

@@ -0,0 +1,10 @@
+export declare const vennLayout: (data: Array<any>, op: {
+    setField: string;
+    valueField: string;
+    getViewBox: () => {
+        x0: number;
+        x1: number;
+        y0: number;
+        y1: number;
+    };
+}) => (import("@visactor/vlayouts").IVennCircleDatum<any> | import("@visactor/vlayouts").IVennOverlapDatum<any>)[];

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

@@ -13,6 +13,7 @@ export interface IWaterfallOpt {
         increase: string;
         decrease: string;
     };
+    stackInverse: boolean;
     groupData: () => DataView;
 }
 export declare const waterfall: (lastData: Array<Datum>, op: IWaterfallOpt) => Datum[];

package/types/event/event-dispatcher.d.ts

@@ -14,7 +14,10 @@ export declare class EventDispatcher implements IEventDispatcher {
     register<Evt extends EventType>(eType: Evt, handler: EventHandler<EventParamsDefinition[Evt]>): this;
     unregister<Evt extends EventType>(eType: Evt, handler?: EventHandler<EventParamsDefinition[Evt]>): this;
     dispatch<Evt extends EventType>(eType: Evt, params: EventParamsDefinition[Evt], level?: EventBubbleLevel): this;
-    prevent<Evt extends EventType>(eType: Evt, except?: EventCallback<EventParams>): this;
+    prevent<Evt extends EventType>(eType: Evt, except?: {
+        handler: EventCallback<EventParams>;
+        level: EventBubbleLevel;
+    }): this;
     allow<Evt extends EventType>(eType: Evt): this;
     clear(): void;
     release(): void;

package/types/event/event.d.ts

@@ -14,7 +14,10 @@ export declare class Event implements IEvent {
     off<Evt extends EventType>(eType: Evt, callback?: EventCallback<EventParamsDefinition[Evt]>): this;
     off<Evt extends EventType>(eType: Evt, query: EventQuery, callback: EventCallback<EventParamsDefinition[Evt]>): this;
     emit<Evt extends EventType>(eType: Evt, params: EventParamsDefinition[Evt], level?: EventBubbleLevel): this;
-    prevent<Evt extends EventType>(eType: Evt, except?: EventCallback<EventParamsDefinition[Evt]>): this;
+    prevent<Evt extends EventType>(eType: Evt, except?: {
+        handler: EventCallback<EventParamsDefinition[Evt]>;
+        level: EventBubbleLevel;
+    }): this;
     allow<Evt extends EventType>(eType: Evt): this;
     release(): void;
 }