@visactor/vchart-types 1.13.7-alpha.0 → 2.0.0-alpha.0

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",
@@ -43,7 +93,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",

package/types/core/factory.d.ts

@@ -1,18 +1,22 @@
 import type { IChartConstructor, IChartOption, IChart, IChartSpecTransformerOption, IChartSpecTransformer } from '../chart/interface';
 import type { ISeriesConstructor, ISeriesMarkInfo, ISeriesOption, SeriesMarkNameEnum } from '../series/interface';
 import type { IComponentConstructor } from '../component/interface';
-import type { IMarkOption, MarkConstructor } from '../mark/interface';
+import type { IMarkDataTransform, IMarkOption, MarkConstructor } from '../mark/interface';
 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 { IStageEventPlugin, VRenderComponentOptions } from './interface';
+import type { MarkAnimationSpec } from '../animation/interface';
+import type { IBaseTriggerOptions, ITriggerConstructor } from '../interaction/interface/trigger';
 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,10 +35,23 @@ 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: {
+        canProgressive?: boolean;
+        transform: IMarkDataTransform;
+        isGraphic?: boolean;
+    }): void;
+    static getGrammarTransform(type: string): {
+        canProgressive?: boolean;
+        transform: IMarkDataTransform<any, any, any>;
+        isGraphic?: boolean;
+    };
     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;
@@ -50,6 +67,7 @@ export declare class Factory {
     static getComponents(): {
         cmp: IComponentConstructor;
         alwaysCheck?: boolean;
+        createOrder: number;
     }[];
     static getComponentInKey(name: string): IComponentConstructor;
     static getLayout(): ILayoutConstructor[];
@@ -65,4 +83,11 @@ export declare class Factory {
     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;
 }

package/types/core/index.d.ts

@@ -9,6 +9,7 @@ export * from '../typings/spec/common';
 export * from '../event/interface';
 export * from '../theme/interface';
 export * from './interface';
+export type { IMarkGraphic, IGraphicContext } from '../mark/interface/';
 export * from '../constant/base';
 export * from '../constant/data';
 export * from '../typings/spec/index';

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 { EventCallback, EventQuery, EventType, ExtendEventParam } from '../event/interface';
 import type { IMark } 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,12 @@ 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;
+    };
+}

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';
@@ -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,7 @@ 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 _getChartOption(type: string): IChartOption;
 }
 export declare const registerVChartCore: () => void;

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/vgrammar-hierarchy';
+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/vgrammar-venn").IVennCircleDatum<any> | import("@visactor/vgrammar-venn").IVennOverlapDatum<any>)[];

package/types/event/events/base.d.ts

@@ -1,6 +1,5 @@
-import type { ValueOf } from '@visactor/vgrammar-core';
 import type { EventHandler, EventParamsDefinition, EventType, IComposedEvent, IEventDispatcher } from '../interface';
-import type { Maybe, RenderMode } from '../../typings';
+import type { Maybe, RenderMode, ValueOf } from '../../typings';
 import type { IChart } from '../../chart/interface';
 export declare abstract class ComposedEvent implements IComposedEvent {
     protected _eventMap: Map<string, EventHandler<ValueOf<EventParamsDefinition>>>;

package/types/event/interface.d.ts

@@ -1,16 +1,15 @@
 import type { IGraphic } from '@visactor/vrender-core';
-import type { IElement } from '@visactor/vgrammar-core';
 import type { IChart } from '../chart/interface';
 import type { IModel } from '../model/interface';
-import type { IMark, MarkType } from '../mark/interface';
+import type { IMark, IMarkGraphic, MarkType } from '../mark/interface';
 import type { DimensionEventParams } from './events/dimension/interface';
 import type { Datum, IPoint, StringOrNumber } from '../typings';
-import type { ChartEvent, Event_Bubble_Level, Event_Source_Type, VGRAMMAR_HOOK_EVENT } from '../constant/event';
+import type { ChartEvent, Event_Bubble_Level, Event_Source_Type, HOOK_EVENT } from '../constant/event';
 import type { SeriesType } from '../series/interface';
 import type { TooltipEventParams } from '../component/tooltip/interface/event';
 import type { ILayoutItem } from '../layout/interface';
 import type { IVChart } from '../core/interface';
-export type EventType = 'pointerdown' | 'pointerup' | 'pointerupoutside' | 'pointertap' | 'pointerover' | 'pointermove' | 'pointerenter' | 'pointerleave' | 'pointerout' | 'mousedown' | 'mouseup' | 'mouseupoutside' | 'rightdown' | 'rightup' | 'rightupoutside' | 'click' | 'dblclick' | 'mousemove' | 'mouseover' | 'mouseout' | 'mouseenter' | 'mouseleave' | 'wheel' | 'touchstart' | 'touchend' | 'touchendoutside' | 'touchmove' | 'touchcancel' | 'tap' | 'dragstart' | 'drag' | 'dragenter' | 'dragleave' | 'dragover' | 'dragend' | 'drop' | 'pan' | 'panstart' | 'panend' | 'press' | 'pressup' | 'pressend' | 'pinch' | 'pinchstart' | 'pinchend' | 'swipe' | keyof typeof ChartEvent | keyof typeof VGRAMMAR_HOOK_EVENT | string;
+export type EventType = 'pointerdown' | 'pointerup' | 'pointerupoutside' | 'pointertap' | 'pointerover' | 'pointermove' | 'pointerenter' | 'pointerleave' | 'pointerout' | 'mousedown' | 'mouseup' | 'mouseupoutside' | 'rightdown' | 'rightup' | 'rightupoutside' | 'click' | 'dblclick' | 'mousemove' | 'mouseover' | 'mouseout' | 'mouseenter' | 'mouseleave' | 'wheel' | 'touchstart' | 'touchend' | 'touchendoutside' | 'touchmove' | 'touchcancel' | 'tap' | 'dragstart' | 'drag' | 'dragenter' | 'dragleave' | 'dragover' | 'dragend' | 'drop' | 'pan' | 'panstart' | 'panend' | 'press' | 'pressup' | 'pressend' | 'pinch' | 'pinchstart' | 'pinchend' | 'swipe' | keyof typeof ChartEvent | keyof typeof HOOK_EVENT | string;
 export type EventBubbleLevel = keyof typeof Event_Bubble_Level;
 export type ComponentType = 'axis' | 'dataZoom' | 'indicator' | 'legend' | 'mapLabel' | 'markLine' | 'markArea' | 'markPoint' | 'tooltip' | 'title' | 'label' | 'totalLabel' | 'customMark';
 export type EventTargetType = MarkType | ComponentType | SeriesType;
@@ -42,10 +41,9 @@ type SuperEvent = Event & {
 };
 export type BaseEventParams = EventParams & {
     event: SuperEvent;
-    item: IElement;
+    item: IMarkGraphic;
     datum: Datum;
     source: EventSourceType;
-    itemMap: Map<string, any>;
 };
 export type EventCallback<Params extends EventParams> = (params: Params) => boolean | void;
 export type EventFilter = {
@@ -66,10 +64,9 @@ export type EventHandler<Params extends EventParams> = {
 };
 export type ExtendEventParam = EventParams & {
     event?: Event;
-    item?: any;
+    item?: IMarkGraphic;
     datum?: Datum;
     source?: EventSourceType;
-    itemMap?: Map<string, any>;
 };
 export type LayoutEventParam = {
     elements: (ILayoutItem & {
@@ -84,7 +81,7 @@ export type ZoomEventParam = ExtendEventParam & {
     scaleCenter: IPoint;
 };
 export type InteractionEventParam = {
-    items?: IElement[];
+    graphics?: IMarkGraphic[];
     datums?: Datum[];
 } & Partial<BaseEventParams>;
 export type EventParamsDefinition = {

package/types/index-harmony-simple.d.ts

@@ -37,9 +37,10 @@ import { registerCustomMark } from './component/custom-mark';
 import { registerMapLabel } from './component/map-label';
 import { registerGridLayout } from './layout/grid-layout/grid-layout';
 import { registerPoptip } from './component/poptip';
-import { registerElementHighlight, registerElementSelect } from '@visactor/vgrammar-core';
 import { DefaultTicker } from '@visactor/vrender-core';
 import { registerAnimate } from './plugin/other';
+import { registerElementSelect } from './interaction/triggers/element-select';
+import { registerElementHighlight } from './interaction/triggers/element-highlight';
 export { VChart, DefaultTicker, registerAnimate };
 export { registerScatterChart, registerRoseChart, registerRadarChart, registerHistogramChart, registerMapChart, registerGaugeChart, registerWordCloudChart, registerFunnelChart, registerWaterfallChart, registerBoxplotChart, registerCircularProgressChart, registerLinearProgressChart, registerRangeColumnChart, registerRangeAreaChart, registerSunburstChart, registerCirclePackingChart, registerTreemapChart, registerSankeyChart, registerHeatmapChart, registerCorrelationChart, registerCartesianTimeAxis, registerCartesianLogAxis, registerCartesianSymlogAxis, registerPolarBandAxis, registerPolarLinearAxis, registerContinuousLegend, registerPolarCrossHair, registerDataZoom, registerScrollBar, registerIndicator, registerGeoCoordinate, registerMarkLine, registerMarkArea, registerMarkPoint, registerPolarMarkLine, registerPolarMarkArea, registerPolarMarkPoint, registerGeoMarkPoint, registerTitle, registerPlayer, registerTotalLabel, registerBrush, registerCustomMark, registerMapLabel, registerPoptip, registerGridLayout, registerElementHighlight, registerElementSelect };
 export default VChart;

package/types/index.d.ts

@@ -13,6 +13,3 @@ export * from './plugin/chart';
 export * from './plugin/components/tooltip-handler';
 export * from './plugin/components/axis-sync';
 export * from './plugin/other';
-export * from './vrender-tools';
-export * from './util/data';
-export * from './util/spec/transform';

package/types/interaction/config.d.ts

@@ -1,4 +1,5 @@
 import type { RenderMode } from '../typings/spec/common';
+import type { IHoverSpec, ISelectSpec } from './interface/spec';
 export declare function getDefaultInteractionConfigByMode(mode: RenderMode): {
     hover: {
         enable: boolean;
@@ -20,3 +21,15 @@ export declare function getDefaultInteractionConfigByMode(mode: RenderMode): {
         trigger: string;
     };
 };
+export declare const parseHoverSelect: (mode: RenderMode, hoverSpec: IHoverSpec, selectSpec: ISelectSpec) => {
+    select: ISelectSpec;
+    hover: {
+        enable: boolean;
+        trigger: string;
+        triggerOff: string;
+    } | {
+        enable: boolean;
+        trigger: string[];
+        triggerOff: string;
+    };
+};

package/types/interaction/index.d.ts

@@ -1 +1,9 @@
-export { registerElementActive, registerElementHighlight, registerElementSelect, registerElementActiveByLegend, registerElementHighlightByLegend, registerElementHighlightByName, registerElementHighlightByGroup, registerElementHighlightByKey } from '@visactor/vgrammar-core';
+export { registerElementHighlight } from './triggers/element-highlight';
+export { registerElementSelect } from './triggers/element-select';
+export { registerDimensionHover } from './triggers/dimension-hover';
+export { registerElementActive } from './triggers/element-active';
+export { registerElementActiveByLegend } from './triggers/element-active-by-legend';
+export { registerElementHighlightByGroup } from './triggers/element-highlight-by-group';
+export { registerElementHighlightByKey } from './triggers/element-highlight-by-key';
+export { registerElementHighlightByLegend } from './triggers/element-highlight-by-legend';
+export { registerElementHighlightByName } from './triggers/element-highlight-by-name';

package/types/interaction/interaction.d.ts

@@ -1,29 +1,21 @@
-import type { StateValue } from '../compile/mark';
-import type { IElement } from '@visactor/vgrammar-core';
-import type { BaseEventParams } from '../event/interface';
-import type { IMark } from '../mark/interface';
-import type { IInteraction } from './interface';
-import type { IInteraction as IVGrammarInteraction } from '@visactor/vgrammar-core';
+import type { IMarkGraphic } from '../mark/interface';
+import type { IInteraction } from './interface/common';
+import type { ITrigger } from './interface/trigger';
 export declare class Interaction implements IInteraction {
-    private _stateMarks;
-    private _stateElements;
-    private _vgrammarInteractions;
-    addVgrammarInteraction(state: StateValue, i: IVGrammarInteraction): void;
-    static markStateEnable(mark: IMark, state: string): boolean;
+    private _stateGraphicsByTrigger;
     private _disableTriggerEvent;
     setDisableActiveEffect(disable: boolean): void;
-    registerMark(state: StateValue, mark: IMark): void;
-    getStateMark(state: StateValue): IMark[] | null;
-    filterEventMark(params: BaseEventParams, state: StateValue): boolean;
-    getEventElement(stateValue: StateValue): IElement[];
-    getEventElementData(stateValue: StateValue): any[];
-    exchangeEventElement(stateValue: StateValue, element: IElement): void;
-    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;
+    private _triggerMapByState;
+    addTrigger(trigger: ITrigger): void;
+    setStatedGraphics(trigger: ITrigger, graphics: IMarkGraphic[]): void;
+    getStatedGraphics(trigger: ITrigger): IMarkGraphic[];
+    updateStates(trigger: ITrigger, newStatedGraphics: IMarkGraphic[], prevStatedGraphics?: IMarkGraphic[], state?: string, reverseState?: string): IMarkGraphic[];
+    protected toggleReverseStateOfGraphics(trigger: ITrigger, newStatedGraphics: IMarkGraphic[], prevStatedGraphics: IMarkGraphic[], reverseState: string): void;
+    protected toggleStateOfGraphics(trigger: ITrigger, newStatedGraphics: IMarkGraphic[], prevStatedGraphics: IMarkGraphic[], state: string): void;
+    protected addBothStateOfGraphics(trigger: ITrigger, statedGraphics: IMarkGraphic[], state: string, reverseState: string): void;
+    protected addStateOfGraphics(trigger: ITrigger, statedGraphics: IMarkGraphic[], state: string): void;
+    clearAllStatesOfTrigger(trigger: ITrigger, state?: string, reverseState?: string): void;
+    clearAllStates(): void;
+    clearByState(stateValue: string): void;
+    updateStateOfGraphics(stateValue: string, markGraphics: IMarkGraphic[]): void;
 }

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

@@ -0,0 +1,22 @@
+import type { IMarkGraphic } from '../../mark/interface';
+import type { RenderMode } from '../../typings/spec/common';
+import type { IEventDispatcher } from '../../event/interface';
+import type { IModel } from '../../model/interface';
+import type { ITrigger } from './trigger';
+export interface IInteraction {
+    setDisableActiveEffect: (disable: boolean) => void;
+    addTrigger: (trigger: ITrigger) => void;
+    setStatedGraphics: (trigger: ITrigger, graphics: IMarkGraphic[]) => void;
+    getStatedGraphics: (trigger: ITrigger) => IMarkGraphic[];
+    updateStates: (trigger: ITrigger, newStatedGraphics: IMarkGraphic[], prevStatedGraphics?: IMarkGraphic[], state?: string, reverseState?: string) => IMarkGraphic[];
+    clearAllStates: () => void;
+    clearAllStatesOfTrigger: (trigger: ITrigger, state?: string, reverseState?: string) => void;
+    clearByState: (stateValue: string) => any;
+    updateStateOfGraphics: (stateValue: string, markGraphics: IMarkGraphic[]) => void;
+}
+export interface ITriggerOption {
+    mode: RenderMode;
+    interaction: IInteraction;
+    eventDispatcher: IEventDispatcher;
+    model: IModel;
+}

package/types/interaction/interface/spec.d.ts

@@ -0,0 +1,53 @@
+import type { EventType } from '../../event/interface';
+import type { StringOrNumber } from '../../typings/common';
+import type { IElementActiveByLegendOptions, IElementActiveOptions, IElementHighlightByLegendOptions, IElementHighlightByNameOptions, IElementHighlightOptions, IElementSelectOptions } from './trigger';
+export interface IBaseInteractionSpec {
+    markIds?: StringOrNumber[];
+    markNames?: StringOrNumber[];
+}
+type Trigger = EventType | EventType[];
+export interface IHoverSpec extends IBaseInteractionSpec {
+    enable?: boolean;
+    trigger?: Trigger;
+    triggerOff?: Trigger;
+}
+export interface ISelectSpec extends IBaseInteractionSpec {
+    enable?: boolean;
+    mode?: 'single' | 'multiple';
+    trigger?: Trigger;
+    triggerOff?: Trigger | number;
+}
+export type IElementActiveSpec = IBaseInteractionSpec & Pick<IElementActiveOptions, 'trigger' | 'triggerOff' | 'state'> & {
+    type: 'element-active';
+};
+export type IElementSelectSpec = IBaseInteractionSpec & Pick<IElementSelectOptions, 'trigger' | 'triggerOff' | 'state' | 'isMultiple' | 'reverseState'> & {
+    type: 'element-select';
+};
+export type IElementHighlightSpec = IBaseInteractionSpec & Pick<IElementHighlightOptions, 'blurState' | 'highlightState' | 'triggerOff' | 'trigger'> & {
+    type: 'element-highlight';
+};
+export type IElementHighlightByKeySpec = IBaseInteractionSpec & Pick<IElementHighlightOptions, 'blurState' | 'highlightState' | 'triggerOff' | 'trigger'> & {
+    type: 'element-highlight-by-key';
+};
+export type IElementHighlightByGroup = IBaseInteractionSpec & Pick<IElementHighlightOptions, 'blurState' | 'highlightState' | 'triggerOff' | 'trigger'> & {
+    type: 'element-highlight-by-group';
+};
+export type IElementActiveByLegend = IBaseInteractionSpec & Pick<IElementActiveByLegendOptions, 'filterType' | 'state'> & {
+    type: 'element-active-by-legend';
+};
+export type IElementHighlightByLegend = IBaseInteractionSpec & Pick<IElementHighlightByLegendOptions, 'filterType' | 'blurState' | 'highlightState'> & {
+    type: 'element-highlight-by-legend';
+};
+export type IElementHighlightByName = IBaseInteractionSpec & Pick<IElementHighlightByNameOptions, 'blurState' | 'highlightState' | 'graphicName' | 'parseData'> & {
+    type: 'element-highlight-by-name';
+};
+export interface ICustomInteraction extends IBaseInteractionSpec {
+    type: string;
+}
+export type IInteractionItemSpec = IElementActiveSpec | IElementSelectSpec | IElementHighlightSpec | IElementHighlightByKeySpec | IElementHighlightByGroup | IElementActiveByLegend | IElementHighlightByLegend | IElementHighlightByName | ICustomInteraction;
+export interface IInteractionSpec {
+    hover?: IHoverSpec | boolean;
+    select?: ISelectSpec | boolean;
+    interactions?: IInteractionItemSpec[];
+}
+export {};

package/types/interaction/interface/trigger.d.ts

@@ -0,0 +1,87 @@
+import type { GraphicEventType } from '@visactor/vrender-core';
+import type { IMark, IMarkGraphic } from '../../mark/interface/common';
+import type { RenderMode } from '../../typings/spec/common';
+import type { IInteraction } from './common';
+import type { BaseEventParams } from '../../event/interface';
+export type ITriggerEventHandler = (e: any, markGraphic?: IMarkGraphic) => void;
+export interface ITrigger<TriggerOptions extends IBaseTriggerOptions = any> {
+    readonly options: TriggerOptions;
+    readonly type: string;
+    registerMark: (mark: IMark | IMark[]) => void;
+    release: () => void;
+    init: () => void;
+    start: (g: any) => void;
+    reset: (g?: IMarkGraphic) => void;
+    getStartState: () => string;
+    getResetState: () => string;
+    updateMarkIdByState: (states: string[]) => void;
+    getMarkIdByState: () => Record<string, number[]>;
+    getMarks: () => IMark[];
+    getMarksByState: (state: string) => IMark[];
+}
+export interface IBaseTriggerOptions {
+    type?: string;
+    marks?: IMark[];
+    mode?: RenderMode;
+    event: {
+        on: (eType: string, callback: ITriggerEventHandler) => void;
+        off: (eType: string, callback?: ITriggerEventHandler) => void;
+        emit: (eType: string, params: any) => void;
+    };
+    interaction: IInteraction;
+    id?: string;
+    shouldStart?: (e: any) => boolean;
+    shouldUpdate?: (e: any) => boolean;
+    shouldEnd?: (e: any) => boolean;
+    shouldReset?: (e: any) => boolean;
+    onStart?: (e: any) => boolean;
+    onUpdate?: (e: any) => boolean;
+    onEnd?: (e: any) => boolean;
+    onReset?: (e: any) => boolean;
+}
+export type IElementSelectTriggerOff = GraphicEventType | string | 'empty' | 'none' | number;
+export interface IElementSelectOptions extends IBaseTriggerOptions {
+    trigger?: GraphicEventType | GraphicEventType[];
+    state?: string;
+    reverseState?: string;
+    triggerOff?: IElementSelectTriggerOff | IElementSelectTriggerOff[];
+    isMultiple?: boolean;
+}
+export interface IDimensionHoverOptions extends IBaseTriggerOptions {
+    state?: string;
+    reverseState?: string;
+    trigger?: string;
+}
+export interface IElementActiveOptions extends IBaseTriggerOptions {
+    trigger?: GraphicEventType | GraphicEventType[];
+    triggerOff?: GraphicEventType | GraphicEventType[] | 'none';
+    state?: string;
+}
+export interface IElementHighlightOptions extends IBaseTriggerOptions {
+    trigger?: GraphicEventType;
+    triggerOff?: GraphicEventType | 'none';
+    highlightState?: string;
+    blurState?: string;
+}
+export interface IElementFilterOptions {
+    filterType?: 'key' | 'groupKey';
+    filterField?: string;
+}
+export interface IElementActiveByLegendOptions extends IBaseTriggerOptions, IElementFilterOptions {
+    state?: string;
+}
+export interface IElementHighlightByLegendOptions extends IBaseTriggerOptions, IElementFilterOptions {
+    highlightState?: string;
+    blurState?: string;
+}
+export interface IElementHighlightByNameOptions extends IElementHighlightByLegendOptions {
+    graphicName?: string | string[];
+    trigger?: GraphicEventType;
+    triggerOff?: GraphicEventType | 'none';
+    parseData?: (e: BaseEventParams) => any;
+}
+export type IElementHighlightByGraphicNameOptions = IElementHighlightOptions;
+export interface ITriggerConstructor<T extends IBaseTriggerOptions = IBaseTriggerOptions> {
+    readonly type: string;
+    new (options?: T): ITrigger<T>;
+}

package/types/interaction/triggers/base.d.ts

@@ -0,0 +1,28 @@
+import type { IBaseTriggerOptions, ITrigger, ITriggerEventHandler } from '../interface/trigger';
+import type { IMark, IMarkGraphic } from '../../mark/interface/common';
+import { MarkSet } from '../../mark/mark-set';
+export declare abstract class BaseTrigger<T extends IBaseTriggerOptions> implements ITrigger<T> {
+    options: T;
+    type: string;
+    protected _markSet: MarkSet;
+    protected _markIdByState: Record<string, number[]>;
+    constructor(options: T);
+    getMarks(): IMark[];
+    getMarksByState(state: string): IMark[];
+    registerMark(mark: IMark | IMark[]): void;
+    updateMarkIdByState(states: string[]): void;
+    getMarkIdByState(): Record<string, number[]>;
+    isGraphicInStateMark(g: IMarkGraphic, state: string): boolean;
+    isGraphicInMark(g: IMarkGraphic): boolean;
+    protected abstract getEvents(): Array<{
+        type: string | string[];
+        handler: ITriggerEventHandler;
+    }>;
+    getStartState(): string;
+    getResetState(): string;
+    init(): void;
+    release(): void;
+    start(g: IMarkGraphic | string): void;
+    reset(g?: IMarkGraphic): void;
+    protected dispatchEvent(type: 'start' | 'reset' | 'update' | 'end', params: any): void;
+}