@visactor/vchart 1.2.0-beta.6 → 1.2.0-beta.7

package/build/es5/data/transforms/pie.d.ts

@@ -0,0 +1,16 @@
+import type { DataView } from '@visactor/vdataset';
+export interface IPieOpt {
+    angleField: string;
+    startAngle: number;
+    endAngle: 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/build/es5/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/build/es5/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/build/es5/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/build/es5/data/transforms/sankey.d.ts

@@ -0,0 +1,21 @@
+import type { SankeyOptions, SankeyData } from '@visactor/vgrammar-sankey';
+export interface ISankeyOpt extends SankeyOptions {
+    targetField: string;
+    sourceField: 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/build/es5/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/build/es5/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/build/es5/data/transforms/tick-data/config.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_CONTINUOUS_TICK_COUNT = 5;

package/build/es5/data/transforms/tick-data/continuous.d.ts

@@ -0,0 +1,3 @@
+import type { ContinuousScale } from '@visactor/vscale';
+import type { ITickData, ITickDataOpt } from './interface';
+export declare const continuousTicks: (scale: ContinuousScale, op: ITickDataOpt) => ITickData[];

package/build/es5/data/transforms/tick-data/discrete/linear.d.ts

@@ -0,0 +1,3 @@
+import type { BandScale } from '@visactor/vscale';
+import type { ICartesianTickDataOpt, ITickData } from '../interface';
+export declare const linearDiscreteTicks: (scale: BandScale, op: ICartesianTickDataOpt) => ITickData[];

package/build/es5/data/transforms/tick-data/discrete/polar-angle.d.ts

@@ -0,0 +1,3 @@
+import type { BandScale } from '@visactor/vscale';
+import type { IPolarTickDataOpt, ITickData } from '../interface';
+export declare const polarAngleAxisDiscreteTicks: (scale: BandScale, op: IPolarTickDataOpt) => ITickData[];

package/build/es5/data/transforms/tick-data/index.d.ts

@@ -0,0 +1,4 @@
+import type { IBaseScale } from '@visactor/vscale';
+import type { ITickData, ITickDataOpt } from './interface';
+export * from './interface';
+export declare const ticks: (scale: IBaseScale, op: ITickDataOpt) => ITickData[];

package/build/es5/data/transforms/tick-data/interface.d.ts

@@ -0,0 +1,28 @@
+import type { IPolarAxisSpec } from '../../../component/axis/polar/interface';
+import type { CoordinateType, IOrientType, IPolarOrientType, ITextMarkSpec } from '../../../typings';
+export interface ITickDataOpt {
+    sampling?: boolean;
+    tickCount?: number;
+    forceTickCount?: number;
+    tickStep?: number;
+    coordinateType: CoordinateType;
+    axisOrientType: IOrientType | IPolarOrientType;
+    startAngle?: number;
+    labelFormatter?: (value: any) => string;
+    labelStyle: ITextMarkSpec;
+    labelGap?: number;
+}
+export interface ICartesianTickDataOpt extends ITickDataOpt {
+    axisOrientType: IOrientType;
+    labelLastVisible: boolean;
+    labelFlush: boolean;
+}
+export interface IPolarTickDataOpt extends ITickDataOpt {
+    axisOrientType: IPolarOrientType;
+    getRadius: () => number;
+    axisSpec: IPolarAxisSpec;
+}
+export interface ITickData {
+    index: number;
+    value: number | string;
+}

package/build/es5/data/transforms/tick-data/util.d.ts

@@ -0,0 +1,15 @@
+import type { IBaseScale } from '@visactor/vscale';
+import type { IBoundsLike } from '@visactor/vutils';
+import { AABBBounds } from '@visactor/vutils';
+import type { ICartesianTickDataOpt, IPolarTickDataOpt, ITickData, ITickDataOpt } from './interface';
+import type { IGraphic } from '@visactor/vrender';
+export declare const convertDomainToTickData: (domain: any[], op: ITickDataOpt) => ITickData[];
+export declare const labelOverlap: (prevLabel: AABBBounds, nextLabel: AABBBounds, gap?: number) => boolean;
+export declare const labelDistance: (prevLabel: AABBBounds, nextLabel: AABBBounds) => [number, number];
+export declare function intersect(a: IBoundsLike, b: IBoundsLike, sep: number): boolean;
+export interface ILabelItem<T> extends Pick<IGraphic, 'AABBBounds'> {
+    value?: T;
+}
+export declare function hasOverlap<T>(items: ILabelItem<T>[], pad: number): boolean;
+export declare const getCartesianLabelBounds: (scale: IBaseScale, domain: any[], op: ICartesianTickDataOpt) => AABBBounds[];
+export declare const getPolarAngleLabelBounds: (scale: IBaseScale, domain: any[], op: IPolarTickDataOpt) => AABBBounds[];

package/build/es5/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/build/es5/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/build/es5/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/build/es5/event/event-dispatcher.d.ts

@@ -0,0 +1,25 @@
+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 _viewListeners;
+    private _windowListeners;
+    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/build/es5/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/build/es5/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/build/es5/event/events/dimension/dimension-click.d.ts

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

package/build/es5/event/events/dimension/dimension-hover.d.ts

@@ -0,0 +1,10 @@
+import type { RenderMode } from '../../../typings/spec/common';
+import type { EventHandler, EventParamsDefinition, EventType, IEventDispatcher } from '../../interface';
+import { DimensionEvent } from './base';
+export declare class DimensionHoverEvent extends DimensionEvent {
+    private _cacheDimensionInfo;
+    constructor(eventDispatcher: IEventDispatcher, mode: RenderMode);
+    register<Evt extends EventType>(eType: Evt, handler: EventHandler<EventParamsDefinition[Evt]>): void;
+    unregister(): void;
+    private onMouseMove;
+}

package/build/es5/event/events/dimension/index.d.ts

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

package/build/es5/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;
+    axis?: AxisComponent;
+    data: IDimensionData[];
+}
+export interface IDimensionData {
+    datum: Datum[];
+    series: ISeries;
+}
+export type DimensionEventParams = BaseEventParams & {
+    action: 'enter' | 'leave' | 'move' | 'click';
+    dimensionInfo: IDimensionInfo[];
+};

package/build/es5/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/build/es5/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/build/es5/event/events/dimension/util/index.d.ts

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

package/build/es5/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/build/es5/event/events/index.d.ts

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

package/build/es5/event/interface.d.ts

@@ -0,0 +1,153 @@
+import type { INode } from '@visactor/vrender';
+import type { IElement } from '@visactor/vgrammar';
+import type { IChart } from '../chart/interface';
+import type { IModel } from '../model/interface';
+import type { IMark, MarkType } from '../mark/interface';
+import type { VChart } from '../core/vchart';
+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';
+import type { SeriesType } from '../series/interface';
+import type { TooltipEventParams } from '../component/tooltip/interface/event';
+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 EventBubbleLevel = keyof typeof Event_Bubble_Level;
+export type ComponentType = 'axis' | 'dataZoom' | 'indicator' | 'legend' | 'mapLabel' | 'markLine' | 'tooltip' | 'title';
+export type EventTargetType = MarkType | ComponentType | SeriesType;
+export type EventSourceType = keyof typeof Event_Source_Type;
+export type EventQuery = {
+    level?: EventBubbleLevel;
+    source?: EventSourceType;
+    nodeName?: string;
+    markName?: string;
+    type?: EventTargetType;
+    id?: StringOrNumber;
+    filter?: (params: Partial<BaseEventParams>) => boolean;
+    throttle?: number;
+    debounce?: number;
+    consume?: boolean;
+};
+export type EventParams = {
+    event?: SuperEvent;
+    value?: any;
+    mark?: IMark;
+    model?: IModel;
+    chart?: IChart;
+    datum?: Datum;
+    node?: INode;
+};
+type SuperEvent = Event & {
+    [key: string]: any;
+};
+export type BaseEventParams = EventParams & {
+    event: SuperEvent;
+    item: IElement;
+    datum: Datum;
+    source: EventSourceType;
+    itemMap: Map<string, any>;
+};
+export type EventCallback<Params extends EventParams> = (params: Params) => boolean | void;
+export type EventFilter = {
+    source: EventSourceType;
+    level: EventBubbleLevel;
+    type: string | null;
+    markName: string | null;
+    nodeName: string | null;
+    userId: StringOrNumber | null;
+    filter: (params: Partial<BaseEventParams>) => boolean | null;
+};
+export type EventHandler<Params extends EventParams> = {
+    callback: EventCallback<Params>;
+    query: EventQuery | null;
+    wrappedCallback?: EventCallback<Params>;
+    filter?: EventFilter;
+};
+export type ExtendEventParam = EventParams & {
+    event?: Event;
+    item?: any;
+    datum?: Datum;
+    source?: EventSourceType;
+    itemMap?: Map<string, any>;
+};
+export type PanEventParam = ExtendEventParam & {
+    delta: [number, number];
+};
+export type ZoomEventParam = ExtendEventParam & {
+    scale: number;
+    scaleCenter: IPoint;
+};
+export type EventParamsDefinition = {
+    pointerdown: BaseEventParams;
+    pointerup: BaseEventParams;
+    pointerupoutside: BaseEventParams;
+    pointertap: BaseEventParams;
+    pointerover: BaseEventParams;
+    pointermove: BaseEventParams;
+    pointerenter: BaseEventParams;
+    pointerleave: BaseEventParams;
+    pointerout: BaseEventParams;
+    mousedown: BaseEventParams;
+    mouseup: BaseEventParams;
+    mouseupoutside: BaseEventParams;
+    rightdown: BaseEventParams;
+    rightup: BaseEventParams;
+    rightupoutside: BaseEventParams;
+    click: BaseEventParams;
+    dblclick: BaseEventParams;
+    mousemove: BaseEventParams;
+    mouseover: BaseEventParams;
+    mouseout: BaseEventParams;
+    mouseenter: BaseEventParams;
+    mouseleave: BaseEventParams;
+    wheel: BaseEventParams;
+    touchstart: BaseEventParams;
+    touchend: BaseEventParams;
+    touchendoutside: BaseEventParams;
+    touchmove: BaseEventParams;
+    touchcancel: BaseEventParams;
+    dragstart: BaseEventParams;
+    drag: BaseEventParams;
+    dragenter: BaseEventParams;
+    dragleave: BaseEventParams;
+    dragover: BaseEventParams;
+    dragend: BaseEventParams;
+    drop: BaseEventParams;
+    tap: BaseEventParams;
+    pan: BaseEventParams;
+    panstart: BaseEventParams;
+    panend: BaseEventParams;
+    press: BaseEventParams;
+    pressup: BaseEventParams;
+    pressend: BaseEventParams;
+    pinch: BaseEventParams;
+    pinchstart: BaseEventParams;
+    pinchend: BaseEventParams;
+    swipe: BaseEventParams;
+    dimension: DimensionEventParams;
+    tooltipShow: TooltipEventParams;
+    tooltipHide: TooltipEventParams;
+    tooltipRelease: TooltipEventParams;
+    [key: string]: ExtendEventParam;
+};
+export interface IEventDispatcher {
+    globalInstance: VChart;
+    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;
+}
+export interface IEvent {
+    on: (<Evt extends EventType>(eType: Evt, callback: EventCallback<EventParamsDefinition[Evt]>) => this) & (<Evt extends EventType>(eType: Evt, query: EventQuery, callback: EventCallback<EventParamsDefinition[Evt]>) => this);
+    off: (<Evt extends EventType>(eType: Evt, callback?: EventCallback<EventParamsDefinition[Evt]>) => this) & (<Evt extends EventType>(eType: Evt, query: EventQuery, callback: EventCallback<EventParamsDefinition[Evt]>) => this);
+    emit: <Evt extends EventType>(eType: Evt, params: EventParamsDefinition[Evt], level?: EventBubbleLevel) => void;
+    release: () => void;
+    getComposedEventMap: () => Map<EventCallback<EventParams>, {
+        eventType: EventType;
+        event: IComposedEvent;
+    }>;
+}
+export interface IComposedEvent {
+    register: <Evt extends EventType>(eType: Evt, handler: EventHandler<EventParamsDefinition[Evt]>) => void;
+    unregister: () => void;
+    dispatch: (v: unknown, opt: unknown) => unknown;
+}
+export {};

package/build/es5/index.d.ts

@@ -0,0 +1,10 @@
+import { VChart } from './vchart-all';
+export default VChart;
+export * from './core';
+export * from './chart';
+export * from './series';
+export * from './mark';
+export * from './component';
+export * from './layout';
+export * from './typings/spec/index';
+export { ThemeManager } from './theme/index';