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

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

@@ -1,2 +1,3 @@
 export * from './event';
 export * from './events';
+export { getCartesianDimensionInfo, getPolarDimensionInfo } from './events/dimension/util';

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

@@ -3,7 +3,6 @@ export default VChart;
 export * from './core';
 export * from './chart';
 export * from './chart/base';
-export * from './chart/common';
 export * from './series';
 export * from './mark';
 export * from './component';

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;
+}

package/types/interaction/triggers/dimension-hover.d.ts

@@ -0,0 +1,22 @@
+import type { DimensionEventParams } from '../../event/events/dimension/interface';
+import type { IMarkGraphic } from '../../mark/interface';
+import type { IDimensionHoverOptions, ITrigger } from '../interface/trigger';
+import { BaseTrigger } from './base';
+export declare class DimensionHover extends BaseTrigger<IDimensionHoverOptions> implements ITrigger<IDimensionHoverOptions> {
+    static type: string;
+    type: string;
+    static defaultOptions: Partial<IDimensionHoverOptions>;
+    protected _resetType: ('view' | 'self' | 'timeout')[];
+    protected _statedGraphics?: IMarkGraphic[];
+    constructor(options?: IDimensionHoverOptions);
+    getStartState(): string;
+    getResetState(): string;
+    protected getEvents(): {
+        type: string;
+        handler: (params: DimensionEventParams) => void;
+    }[];
+    resetAll: () => void;
+    protected getStatedGraphics(params: DimensionEventParams, reverse?: boolean): IMarkGraphic[];
+    handleStart: (params: DimensionEventParams) => void;
+}
+export declare const registerDimensionHover: () => void;

package/types/interaction/triggers/element-active-by-legend.d.ts

@@ -0,0 +1,21 @@
+import { BaseTrigger } from './base';
+import type { IElementActiveByLegendOptions, ITrigger, ITriggerEventHandler } from '../interface/trigger';
+import type { IMarkGraphic } from '../../mark/interface';
+import type { BaseEventParams } from '../../core';
+export declare class ElementActiveByLegend extends BaseTrigger<IElementActiveByLegendOptions> implements ITrigger<IElementActiveByLegendOptions> {
+    static type: string;
+    type: string;
+    static defaultOptions: Partial<IElementActiveByLegendOptions>;
+    constructor(options?: IElementActiveByLegendOptions);
+    protected getEvents(): Array<{
+        type: string | string[];
+        handler: ITriggerEventHandler;
+    }>;
+    getStartState(): string;
+    start(itemKey: string): void;
+    resetAll(): void;
+    reset(g?: IMarkGraphic): void;
+    handleStart: (e: BaseEventParams) => void;
+    handleReset: (e: BaseEventParams) => void;
+}
+export declare const registerElementActiveByLegend: () => void;

package/types/interaction/triggers/element-active.d.ts

@@ -0,0 +1,20 @@
+import { BaseTrigger } from './base';
+import type { IElementActiveOptions, ITrigger, ITriggerEventHandler } from '../interface/trigger';
+import type { IMarkGraphic } from '../../mark/interface';
+import type { BaseEventParams } from '../../event/interface';
+export declare class ElementActive extends BaseTrigger<IElementActiveOptions> implements ITrigger<IElementActiveOptions> {
+    static type: string;
+    type: string;
+    static defaultOptions: Partial<IElementActiveOptions>;
+    constructor(options?: IElementActiveOptions);
+    protected getEvents(): Array<{
+        type: string | string[];
+        handler: ITriggerEventHandler;
+    }>;
+    getStartState(): string;
+    start(g: IMarkGraphic): void;
+    reset(graphic?: IMarkGraphic): void;
+    handleStart: (e: BaseEventParams) => void;
+    handleReset: (e: BaseEventParams) => void;
+}
+export declare const registerElementActive: () => void;

package/types/interaction/triggers/element-highlight-by-graphic-name.d.ts

@@ -0,0 +1,13 @@
+import { ElementHighlight } from './element-highlight';
+import type { BaseEventParams } from '../../event/interface';
+export declare class ElementHighlightByGraphicName extends ElementHighlight {
+    static type: string;
+    type: string;
+    protected _filterByName(e: BaseEventParams): boolean;
+    protected _parseTargetKey(e: BaseEventParams): string;
+    start(itemKey: any): void;
+    reset(): void;
+    handleStart: (e: BaseEventParams) => void;
+    handleReset: (e: BaseEventParams) => void;
+}
+export declare const registerElementHighlightByGraphicName: () => void;

package/types/interaction/triggers/element-highlight-by-group.d.ts

@@ -0,0 +1,23 @@
+import { BaseTrigger } from './base';
+import type { IElementHighlightOptions, ITrigger, ITriggerEventHandler } from '../interface/trigger';
+import type { IMarkGraphic } from '../../mark/interface';
+import type { BaseEventParams } from '../../core';
+export declare class ElementHighlightByGroup extends BaseTrigger<IElementHighlightOptions> implements ITrigger<IElementHighlightOptions> {
+    static type: string;
+    type: string;
+    static defaultOptions: Partial<IElementHighlightOptions>;
+    constructor(options?: IElementHighlightOptions);
+    getStartState(): string;
+    getResetState(): string;
+    protected getEvents(): Array<{
+        type: string | string[];
+        handler: ITriggerEventHandler;
+    }>;
+    resetAll(): void;
+    protected _getHightlightKey(g: IMarkGraphic): string;
+    start(g: IMarkGraphic): void;
+    reset(g?: IMarkGraphic): void;
+    handleStart: (e: BaseEventParams) => void;
+    handleReset: (e: BaseEventParams) => void;
+}
+export declare const registerElementHighlightByGroup: () => void;

package/types/interaction/triggers/element-highlight-by-key.d.ts

@@ -0,0 +1,9 @@
+import type { IElementHighlightOptions, ITrigger } from '../interface/trigger';
+import { ElementHighlightByGroup } from './element-highlight-by-group';
+import type { IMarkGraphic } from '../../mark/interface/common';
+export declare class ElementHighlightByKey extends ElementHighlightByGroup implements ITrigger<IElementHighlightOptions> {
+    static type: string;
+    type: string;
+    protected _getHightlightKey(g: IMarkGraphic): string;
+}
+export declare const registerElementHighlightByKey: () => void;

package/types/interaction/triggers/element-highlight-by-legend.d.ts

@@ -0,0 +1,22 @@
+import { BaseTrigger } from './base';
+import type { IElementHighlightByLegendOptions, ITrigger, ITriggerEventHandler } from '../interface/trigger';
+import type { IMarkGraphic } from '../../mark/interface/common';
+import type { BaseEventParams } from '../../event/interface';
+export declare class ElementHighlightByLegend extends BaseTrigger<IElementHighlightByLegendOptions> implements ITrigger<IElementHighlightByLegendOptions> {
+    static type: string;
+    type: string;
+    static defaultOptions: Partial<IElementHighlightByLegendOptions>;
+    constructor(options?: IElementHighlightByLegendOptions);
+    getStartState(): string;
+    getResetState(): string;
+    protected getEvents(): Array<{
+        type: string | string[];
+        handler: ITriggerEventHandler;
+    }>;
+    start(itemKey: any): void;
+    resetAll(): void;
+    reset(g?: IMarkGraphic): void;
+    handleStart: (e: BaseEventParams) => void;
+    handleReset: (e: BaseEventParams) => void;
+}
+export declare const registerElementHighlightByLegend: () => void;