@visactor/vchart-types 1.6.0

package/types/constant/event.d.ts

@@ -0,0 +1,57 @@
+export { HOOK_EVENT as VGRAMMAR_HOOK_EVENT } from '@visactor/vgrammar-core';
+export declare const BASE_EVENTS: string[];
+export declare enum ChartEvent {
+    initialized = "initialized",
+    rendered = "rendered",
+    renderFinished = "renderFinished",
+    animationFinished = "animationFinished",
+    regionSeriesDataFilterOver = "regionSeriesDataFilterOver",
+    afterInitData = "afterInitData",
+    afterInitEvent = "afterInitEvent",
+    afterInitMark = "afterInitMark",
+    rawDataUpdate = "rawDataUpdate",
+    viewDataFilterOver = "viewDataFilterOver",
+    viewDataUpdate = "viewDataUpdate",
+    viewDataStatisticsUpdate = "viewDataStatisticsUpdate",
+    markDeltaYUpdate = "markDeltaYUpdate",
+    viewDataLabelUpdate = "viewDataLabelUpdate",
+    scaleDomainUpdate = "scaleDomainUpdate",
+    scaleUpdate = "scaleUpdate",
+    dataZoomChange = "dataZoomChange",
+    drill = "drill",
+    layoutStart = "layoutStart",
+    layoutEnd = "layoutEnd",
+    layoutRectUpdate = "layoutRectUpdate",
+    playerPlay = "playerPlay",
+    playerPause = "playerPause",
+    playerEnd = "playerEnd",
+    playerChange = "playerChange",
+    playerForward = "playerForward",
+    playerBackward = "playerBackward",
+    scrollBarChange = "scrollBarChange",
+    brushStart = "brushStart",
+    brushChange = "brushChange",
+    brushEnd = "brushEnd",
+    legendSelectedDataChange = "legendSelectedDataChange",
+    legendFilter = "legendFilter",
+    legendItemClick = "legendItemClick",
+    legendItemHover = "legendItemHover",
+    legendItemUnHover = "legendItemUnHover",
+    tooltipShow = "tooltipShow",
+    tooltipHide = "tooltipHide",
+    tooltipRelease = "tooltipRelease",
+    afterResize = "afterResize",
+    afterRender = "afterRender",
+    afterLayout = "afterLayout"
+}
+export declare enum Event_Source_Type {
+    chart = "chart",
+    window = "window",
+    canvas = "canvas"
+}
+export declare enum Event_Bubble_Level {
+    vchart = "vchart",
+    chart = "chart",
+    model = "model",
+    mark = "mark"
+}

package/types/constant/funnel.d.ts

@@ -0,0 +1,14 @@
+export declare const FUNNEL_TRANSFORM_RATIO: string;
+export declare const FUNNEL_REACH_RATIO: string;
+export declare const FUNNEL_HEIGHT_RATIO: string;
+export declare const FUNNEL_VALUE_RATIO: string;
+export declare const FUNNEL_LAST_VALUE_RATIO: string;
+export declare const FUNNEL_NEXT_VALUE_RATIO: string;
+export declare const FUNNEL_LAST_VALUE: string;
+export declare const FUNNEL_CURRENT_VALUE: string;
+export declare const FUNNEL_NEXT_VALUE: string;
+export declare const FUNNEL_TRANSFORM_LEVEL: string;
+export declare const FUNNEL_LABEL_LINE_LENGTH = 20;
+export declare const FUNNEL_LABEL_SPACE_WIDTH = 5;
+export declare const FUNNEL_MAX_SIZE = "80%";
+export declare const FUNNEL_MIN_SIZE = 0;

package/types/constant/hierarchy.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_HIERARCHY_DEPTH: string;
+export declare const DEFAULT_HIERARCHY_ROOT: string;
+export declare const DEFAULT_HIERARCHY_ROOT_INDEX: string;

package/types/constant/index.d.ts

@@ -0,0 +1,110 @@
+export declare const DEFAULT_MEASURE_CANVAS_ID: string;
+export declare const DEFAULT_DATA_INDEX: string;
+export declare const DEFAULT_DATA_KEY: string;
+export declare const DEFAULT_DATA_SERIES_FIELD: string;
+export declare const DEFAULT_SERIES_STYLE_NAME: string;
+export declare enum AttributeLevel {
+    Default = 0,
+    Theme = 1,
+    Chart = 2,
+    Base_Series = 3,
+    Series = 4,
+    Mark = 5,
+    User_Chart = 6,
+    User_Series = 7,
+    User_Mark = 8,
+    Built_In = 99
+}
+export declare const STACK_FIELD_START: string;
+export declare const STACK_FIELD_END: string;
+export declare const STACK_FIELD_START_PERCENT: string;
+export declare const STACK_FIELD_END_PERCENT: string;
+export declare const STACK_FIELD_START_OffsetSilhouette: string;
+export declare const STACK_FIELD_END_OffsetSilhouette: string;
+export declare const STACK_FIELD_TOTAL: string;
+export declare const STACK_FIELD_TOTAL_PERCENT: string;
+export declare const STACK_FIELD_TOTAL_TOP: string;
+export declare const SEGMENT_FIELD_START: string;
+export declare const SEGMENT_FIELD_END: string;
+export declare enum LayoutZIndex {
+    Axis_Grid = 50,
+    CrossHair_Grid = 100,
+    Region = 450,
+    Mark = 300,
+    Node = 400,
+    Axis = 100,
+    MarkLine = 500,
+    MarkArea = 100,
+    MarkPoint = 500,
+    DataZoom = 500,
+    ScrollBar = 500,
+    Player = 500,
+    Legend = 500,
+    CrossHair = 500,
+    Indicator = 500,
+    Title = 500,
+    Label = 500,
+    Brush = 500,
+    CustomMark = 500
+}
+export declare enum LayoutLevel {
+    Indicator = 10,
+    Region = 20,
+    Axis = 30,
+    DataZoom = 40,
+    Player = 40,
+    ScrollBar = 40,
+    Legend = 50,
+    Title = 70,
+    CustomMark = 70
+}
+export declare const GradientType: string[];
+export declare const DEFAULT_LINEAR_GRADIENT_CONFIG: {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+};
+export declare const DEFAULT_RADIAL_GRADIENT_CONFIG: {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+    r0: number;
+    r1: number;
+};
+export declare const DEFAULT_CONICAL_GRADIENT_CONFIG: {
+    x: number;
+    y: number;
+    startAngle: number;
+    endAngle: number;
+};
+export declare const DEFAULT_GRADIENT_CONFIG: {
+    linear: {
+        x0: number;
+        y0: number;
+        x1: number;
+        y1: number;
+    };
+    radial: {
+        x0: number;
+        y0: number;
+        x1: number;
+        y1: number;
+        r0: number;
+        r1: number;
+    };
+    conical: {
+        x: number;
+        y: number;
+        startAngle: number;
+        endAngle: number;
+    };
+};
+export * from './base';
+export * from './label';
+export * from './polar';
+export * from './layout';
+export * from './event';
+export * from './waterfall';
+export * from './correlation';

package/types/constant/label.d.ts

@@ -0,0 +1,6 @@
+export declare const DEFAULT_LABEL_LIMIT: string;
+export declare const DEFAULT_LABEL_ALIGN: string;
+export declare const DEFAULT_LABEL_TEXT: string;
+export declare const DEFAULT_LABEL_VISIBLE: string;
+export declare const DEFAULT_LABEL_X: string;
+export declare const DEFAULT_LABEL_Y: string;

package/types/constant/layout.d.ts

@@ -0,0 +1,2 @@
+export declare const USER_LAYOUT_RECT_LEVEL = 9;
+export declare const DEFAULT_LAYOUT_RECT_LEVEL = 0;

package/types/constant/marker.d.ts

@@ -0,0 +1,4 @@
+import type { IAggrType } from '../component/marker/interface';
+import type { IRegressType } from '../component/marker/mark-area/interface';
+export declare const AGGR_TYPE: IAggrType[];
+export declare const REGRESS_TYPE: IRegressType[];

package/types/constant/polar.d.ts

@@ -0,0 +1,23 @@
+export declare const ARC_TRANSFORM_VALUE: string;
+export declare const ARC_RATIO: string;
+export declare const ARC_START_ANGLE: string;
+export declare const ARC_END_ANGLE: string;
+export declare const ARC_K: string;
+export declare const ARC_LABEL_HOVER_AX: string;
+export declare const ARC_LABEL_HOVER_AY: string;
+export declare const ARC_LABEL_POINT_AX: string;
+export declare const ARC_LABEL_POINT_AY: string;
+export declare const ARC_LABEL_POINT_BX: string;
+export declare const ARC_LABEL_POINT_BY: string;
+export declare const ARC_LABEL_POINT_CX: string;
+export declare const ARC_LABEL_POINT_CY: string;
+export declare const ARC_LABEL_SELECTED_AX: string;
+export declare const ARC_LABEL_SELECTED_AY: string;
+export declare const ARC_MIDDLE_ANGLE: string;
+export declare const ARC_QUADRANT: string;
+export declare const ARC_RADIAN: string;
+export declare const POLAR_START_RADIAN: number;
+export declare const POLAR_END_RADIAN: number;
+export declare const POLAR_START_ANGLE = -90;
+export declare const POLAR_END_ANGLE = 270;
+export declare const POLAR_DEFAULT_RADIUS = 0.6;

package/types/constant/scatter.d.ts

@@ -0,0 +1,7 @@
+import { ScaleEnum } from '@visactor/vscale';
+export declare const SCATTER_DEFAULT_SIZE = 10;
+export declare const SCATTER_DEFAULT_RANGE_SIZE: number[];
+export declare const SCATTER_DEFAULT_SIZE_SCALE_TYPE = ScaleEnum.Linear;
+export declare const SCATTER_DEFAULT_SHAPE = "circle";
+export declare const SCATTER_DEFAULT_SHAPE_SCALE_TYPE = ScaleEnum.Ordinal;
+export declare const SCATTER_DEFAULT_RANGE_SHAPE: string[];

package/types/constant/scroll-bar.d.ts

@@ -0,0 +1 @@
+export declare const SCROLL_BAR_DEFAULT_SIZE = 12;

package/types/constant/sunburst.d.ts

@@ -0,0 +1 @@
+export declare const SUNBURST_AUTO_VISIBLE_DEFAULT_THRESHOLD = 10;

package/types/constant/waterfall.d.ts

@@ -0,0 +1 @@
+export declare const WaterfallDefaultSeriesField: string;

package/types/constant/word-cloud.d.ts

@@ -0,0 +1,7 @@
+export declare const WORD_CLOUD_ANGLE: string;
+export declare const WORD_CLOUD_FILLING_ANGLE: string;
+export declare const WORD_CLOUD_WEIGHT: string;
+export declare const WORDCLOUD_COLOR: string;
+export declare const WORDCLOUD_DATA_TOTAL: string;
+export declare const WORD_CLOUD_TEXT: string;
+export declare const WORDCLOUD_SHAPE_DATA_TOTAL: string;

package/types/core/factory.d.ts

@@ -0,0 +1,48 @@
+import type { IChartConstructor, IChartOption, IChart } from '../chart/interface';
+import type { ISeriesConstructor, ISeriesOption } from '../series/interface';
+import type { IComponentConstructor } from '../component/interface';
+import type { IMarkOption, MarkConstructor } from '../mark/interface';
+import type { IRegion, IRegionConstructor } from '../region/interface';
+import type { IModelOption } from '../model/interface';
+import type { Transform, Parser } from '@visactor/vdataset';
+import type { ILayoutConstructor } from '../layout/interface';
+import type { MarkAnimationSpec } from '@visactor/vgrammar-core';
+export declare class Factory {
+    private static _charts;
+    private static _series;
+    private static _components;
+    private static _marks;
+    private static _regions;
+    private static _animations;
+    private static _implements;
+    static transforms: {
+        [key: string]: Transform;
+    };
+    static dataParser: {
+        [key: string]: Parser;
+    };
+    static _layout: {
+        [key: string]: ILayoutConstructor;
+    };
+    static registerChart(key: string, chart: IChartConstructor): void;
+    static registerSeries(key: string, series: ISeriesConstructor): void;
+    static registerComponent(key: string, cmp: IComponentConstructor): void;
+    static registerMark(key: string, mark: MarkConstructor): void;
+    static registerRegion(key: string, region: IRegionConstructor): void;
+    static registerTransform(key: string, transform: Transform): void;
+    static registerLayout(key: string, layout: ILayoutConstructor): void;
+    static registerAnimation(key: string, animation: (params?: any, preset?: any) => MarkAnimationSpec): void;
+    static registerImplement(key: string, implement: (...args: any) => void): void;
+    static createChart(chartType: string, spec: any, options: IChartOption): IChart | null;
+    static createRegion(regionType: string, spec: any, options: IModelOption): IRegion | null;
+    static createSeries(seriesType: string, spec: any, options: ISeriesOption): import("../series/interface").ISeries;
+    static createMark(markType: string, name: string, options: IMarkOption): import("../mark/interface").IMark;
+    static getComponents(): IComponentConstructor[];
+    static getComponentInKey(name: string): IComponentConstructor;
+    static getLayout(): ILayoutConstructor[];
+    static getLayoutInKey(name: string): ILayoutConstructor;
+    static getSeries(): ISeriesConstructor[];
+    static getSeriesInType(type: string): ISeriesConstructor;
+    static getAnimationInKey(key: string): (params?: any, preset?: any) => MarkAnimationSpec;
+    static getImplementInKey(key: string): (...args: any) => void;
+}

package/types/core/index.d.ts

@@ -0,0 +1,12 @@
+import { VChart } from './vchart';
+import { Factory } from './factory';
+export { VChart, Factory };
+export declare const version: string;
+export type { IVChart } from './interface';
+export type { IStateSpec, StateValueType } from '../compile/mark';
+export * from '../typings/spec/common';
+export * from '../event/interface';
+export * from '../theme/interface';
+export * from '../typings/spec/index';
+export * from '../theme/index';
+export { vglobal } from '@visactor/vrender-core';

package/types/core/instance-manager.d.ts

@@ -0,0 +1,10 @@
+import type { MaybeArray } from '../typings';
+import type { IVChart } from './interface';
+export declare class InstanceManager {
+    static readonly instances: Map<number, IVChart>;
+    static registerInstance(instance: IVChart): void;
+    static unregisterInstance(instance: IVChart): void;
+    static getInstance(id: number): IVChart | undefined;
+    static instanceExist(id: number): boolean;
+    static forEach(callbackfn: (instance: IVChart, id: number, map: Map<number, IVChart>) => void, excludeId?: MaybeArray<number>, thisArg?: any): void;
+}

package/types/core/interface.d.ts

@@ -0,0 +1,92 @@
+import type { DataSet } from '@visactor/vdataset';
+import type { IParserOptions } from '@visactor/vdataset/es/parser';
+import type { Datum, IMarkStateSpec, IPoint, IRegionQuerier, IShowTooltipOption, ISpec, ITooltipHandler, Maybe, MaybeArray, StringOrNumber } from '../typings';
+import type { IMorphConfig } from '../animation/spec';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { EventCallback, EventParams, EventQuery, EventType } from '../event/interface';
+import type { IMark } from '../mark/interface';
+import type { ISeries } from '../series/interface/series';
+import type { ITheme } from '../theme';
+import type { IComponent } from '../component/interface';
+import type { LayoutCallBack } from '../layout/interface';
+import type { Compiler } from '../compile/compiler';
+import type { IChart } from '../chart/interface';
+import type { IGradientColor, Stage } from '@visactor/vrender-core';
+import type { IThemeColorScheme } from '../theme/color-scheme/interface';
+export type DataLinkSeries = {
+    seriesId?: StringOrNumber;
+    seriesIndex?: number;
+};
+export type DataLinkAxis = {
+    axisId?: StringOrNumber;
+    axisIndex?: number;
+};
+export interface IVChart {
+    readonly id: number;
+    renderSync: (morphConfig?: IMorphConfig) => IVChart;
+    renderAsync: (morphConfig?: IMorphConfig) => Promise<IVChart>;
+    updateData: (id: StringOrNumber, data: Datum[] | string, options?: IParserOptions) => Promise<IVChart>;
+    updateDataInBatches: (list: {
+        id: string;
+        data: Datum[];
+        options?: IParserOptions;
+    }[]) => Promise<IVChart>;
+    updateDataSync: (id: StringOrNumber, data: Datum[], options?: IParserOptions) => IVChart;
+    updateSpec: (spec: ISpec, forceMerge?: boolean, morphConfig?: IMorphConfig) => Promise<IVChart>;
+    updateModelSpecSync: (filter: string | {
+        type: string;
+        index: number;
+    }, spec: unknown, forceMerge?: boolean, morphConfig?: IMorphConfig) => IVChart;
+    updateModelSpec: (filter: string | {
+        type: string;
+        index: number;
+    }, spec: unknown, forceMerge?: boolean, morphConfig?: IMorphConfig) => Promise<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;
+    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;
+    getCurrentTheme: () => ITheme;
+    getCurrentThemeName: () => string;
+    setCurrentTheme: (name: string) => Promise<IVChart>;
+    setTooltipHandler: (tooltipHandler: ITooltipHandler) => void;
+    getTooltipHandlerByUser: () => ITooltipHandler | undefined;
+    getTooltipHandler: () => ITooltipHandler | undefined;
+    showTooltip: (datum: Datum, options: IShowTooltipOption) => boolean;
+    hideTooltip: () => boolean;
+    getLegendDataById: (id: string) => Datum[];
+    getLegendDataByIndex: (index?: number) => Datum[];
+    getLegendSelectedDataById: (id: string) => StringOrNumber[];
+    getLegendSelectedDataByIndex: (index?: number) => StringOrNumber[];
+    setLegendSelectedDataById: (id: string, selectedData: StringOrNumber[]) => void;
+    setLegendSelectedDataByIndex: (index: number, selectedData: StringOrNumber[]) => void;
+    getDataURL: () => Promise<any>;
+    exportImg: (name?: string) => Promise<void>;
+    exportCanvas: () => HTMLCanvasElement | undefined;
+    getImageBuffer: () => void;
+    setLayout: (layout: LayoutCallBack) => void;
+    reLayout: () => void;
+    getCompiler: () => Compiler;
+    getChart: () => Maybe<IChart>;
+    getStage: () => Stage;
+    getCanvas: () => HTMLCanvasElement | undefined;
+    getContainer: () => Maybe<HTMLElement>;
+    getComponents: () => IComponent[];
+    getDataSet: () => Maybe<DataSet>;
+    convertDatumToPosition: (datum: Datum, dataLinkInfo?: DataLinkSeries, isRelativeToCanvas?: boolean) => IPoint | null;
+    convertValueToPosition: ((value: StringOrNumber, dataLinkInfo: DataLinkAxis, isRelativeToCanvas?: boolean) => number | null) & ((value: [StringOrNumber, StringOrNumber], dataLinkInfo: DataLinkSeries, isRelativeToCanvas?: boolean) => IPoint | null);
+    stopAnimation: () => void;
+    pauseAnimation: () => void;
+    resumeAnimation: () => void;
+}
+export interface IGlobalConfig {
+    uniqueTooltip?: boolean;
+}
+export interface IChartLevelTheme {
+    background?: string | IGradientColor;
+    fontFamily?: string;
+    colorScheme?: IThemeColorScheme;
+}

package/types/core/util.d.ts

@@ -0,0 +1,3 @@
+export declare const VCHART_UTILS: {
+    measureText: (text: string, textSpec?: Partial<import("@visactor/vrender-core").ITextGraphicAttribute>, option?: Partial<import("@visactor/vutils").ITextMeasureOption>, useNaiveCanvas?: boolean) => import("@visactor/vutils").ITextSize;
+};

package/types/core/vchart.d.ts

@@ -0,0 +1,149 @@
+import type { ISeries } from '../series/interface/series';
+import type { ILayoutConstructor, LayoutCallBack } from '../layout/interface';
+import type { IDataValues, IMarkStateSpec, IInitOption } from '../typings/spec/common';
+import type { ISeriesConstructor } from '../series/interface';
+import type { DimensionIndexOption, IChart, IChartConstructor } from '../chart/interface';
+import type { IComponentConstructor } from '../component/interface';
+import type { EventCallback, EventParams, EventQuery, EventType } from '../event/interface';
+import type { IParserOptions } from '@visactor/vdataset/es/parser';
+import type { Transform } from '@visactor/vdataset';
+import { DataSet, DataView } from '@visactor/vdataset';
+import type { Stage } from '@visactor/vrender-core';
+import type { GeoSourceType } from '../typings/geo';
+import type { GeoSourceOption } from '../series/map/geo-source';
+import type { IMark, MarkConstructor } from '../mark/interface';
+import type { ITooltipHandler } from '../typings/tooltip';
+import type { Datum, IPoint, IRegionQuerier, IShowTooltipOption, ISpec, Maybe, MaybeArray, StringOrNumber } from '../typings';
+import type { IBoundsLike, ILogger } from '@visactor/vutils';
+import { ThemeManager } from '../theme/theme-manager';
+import type { ITheme } from '../theme';
+import type { IModel, IUpdateSpecResult } from '../model/interface';
+import { Compiler } from '../compile/compiler';
+import type { IMorphConfig } from '../animation/spec';
+import type { DataLinkAxis, DataLinkSeries, IGlobalConfig, IVChart } from './interface';
+import { InstanceManager } from './instance-manager';
+export declare class VChart implements IVChart {
+    readonly id: number;
+    static useRegisters(comps: (() => void)[]): void;
+    static useChart(charts: IChartConstructor[]): void;
+    static useSeries(series: ISeriesConstructor[]): void;
+    static useComponent(components: IComponentConstructor[]): void;
+    static useMark(marks: MarkConstructor[]): void;
+    static useLayout(layouts: ILayoutConstructor[]): void;
+    static registerDataSetTransform(name: string, transform: Transform): void;
+    static registerMap(key: string, source: GeoSourceType, option?: GeoSourceOption): void;
+    static unregisterMap(key: string): void;
+    static getMap(key: string): GeoSourceType;
+    static hideTooltip(excludeId?: MaybeArray<number>): void;
+    static getLogger(): ILogger;
+    static readonly InstanceManager: typeof InstanceManager;
+    static readonly ThemeManager: typeof ThemeManager;
+    static globalConfig: IGlobalConfig;
+    static readonly Utils: {
+        measureText: (text: string, textSpec?: Partial<import("@visactor/vrender-core").ITextGraphicAttribute>, option?: Partial<import("@visactor/vutils").ITextMeasureOption>, useNaiveCanvas?: boolean) => import("@visactor/vutils").ITextSize;
+    };
+    protected _spec: any;
+    private _viewBox;
+    private _chart;
+    private _compiler;
+    private _event;
+    private _userEvents;
+    private _eventDispatcher;
+    private _dataSet;
+    getDataSet(): DataSet;
+    private _container?;
+    private _canvas?;
+    private _stage?;
+    private _autoSize;
+    private _option;
+    private _curSize;
+    private _observer;
+    private _currentThemeName;
+    private _currentChartLevelTheme;
+    private _onError?;
+    private _context;
+    constructor(spec: ISpec, options: IInitOption);
+    private _setSpec;
+    private _initChart;
+    private _releaseData;
+    private _bindVGrammarViewEvent;
+    private _bindResizeEvent;
+    private _unBindResizeEvent;
+    private _getCurSize;
+    private _doResize;
+    private _onResize;
+    private _initDataSet;
+    updateCustomConfigAndRerender(modifyConfig: () => IUpdateSpecResult | undefined, morphConfig?: IMorphConfig): Promise<IVChart>;
+    updateCustomConfigAndRerenderSync(modifyConfig: () => IUpdateSpecResult | undefined, morphConfig?: IMorphConfig): IVChart;
+    protected _reCompile(updateResult: IUpdateSpecResult): void;
+    renderSync(morphConfig?: IMorphConfig): IVChart;
+    renderAsync(morphConfig?: IMorphConfig): Promise<IVChart>;
+    release(): void;
+    updateData(id: StringOrNumber, data: DataView | Datum[] | string, options?: IParserOptions): Promise<IVChart>;
+    updateDataInBatches(list: {
+        id: string;
+        data: Datum[];
+        options?: IParserOptions;
+    }[]): Promise<IVChart>;
+    updateDataSync(id: StringOrNumber, data: DataView | Datum[], options?: IParserOptions): IVChart;
+    updateFullDataSync(data: IDataValues | IDataValues[], reRender?: boolean): IVChart;
+    updateFullData(data: IDataValues | IDataValues[], reRender?: boolean): Promise<IVChart>;
+    updateSpec(spec: ISpec, forceMerge?: boolean, morphConfig?: IMorphConfig): Promise<IVChart>;
+    updateSpecSync(spec: ISpec, forceMerge?: boolean, morphConfig?: IMorphConfig): IVChart;
+    updateModelSpec(filter: string | {
+        type: string;
+        index: number;
+    } | ((model: IModel) => boolean), spec: unknown, forceMerge?: boolean, morphConfig?: IMorphConfig): Promise<IVChart>;
+    updateModelSpecSync(filter: string | {
+        type: string;
+        index: number;
+    } | ((model: IModel) => boolean), spec: unknown, forceMerge?: boolean, morphConfig?: IMorphConfig): IVChart;
+    protected _updateModelSpec(model: IModel, spec: unknown, sync?: boolean, forceMerge?: boolean, morphConfig?: IMorphConfig): IVChart | Promise<IVChart>;
+    resize(width: number, height: number): Promise<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: string, handler?: EventCallback<EventParams>): 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;
+    private _updateCurrentTheme;
+    private _shouldChartResize;
+    private _getBackground;
+    getCurrentTheme(): ITheme;
+    getCurrentThemeName(): string;
+    setCurrentTheme(name: string): Promise<IVChart>;
+    setCurrentThemeSync(name: string): IVChart;
+    private _getTooltipComponent;
+    setTooltipHandler(tooltipHandler: ITooltipHandler): void;
+    getTooltipHandlerByUser(): ITooltipHandler | undefined;
+    getTooltipHandler(): ITooltipHandler | undefined;
+    showTooltip(datum: Datum, options: IShowTooltipOption): boolean;
+    hideTooltip(): boolean;
+    getLegendDataById(id: string): Datum[];
+    getLegendDataByIndex(index?: number): Datum[];
+    getLegendSelectedDataById(id: string): StringOrNumber[];
+    getLegendSelectedDataByIndex(index?: number): StringOrNumber[];
+    setLegendSelectedDataById(id: string, selectedData: StringOrNumber[]): void;
+    setLegendSelectedDataByIndex(index: number, selectedData: StringOrNumber[]): void;
+    getDataURL(): Promise<string>;
+    exportImg(name?: string): Promise<void>;
+    exportCanvas(): HTMLCanvasElement | undefined;
+    getImageBuffer(): any;
+    setLayout(layout: LayoutCallBack): void;
+    reLayout(): void;
+    getCompiler(): Compiler;
+    getChart(): IChart;
+    getStage(): Stage;
+    getCanvas(): HTMLCanvasElement | undefined;
+    getContainer(): Maybe<HTMLElement>;
+    getComponents(): import("../component/interface").IComponent[];
+    setDimensionIndex(value: StringOrNumber, opt?: DimensionIndexOption): void;
+    stopAnimation(): void;
+    pauseAnimation(): void;
+    resumeAnimation(): void;
+    convertDatumToPosition(datum: Datum, dataLinkInfo?: DataLinkSeries, isRelativeToCanvas?: boolean): IPoint | null;
+    convertValueToPosition(value: StringOrNumber, dataLinkInfo: DataLinkAxis, isRelativeToCanvas?: boolean): number | null;
+    convertValueToPosition(value: [StringOrNumber, StringOrNumber], dataLinkInfo: DataLinkSeries, isRelativeToCanvas?: boolean): IPoint | null;
+}
+export declare const registerVChartCore: () => void;

package/types/data/initialize.d.ts

@@ -0,0 +1,21 @@
+import type { utilFunctionCtx } from '../typings/params';
+import { DataSet, DataView } from '@visactor/vdataset';
+import type { IDataViewOptions } from '@visactor/vdataset';
+import type { IDataValues } from '../typings/spec/common';
+export declare function initializeData(): void;
+export declare function initCSVData(): void;
+export declare function initData(): void;
+export declare function initFoldData(): void;
+export declare function dataViewFromDataView(rawData: DataView, dataSet?: DataSet, op?: IDataViewOptions): DataView;
+export declare function dataToDataView(data: DataView | IDataValues, dataSet: DataSet, sourceDataViews?: DataView[], ctx?: utilFunctionCtx): DataView;
+export declare function updateDataViewInData(dataView: DataView, data: IDataValues, forceMerge: boolean): void;
+export declare enum TransformLevel {
+    copyDataView = -10,
+    treemapFilter = -8,
+    treemapFlatten = -7,
+    dotObjFlat = -7,
+    linkDotInfo = -7,
+    sankeyLayout = -7,
+    dataZoomFilter = -6,
+    legendFilter = -5
+}

package/types/data/parser/array.d.ts

@@ -0,0 +1,2 @@
+import type { Parser } from '@visactor/vdataset';
+export declare const arrayParser: Parser;

package/types/data/parser/scale.d.ts

@@ -0,0 +1,2 @@
+import type { Parser } from '@visactor/vdataset';
+export declare const scaleParser: Parser;

package/types/data/register.d.ts

@@ -0,0 +1,3 @@
+import type { DataSet, Parser, Transform } from '@visactor/vdataset';
+export declare function registerDataSetInstanceTransform(dataSet: DataSet, name: string, transform: Transform): void;
+export declare function registerDataSetInstanceParser(dataSet: DataSet, name: string, parse: Parser): void;

package/types/data/transforms/add-property.d.ts

@@ -0,0 +1,12 @@
+export type AddVChartPropertyContext = {
+    keyMap: Map<string, number>;
+    needDefaultSeriesField: boolean;
+    defaultSeriesField?: string;
+    getKey?: (d: any, i: number, context: AddVChartPropertyContext) => string;
+    categoryField?: string;
+};
+export interface IAddVChartPropertyOpt {
+    beforeCall: () => AddVChartPropertyContext;
+    call: (d: any, i: number, context: AddVChartPropertyContext) => void;
+}
+export declare const addVChartProperty: (data: Array<any>, op: IAddVChartPropertyOpt) => any[];