@visactor/vchart-types 0.10.0-alpha.2

package/types/constant/index.d.ts

@@ -0,0 +1,111 @@
+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,
+    Interaction = 700
+}
+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,3 @@
+export declare const USER_LAYOUT_RECT_LEVEL = 9;
+export declare const DEFAULT_LAYOUT_RECT_LEVEL = 0;
+export declare const DEFAULT_LAYOUT_RECT_LEVEL_MIN = -1;

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,13 @@
+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_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/expression-function.d.ts

@@ -0,0 +1,12 @@
+export declare class ExpressionFunction {
+    functions: {
+        [key: string]: Function;
+    };
+    static instance_: ExpressionFunction;
+    static instance(): ExpressionFunction;
+    constructor();
+    registerFunction(name: string, fun: Function): void;
+    unregisterFunction(name: string): void;
+    getFunction(name: string): Function | null;
+    getFunctionNameList(): string[] | null;
+}

package/types/core/factory.d.ts

@@ -0,0 +1,65 @@
+import type { IChartConstructor, IChartOption, IChart, IChartSpecTransformerOption, IChartSpecTransformer } from '../chart/interface';
+import type { ISeriesConstructor, ISeriesMarkInfo, ISeriesOption, SeriesMarkNameEnum } from '../series/interface';
+import type { IComponentConstructor } from '../component/interface';
+import type { IMarkOption, MarkConstructor } from '../mark/interface';
+import type { IRegion, IRegionConstructor } from '../region/interface';
+import type { IBaseModelSpecTransformer, IBaseModelSpecTransformerOption, IModelOption } from '../model/interface';
+import type { Transform, Parser } from '@visactor/vdataset';
+import type { ILayoutConstructor } from '../layout/interface';
+import type { MarkAnimationSpec } from '@visactor/vgrammar-core';
+import type { IChartPluginConstructor } from '../plugin/chart/interface';
+import type { IComponentPluginConstructor } from '../plugin/components/interface';
+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;
+    private static _chartPlugin;
+    private static _componentPlugin;
+    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, alwaysCheck?: boolean): 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 registerChartPlugin(key: string, plugin: IChartPluginConstructor): void;
+    static registerComponentPlugin(key: string, plugin: IComponentPluginConstructor): void;
+    static createChart(chartType: string, spec: any, options: IChartOption): IChart | null;
+    static createChartSpecTransformer(chartType: string, option: IChartSpecTransformerOption): IChartSpecTransformer | null;
+    static createRegion(regionType: string, spec: any, options: IModelOption): IRegion | null;
+    static createRegionSpecTransformer(regionType: string, options: IBaseModelSpecTransformerOption): IBaseModelSpecTransformer | null;
+    static createSeries(seriesType: string, spec: any, options: ISeriesOption): import("../series/interface").ISeries;
+    static createSeriesSpecTransformer(seriesType: string, options: IBaseModelSpecTransformerOption): IBaseModelSpecTransformer | null;
+    static createMark(markType: string, name: string, options: IMarkOption): import("../mark/interface").IMark;
+    static getComponents(): {
+        cmp: IComponentConstructor;
+        alwaysCheck?: boolean;
+    }[];
+    static getComponentInKey(name: string): IComponentConstructor;
+    static getLayout(): ILayoutConstructor[];
+    static getLayoutInKey(name: string): ILayoutConstructor;
+    static getSeries(): ISeriesConstructor[];
+    static getSeriesInType(type: string): ISeriesConstructor;
+    static getRegionInType(type: string): IRegionConstructor;
+    static getAnimationInKey(key: string): (params?: any, preset?: any) => MarkAnimationSpec;
+    static getImplementInKey(key: string): (...args: any) => void;
+    static getSeriesMarkMap(seriesType: string): Partial<Record<SeriesMarkNameEnum, ISeriesMarkInfo>>;
+    static getChartPlugins(): IChartPluginConstructor[];
+    static getComponentPlugins(): IComponentPluginConstructor[];
+    static getComponentPluginInType(type: string): IComponentPluginConstructor;
+}

package/types/core/index.d.ts

@@ -0,0 +1,15 @@
+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 '../constant';
+export * from './interface';
+export * from '../typings/spec/index';
+export * from '../theme/index';
+export { vglobal } from '@visactor/vrender-core';
+export * from '../plugin';

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,106 @@
+import type { DataSet } from '@visactor/vdataset';
+import type { IParserOptions } from '@visactor/vdataset/es/parser';
+import type { Datum, 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 { 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, IChartSpecInfo } from '../chart/interface';
+import type { Stage } from '@visactor/vrender-core';
+import type { IContainerSize } from '@visactor/vrender-components';
+export type DataLinkSeries = {
+    seriesId?: StringOrNumber;
+    seriesIndex?: number;
+};
+export type DataLinkAxis = {
+    axisId?: StringOrNumber;
+    axisIndex?: number;
+};
+export interface IVChartConstructor {
+    new (spec: ISpec, options: IInitOption): IVChart;
+}
+export interface IVChart {
+    readonly id: number;
+    renderSync: (morphConfig?: IMorphConfig, resetMediaQuery?: boolean) => IVChart;
+    renderAsync: (morphConfig?: IMorphConfig, resetMediaQuery?: boolean) => 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, resetMediaQuery?: boolean) => Promise<IVChart>;
+    updateSpecSync: (spec: ISpec, forceMerge?: boolean, morphConfig?: IMorphConfig, resetMediaQuery?: boolean) => void;
+    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>;
+    updateSpecAndRecompile: (spec: ISpec, forceMerge: boolean, option: IVChartRenderOption) => boolean;
+    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;
+    registerFunction: (key: string, fun: Function) => void;
+    unregisterFunction: (key: string) => void;
+    getFunction: (key: string) => Function | null;
+    getFunctionList: () => string[] | null;
+    getSpecInfo: () => IChartSpecInfo;
+    setRuntimeSpec: (spec: any) => void;
+    getSpec: () => any;
+    getCurrentSize: () => IContainerSize;
+}
+export interface IGlobalConfig {
+    uniqueTooltip?: boolean;
+}
+export interface IVChartRenderOption {
+    morphConfig?: IMorphConfig;
+    transformSpec?: boolean;
+    actionSource?: VChartRenderActionSource;
+}
+export type VChartRenderActionSource = 'render' | 'updateSpec' | 'updateModelSpec' | 'setCurrentTheme' | 'updateSpecAndRecompile';

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,185 @@
+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, IChartSpecInfo } 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, DataView } from '@visactor/vdataset';
+import { DataSet } 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, IVChartRenderOption } 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 registerFunction(key: string, fun: Function): void;
+    static unregisterFunction(key: string): void;
+    static getFunction(key: string): Function | null;
+    static getFunctionList(): string[] | null;
+    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 _originalSpec: any;
+    protected _spec: any;
+    getSpec(): any;
+    protected _specInfo: IChartSpecInfo;
+    getSpecInfo(): IChartSpecInfo;
+    private _viewBox;
+    private _chart;
+    private _chartSpecTransformer;
+    private _compiler;
+    private _event;
+    private _userEvents;
+    private _eventDispatcher;
+    private _dataSet;
+    getDataSet(): DataSet;
+    private _container?;
+    private _canvas?;
+    private _stage?;
+    private _autoSize;
+    private _option;
+    private _currentSize;
+    private _observer;
+    private _currentThemeName;
+    private _currentTheme;
+    private _onError?;
+    private _context;
+    private _isReleased;
+    private _chartPlugin?;
+    constructor(spec: ISpec, options: IInitOption);
+    private _setNewSpec;
+    private _getSpecFromOriginalSpec;
+    private _initChartSpec;
+    private _updateSpecInfo;
+    private _initChart;
+    private _releaseData;
+    private _bindVGrammarViewEvent;
+    private _bindResizeEvent;
+    private _unBindResizeEvent;
+    getCurrentSize(): {
+        width: number;
+        height: number;
+    };
+    private _doResize;
+    private _onResize;
+    private _initDataSet;
+    updateCustomConfigAndRerender(updateSpecResult: IUpdateSpecResult | (() => IUpdateSpecResult), sync?: boolean, option?: IVChartRenderOption): IVChart | Promise<IVChart>;
+    protected _updateCustomConfigAndRecompile(updateSpecResult: IUpdateSpecResult, option?: IVChartRenderOption): boolean;
+    protected _reCompile(updateResult: IUpdateSpecResult, morphConfig?: IMorphConfig): void;
+    protected _beforeRender(option?: IVChartRenderOption): boolean;
+    protected _afterRender(): boolean;
+    renderSync(morphConfig?: IMorphConfig): IVChart;
+    renderAsync(morphConfig?: IMorphConfig): Promise<IVChart>;
+    protected _renderSync(option?: IVChartRenderOption): IVChart;
+    protected _renderAsync(option?: IVChartRenderOption): Promise<IVChart>;
+    private _updateAnimateState;
+    release(): void;
+    updateData(id: StringOrNumber, data: DataView | Datum[] | string, options?: IParserOptions): Promise<IVChart>;
+    private _updateDataById;
+    updateDataInBatches(list: {
+        id: string;
+        data: Datum[];
+        options?: IParserOptions;
+    }[]): Promise<IVChart>;
+    updateDataSync(id: StringOrNumber, data: DataView | Datum[] | string, 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;
+    updateSpecAndRecompile(spec: ISpec, forceMerge?: boolean, option?: IVChartRenderOption): boolean;
+    private _updateSpec;
+    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>;
+    resizeSync(width: number, height: number): 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: 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;
+    protected _setCurrentTheme(name?: string): IUpdateSpecResult;
+    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;
+    getFunction(key: string): Function | null;
+    registerFunction(key: string, fun: Function): void;
+    unregisterFunction(key: string): void;
+    getFunctionList(): string[];
+    setRuntimeSpec(spec: any): void;
+    private _initChartPlugin;
+    private _chartPluginApply;
+}
+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[];