@visactor/vchart-types 1.6.0-beta.0

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

@@ -0,0 +1,33 @@
+import type { DataView } from '@visactor/vdataset';
+import type { IAggrType } from '../../component/marker/interface';
+import type { ICartesianSeries } from '../../series/interface';
+export type IOption = {
+    field: string;
+};
+export type IOptionAggrField = {
+    field: string;
+    aggrType: IAggrType;
+};
+export type IOptionPos = IOptionAggrField | string | number;
+export type IOptionSeries = {
+    getRelativeSeries: () => ICartesianSeries;
+    getStartRelativeSeries: () => ICartesianSeries;
+    getEndRelativeSeries: () => ICartesianSeries;
+};
+export type IOptionCallback = (relativeSeriesData: any, startRelativeSeriesData: any, endRelativeSeriesData: any) => IOptionPos;
+export type IOptionAggr = {
+    x?: IOptionPos | IOptionCallback;
+    y?: IOptionPos | IOptionCallback;
+    getRefRelativeSeries?: () => ICartesianSeries;
+} & IOptionSeries;
+export declare const markerMin: (_data: Array<DataView>, opt: IOption) => number;
+export declare const markerMax: (_data: Array<DataView>, opt: IOption) => number;
+export declare function markerSum(_data: Array<DataView>, opt: IOption): number;
+export declare function markerAverage(_data: Array<DataView>, opt: IOption): number;
+export declare function markerVariance(_data: Array<DataView>, opt: IOption): number;
+export declare function markerStandardDeviation(_data: Array<DataView>, opt: IOption): number;
+export declare function markerMedian(_data: Array<DataView>, opt: IOption): number;
+export declare function markerAggregation(_data: Array<DataView>, options: IOptionAggr[]): {
+    x: string | number | null;
+    y: string | number | null;
+}[];

package/types/data/transforms/box-plot.d.ts

@@ -0,0 +1,5 @@
+export interface IBoxPlotOutlierOpt {
+    dimensionField: string[];
+    outliersField: string;
+}
+export declare const foldOutlierData: (data: Array<DataView>, op: IBoxPlotOutlierOpt) => any;

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

@@ -0,0 +1,7 @@
+import type { Datum } from '../../typings';
+import type { CirclePackingOptions } from '@visactor/vgrammar-hierarchy';
+export interface ICirclePackingOpt extends CirclePackingOptions {
+    width: number;
+    height: number;
+}
+export declare const circlePackingLayout: (data: Array<Datum>, op: () => ICirclePackingOpt) => Datum[];

package/types/data/transforms/copy-data-view.d.ts

@@ -0,0 +1,5 @@
+import { DataView } from '@visactor/vdataset';
+export declare const copyDataView: (data: Array<DataView>, options?: ICopyDataViewOption) => any;
+export interface ICopyDataViewOption {
+    deep?: boolean;
+}

package/types/data/transforms/correlation-center.d.ts

@@ -0,0 +1,4 @@
+export declare const correlationCenter: (data: any, options: any) => {
+    [x: string]: any;
+    [x: number]: any;
+};

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

@@ -0,0 +1,17 @@
+export interface ICorrelationOpt {
+    field: string;
+    radiusField?: string;
+    radiusRange?: [number, number];
+    center?: [string | number, string | number];
+    startAngle?: number;
+    endAngle?: number;
+    innerRadius?: string | number;
+    outerRadius?: string | number;
+}
+export interface CircularRelationItem {
+    x: number;
+    y: number;
+    size: number;
+    datum: any;
+}
+export declare const correlation: (data: any, options: any) => any;

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

@@ -0,0 +1,20 @@
+import type { BaseSeries } from '../../series/base/base-series';
+import type { TreemapSeries } from '../../series/treemap/treemap';
+import type { AddVChartPropertyContext } from './add-property';
+import type { SunburstSeries } from '../../series/sunburst/sunburst';
+import type { CirclePackingSeries } from '../../series/circle-packing/circle-packing';
+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;
+};
+export declare function addDataKey(d: any, i: number, context: AddVChartPropertyContext): void;
+export declare function initHierarchyKeyMap(this: TreemapSeries | SunburstSeries | CirclePackingSeries): {
+    keyMap: Map<any, any>;
+    needDefaultSeriesField: boolean;
+    defaultSeriesField: string;
+    getKey: any;
+    categoryField: string;
+};
+export declare function addHierarchyDataKey(d: any, i: number, context: AddVChartPropertyContext, depth?: number, root?: string, rootIndex?: number): void;

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

@@ -0,0 +1,10 @@
+import type { DataView } from '@visactor/vdataset';
+export interface IDimensionTreeOpt {
+    fields: string[];
+}
+export declare const dimensionTree: (data: Array<DataView>, op: IDimensionTreeOpt) => DataView[] | {
+    dimensionValues: {};
+    dimensionData: any;
+};
+export declare function mapValues(target: object, fn: (value: any, key: string) => any): {};
+export declare function findDataInFields(data: any, fields: string[]): any;

package/types/data/transforms/dimension-statistics.d.ts

@@ -0,0 +1,24 @@
+import type { IFieldsMeta } from '../../typings/spec';
+import type { DataView } from '@visactor/vdataset';
+import type { Datum } from '../../typings';
+export type StatisticOperations = Array<'max' | 'min' | 'values' | 'array-max' | 'array-min' | 'allValid'>;
+export interface IStatisticsOption {
+    fields: {
+        key: string;
+        operations: StatisticOperations;
+        customize?: {
+            max: number;
+            min: number;
+        } | any[];
+    }[];
+    target?: 'parser' | 'latest';
+}
+export declare const dimensionStatistics: (data: Array<DataView>, op: IStatisticsOption) => {};
+export declare const dimensionStatisticsOfSimpleData: (latestData: Datum[], fields: {
+    key: string;
+    operations: StatisticOperations;
+    customize?: {
+        max: number;
+        min: number;
+    } | any[];
+}[], dataFields?: Record<string, IFieldsMeta>) => {};

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

@@ -0,0 +1,14 @@
+import type { Datum } from '../../typings';
+export declare enum DrillEnum {
+    DrillDown = "drillDown",
+    DrillUp = "drillUp"
+}
+export type DrillInfo = {
+    key: string;
+    type: DrillEnum;
+    path: string[];
+};
+export declare const drillFilter: (data: Array<Datum>, op: {
+    info: () => DrillInfo;
+    keyField: () => string;
+}) => any[];

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

@@ -0,0 +1,9 @@
+import type { Datum } from '../../typings';
+import type { TreemapNodeElement, SunburstNodeElement } from '@visactor/vgrammar-hierarchy';
+export type FlattenNodeElement = TreemapNodeElement | SunburstNodeElement;
+export interface IFlattenOpt {
+    output?: Datum[];
+    maxDepth?: number;
+    callback?: <T>(node: FlattenNodeElement) => T;
+}
+export declare const flatten: (data: Array<Datum>, op?: IFlattenOpt) => FlattenNodeElement[];

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

@@ -0,0 +1,51 @@
+import type { DataView } from '@visactor/vdataset';
+export interface IFunnelOpt {
+    valueField: string;
+    asTransformRatio: string;
+    asReachRatio: string;
+    asHeightRatio: string;
+    asValueRatio: string;
+    asLastValueRatio: string;
+    asNextValueRatio: string;
+    asCurrentValue: string;
+    asLastValue: string;
+    asNextValue: string;
+    isCone?: boolean;
+    heightVisual?: boolean;
+    range?: {
+        min: number;
+        max: number;
+    };
+}
+export declare const funnel: (originData: Array<DataView>, op: IFunnelOpt) => {
+    dataSet: import("@visactor/vdataset").DataSet;
+    options?: import("@visactor/vdataset").IDataViewOptions;
+    isDataView: boolean;
+    type: import("@visactor/vdataset/es/constants").DATAVIEW_TYPE;
+    name: string | number;
+    target: any;
+    parseOption: import("@visactor/vdataset/es/parser").IParserOptions;
+    transformsArr: import("@visactor/vdataset").ITransformOptions[];
+    isRunning: boolean;
+    rawData: any;
+    history: boolean;
+    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;
+    markRunning: () => void;
+}[];
+export interface IFunnelTransformOpt {
+    asIsTransformLevel: string;
+}
+export declare const funnelTransform: (originData: Array<DataView>, op: IFunnelTransformOpt) => any;

package/types/data/transforms/hierarchy-dimension-statistics.d.ts

@@ -0,0 +1,3 @@
+import type { IStatisticsOption } from './dimension-statistics';
+import type { DataView } from '@visactor/vdataset';
+export declare const hierarchyDimensionStatistics: (data: Array<DataView>, op: IStatisticsOption) => {};

package/types/data/transforms/invalid-travel.d.ts

@@ -0,0 +1,8 @@
+import type { IInvalidType, StringOrNumber } from '../../typings';
+export interface ITravelOpt {
+    config: () => {
+        invalidType: IInvalidType;
+        checkField: StringOrNumber;
+    };
+}
+export declare const invalidTravel: (data: Array<any>, op: ITravelOpt) => any[];

package/types/data/transforms/legend-data/continuous/continuous.d.ts

@@ -0,0 +1,4 @@
+import type { ISeries } from '../../../../series/interface';
+import type { IContinuousLegendDataMakeOption, IContinuousLegendFilterOption } from './interface';
+export declare const continuousLegendDataMake: (data: Array<ISeries>, op: IContinuousLegendDataMakeOption) => any;
+export declare const continuousLegendFilter: (data: Array<any>, op: IContinuousLegendFilterOption) => any[];

package/types/data/transforms/legend-data/continuous/index.d.ts

@@ -0,0 +1,2 @@
+export * from './continuous';
+export * from './interface';

package/types/data/transforms/legend-data/continuous/interface.d.ts

@@ -0,0 +1,13 @@
+import type { IBaseScale } from '@visactor/vscale';
+import type { ISeries } from '../../../../series/interface';
+import type { StringOrNumber } from '../../../../typings';
+export interface IContinuousLegendDataMakeOption {
+    series: () => ISeries[];
+    field: () => string | undefined;
+    scale?: () => IBaseScale;
+}
+export interface IContinuousLegendFilterOption {
+    selected: () => StringOrNumber[];
+    field: () => string | undefined;
+    data: () => StringOrNumber[];
+}

package/types/data/transforms/legend-data/discrete/discrete.d.ts

@@ -0,0 +1,4 @@
+import type { ISeries } from '../../../../series/interface';
+import type { IDiscreteLegendData, IDiscreteLegendDataMakeOption, IDiscreteLegendFilterOption } from './interface';
+export declare const discreteLegendDataMake: (data: Array<ISeries>, op: IDiscreteLegendDataMakeOption) => IDiscreteLegendData[];
+export declare const discreteLegendFilter: (data: Array<any>, op: IDiscreteLegendFilterOption) => any[];

package/types/data/transforms/legend-data/discrete/index.d.ts

@@ -0,0 +1,2 @@
+export * from './discrete';
+export * from './interface';

package/types/data/transforms/legend-data/discrete/interface.d.ts

@@ -0,0 +1,15 @@
+import type { ISeries } from '../../../../series/interface';
+import type { StringOrNumber } from '../../../../typings';
+export interface IDiscreteLegendData {
+    key: string;
+    style: (attribute: string) => any;
+}
+export interface IDiscreteLegendDataMakeOption {
+    series: () => ISeries[];
+    seriesField: (s: ISeries) => string;
+}
+export interface IDiscreteLegendFilterOption {
+    selected: () => StringOrNumber[];
+    field: () => string;
+    data: () => StringOrNumber[];
+}

package/types/data/transforms/link-dot-info.d.ts

@@ -0,0 +1,13 @@
+import type { Datum } from '../../typings';
+export interface ILinkDotInfoOpt {
+    infoKey: string;
+    fields: () => {
+        fromField: string;
+        toField: string;
+        xField: string | string[];
+        yField: string | string[];
+    };
+    linkData: () => Datum[];
+    dotData: () => Datum[];
+}
+export declare const linkDotInfo: (data: Array<DataView>, op: ILinkDotInfoOpt) => Datum[];

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

@@ -0,0 +1,12 @@
+import type { DataView } from '@visactor/vdataset';
+import type { Datum } from '../../typings';
+export interface ILookUpOpt {
+    from: () => object[];
+    key: string;
+    fields: string;
+    values?: string[];
+    as?: string[];
+    default?: any;
+    set?: (A: Datum, B: Datum) => void;
+}
+export declare const lookup: (data: Array<DataView>, opt: ILookUpOpt) => DataView[];

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

@@ -0,0 +1,7 @@
+import type { GeoSourceType } from '../../typings/geo';
+export interface IMapOpt {
+    nameMap: Record<string, string>;
+    nameProperty: string;
+}
+export declare const DEFAULT_MAP_LOOK_UP_KEY: string;
+export declare const map: (data: GeoSourceType, opt: IMapOpt) => any;

package/types/data/transforms/obj-flat.d.ts

@@ -0,0 +1,2 @@
+import type { DataView } from '@visactor/vdataset';
+export declare const objFlat: (data: Array<DataView>, op: string) => any[];

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

@@ -0,0 +1,17 @@
+import type { DataView } from '@visactor/vdataset';
+export interface IPieOpt {
+    angleField: string;
+    startAngle: number;
+    endAngle: number;
+    minAngle: number;
+    asStartAngle: string;
+    asEndAngle: string;
+    asMiddleAngle: string;
+    asRadian: string;
+    asRatio: string;
+    asQuadrant: string;
+    asK: string;
+}
+export declare const pie: (originData: Array<DataView>, op: IPieOpt) => {
+    [x: string]: any;
+}[];

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

@@ -0,0 +1,6 @@
+import type { DataView } from '@visactor/vdataset';
+export type IOptionRegr = {
+    fieldX: string;
+    fieldY: string;
+};
+export declare function markerRegression(_data: Array<DataView>, opt: IOptionRegr): any[];

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

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

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

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

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

@@ -0,0 +1,22 @@
+import type { SankeyOptions, SankeyData } from '@visactor/vgrammar-sankey';
+export interface ISankeyOpt extends SankeyOptions {
+    targetField: string;
+    sourceField: string;
+    valueField: string;
+    view: () => {
+        x0: number;
+        x1: number;
+        y0: number;
+        y1: number;
+    };
+}
+export declare const sankey: (data: SankeyData, op: ISankeyOpt) => {
+    nodes?: import("@visactor/vgrammar-sankey").SankeyNodeDatum[];
+    links: import("@visactor/vgrammar-sankey").SankeyLinkDatum[];
+} | {
+    nodes: import("@visactor/vgrammar-sankey").HierarchyNodeDatum[];
+} | {
+    nodes: import("@visactor/vgrammar-sankey").SankeyNodeElement[];
+    links: import("@visactor/vgrammar-sankey").SankeyLinkElement[];
+    columns: import("@visactor/vgrammar-sankey").SankeyNodeElement[][];
+}[];

package/types/data/transforms/stack-split.d.ts

@@ -0,0 +1,6 @@
+import type { ISeriesStackDataNode } from '../../series/interface';
+import type { DataView } from '@visactor/vdataset';
+export interface IStackOption {
+    fields: string[];
+}
+export declare const stackSplit: (data: Array<DataView>, op: IStackOption) => ISeriesStackDataNode;

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

@@ -0,0 +1,7 @@
+import type { SunburstOptions } from '@visactor/vgrammar-hierarchy';
+import type { Datum } from '../../typings';
+export interface ISunburstOpt extends SunburstOptions {
+    width: number;
+    height: number;
+}
+export declare const sunburstLayout: (data: Array<Datum>, op: () => ISunburstOpt) => Datum[];

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

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

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

@@ -0,0 +1,25 @@
+import type { DataView } from '@visactor/vdataset';
+import type { IWaterfallSeriesSpec } from '../../series/waterfall/interface';
+import type { Datum } from '../../typings';
+export interface IWaterfallOpt {
+    indexField: string;
+    valueField: string;
+    seriesField?: string;
+    startAs: string;
+    endAs: string;
+    total: IWaterfallSeriesSpec['total'];
+    seriesFieldName: {
+        total: string;
+        increase: string;
+        decrease: string;
+    };
+    groupData: () => DataView;
+}
+export declare const waterfall: (lastData: Array<Datum>, op: IWaterfallOpt) => Datum[];
+export interface IWaterfallFillEndOpt {
+    indexField: string;
+    valueField: string;
+    seriesField?: string;
+    total: IWaterfallSeriesSpec['total'];
+}
+export declare const waterfallFillTotal: (data: Array<Datum>, op: IWaterfallFillEndOpt) => Datum[];

package/types/env/env.d.ts

@@ -0,0 +1,7 @@
+export declare const registerAllEnv: () => void;
+export declare const registerBrowserEnv: () => void;
+export declare const registerLarkEnv: () => void;
+export declare const registerLynxEnv: () => void;
+export declare const registerNodeEnv: () => void;
+export declare const registerTaroEnv: () => void;
+export declare const registerWXEnv: () => void;

package/types/env/index.d.ts

@@ -0,0 +1 @@
+export * from './env';

package/types/event/bubble.d.ts

@@ -0,0 +1,15 @@
+import type { EventHandler, EventParams, EventBubbleLevel } from './interface';
+export type BubbleNode = {
+    handler: EventHandler<EventParams>;
+    level: EventBubbleLevel;
+};
+export declare class Bubble {
+    private _map;
+    private _levelNodes;
+    constructor();
+    addHandler(handler: EventHandler<EventParams>, level: EventBubbleLevel): this;
+    removeHandler(handler: EventHandler<EventParams>): this;
+    getHandlers(level: EventBubbleLevel): EventHandler<EventParams>[];
+    getCount(): number;
+    release(): void;
+}

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

@@ -0,0 +1,27 @@
+import type { EventType, EventHandler, EventParamsDefinition, IEventDispatcher, EventBubbleLevel } from './interface';
+import type { VChart } from '../core/vchart';
+import type { Compiler } from '../compile/compiler';
+export declare class EventDispatcher implements IEventDispatcher {
+    globalInstance: VChart;
+    private _viewBubbles;
+    private _windowBubbles;
+    private _canvasBubbles;
+    private _viewListeners;
+    private _windowListeners;
+    private _canvasListeners;
+    private _compiler;
+    constructor(vchart: VChart, compiler: Compiler);
+    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;
+    release(): void;
+    private _filter;
+    private _prepareParams;
+    private _onDelegate;
+    private _invoke;
+    private _getQueryLevel;
+    private _parseQuery;
+    private getEventBubble;
+    private getEventListeners;
+    private _isValidEvent;
+}

package/types/event/event.d.ts

@@ -0,0 +1,18 @@
+import type { RenderMode } from '../typings/spec/common';
+import type { EventType, EventQuery, EventCallback, EventParamsDefinition, IEvent, IEventDispatcher, IComposedEvent, EventParams, EventBubbleLevel } from './interface';
+export declare class Event implements IEvent {
+    private _eventDispatcher;
+    private _mode;
+    private _composedEventMap;
+    getComposedEventMap(): Map<EventCallback<EventParams>, {
+        eventType: string;
+        event: IComposedEvent;
+    }>;
+    constructor(eventDispatcher: IEventDispatcher, mode: RenderMode);
+    on<Evt extends EventType>(eType: Evt, callback: EventCallback<EventParamsDefinition[Evt]>): this;
+    on<Evt extends EventType>(eType: Evt, query: EventQuery, callback: EventCallback<EventParamsDefinition[Evt]>): this;
+    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;
+    release(): void;
+}

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

@@ -0,0 +1,19 @@
+import type { IAxis } from '../../../component/axis/interface';
+import type { RenderMode } from '../../../typings/spec/common';
+import type { BaseEventParams, EventHandler, EventParamsDefinition, IComposedEvent, IEventDispatcher } from '../../interface';
+import type { IChart } from '../../../chart/interface';
+import type { IDimensionInfo } from './interface';
+import type { Maybe } from '../../../typings';
+export declare class DimensionEvent implements IComposedEvent {
+    protected _eventDispatcher: IEventDispatcher;
+    protected _mode: RenderMode;
+    protected _callback: (params: BaseEventParams) => void;
+    protected _chart: Maybe<IChart>;
+    constructor(eventDispatcher: IEventDispatcher, mode: RenderMode);
+    register<Evt extends string>(eType: Evt, handler: EventHandler<EventParamsDefinition[Evt]>): void;
+    unregister(): void;
+    protected getTargetDimensionInfo(x: number, y: number): IDimensionInfo[] | null;
+    dispatch(v: unknown, opt: {
+        filter?: (axis: IAxis) => boolean;
+    }): IDimensionInfo[];
+}

package/types/event/events/dimension/dimension-click.d.ts

@@ -0,0 +1,7 @@
+import type { EventHandler, EventParamsDefinition, EventType } from '../../interface';
+import { DimensionEvent } from './base';
+export declare class DimensionClickEvent extends DimensionEvent {
+    register<Evt extends EventType>(eType: Evt, handler: EventHandler<EventParamsDefinition[Evt]>): void;
+    unregister(): void;
+    private onClick;
+}

package/types/event/events/dimension/dimension-hover.d.ts

@@ -0,0 +1,9 @@
+import type { EventHandler, EventParamsDefinition, EventType } from '../../interface';
+import { DimensionEvent } from './base';
+export declare class DimensionHoverEvent extends DimensionEvent {
+    private _cacheDimensionInfo;
+    register<Evt extends EventType>(eType: Evt, handler: EventHandler<EventParamsDefinition[Evt]>): void;
+    unregister(): void;
+    private onMouseMove;
+    private onMouseOut;
+}

package/types/event/events/dimension/index.d.ts

@@ -0,0 +1,3 @@
+export * from './dimension-click';
+export * from './dimension-hover';
+export * from './interface';

package/types/event/events/dimension/interface.d.ts

@@ -0,0 +1,22 @@
+import type { BaseEventParams } from '../../interface';
+import type { ISeries } from '../../../series/interface';
+import type { Datum } from '../../../typings';
+import type { AxisComponent } from '../../../component/axis/base-axis';
+export declare enum DimensionEventEnum {
+    dimensionHover = "dimensionHover",
+    dimensionClick = "dimensionClick"
+}
+export interface IDimensionInfo {
+    index?: number;
+    value: string | number;
+    axis?: AxisComponent;
+    data: IDimensionData[];
+}
+export interface IDimensionData {
+    datum: Datum[];
+    series: ISeries;
+}
+export type DimensionEventParams = BaseEventParams & {
+    action: 'enter' | 'leave' | 'move' | 'click';
+    dimensionInfo: IDimensionInfo[];
+};

package/types/event/events/dimension/util/cartesian.d.ts

@@ -0,0 +1,8 @@
+import type { IChart } from '../../../../chart/interface';
+import type { ILayoutPoint } from '../../../../model/interface';
+import type { IDimensionInfo } from '../interface';
+import type { CartesianAxis } from '../../../../component/axis/cartesian';
+import type { ICartesianSeries } from '../../../../series/interface';
+export declare const getCartesianDimensionInfo: (chart: IChart | undefined, pos: ILayoutPoint) => IDimensionInfo[] | null;
+export declare const getDimensionInfoByPosition: (axis: CartesianAxis, posValue: number, posKey: 'x' | 'y', getDimensionField: (series: ICartesianSeries) => string | string[]) => IDimensionInfo | null;
+export declare const getDimensionInfoByValue: (axis: CartesianAxis, value: any, getDimensionField?: (series: ICartesianSeries) => string | string[]) => IDimensionInfo | null;

package/types/event/events/dimension/util/common.d.ts

@@ -0,0 +1,8 @@
+import type { ILayoutPoint } from '../../../../model/interface';
+import type { IChart } from '../../../../chart/interface';
+import type { IDimensionData, IDimensionInfo } from '../interface';
+import type { AxisComponent } from '../../../../component/axis/base-axis';
+import type { CoordinateType } from '../../../../typings';
+export declare const isInRegionBound: (chart: IChart, axis: AxisComponent, pos: ILayoutPoint) => boolean;
+export declare const isSameDimensionInfo: (a?: IDimensionInfo, b?: IDimensionInfo) => boolean;
+export declare const getDimensionData: (value: any, axis: AxisComponent, coordinate: CoordinateType, getDimensionField: (series: any) => string | string[]) => IDimensionData[];

package/types/event/events/dimension/util/index.d.ts

@@ -0,0 +1,3 @@
+export * from './common';
+export * from './cartesian';
+export * from './polar';

package/types/event/events/dimension/util/polar.d.ts

@@ -0,0 +1,4 @@
+import type { IChart } from '../../../../chart/interface';
+import type { ILayoutPoint } from '../../../../model/interface';
+import type { IDimensionInfo } from '../interface';
+export declare const getPolarDimensionInfo: (chart: IChart | undefined, pos: ILayoutPoint) => IDimensionInfo[] | null;

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

@@ -0,0 +1,5 @@
+import { DimensionHoverEvent, DimensionClickEvent } from './dimension';
+export declare const ComposedEventMapper: {
+    dimensionHover: typeof DimensionHoverEvent;
+    dimensionClick: typeof DimensionClickEvent;
+};