@visactor/vchart/esm/core/vchart.d.ts

charts lib based @visactor/VGrammar

import type { ISeries } from '../series/interface/series';
import type { ILayoutConstructor, LayoutCallBack } from '../layout/interface';
import type { IDataValues, IMarkStateSpec, IInitOption } from '../typings/spec/common';
import { RenderModeEnum } from '../typings/spec/common';
import type { ISeriesConstructor } from '../series/interface';
import { type DimensionIndexOption, type IChart, type IChartConstructor, type IChartOption, type IChartSpecInfo } from '../chart/interface';
import type { IComponentConstructor } from '../component/interface';
import type { EventCallback, EventQuery, EventType, ExtendEventParam } from '../event/interface';
import type { IParserOptions, Transform } from '@visactor/vdataset';
import { DataSet, DataView } from '@visactor/vdataset';
import type { IStage } from '@visactor/vrender-core';
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, IUpdateDataResult, 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 registerSVG(key: string, source: GeoSourceType, option?: GeoSourceOption): void;
    static unregisterSVG(key: string): void;
    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;
    };
    static readonly vglobal: import("@visactor/vrender-core").IGlobal;
    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 _cachedProcessedTheme;
    private _onError?;
    private _context;
    private _isReleased;
    private _chartPlugin?;
    private _onResize?;
    constructor(spec: ISpec, options: IInitOption);
    private _setNewSpec;
    private _getSpecFromOriginalSpec;
    private _initChartSpec;
    private _updateSpecInfo;
    private _initChart;
    private _releaseData;
    private _bindViewEvent;
    private _bindResizeEvent;
    private _unBindResizeEvent;
    getCurrentSize(): {
        width: number;
        height: number;
    };
    private _doResize;
    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, parserOptions?: IParserOptions, userUpdateOptions?: IUpdateDataResult): Promise<IVChart>;
    private _updateDataById;
    updateDataInBatches(list: {
        id: string;
        data: Datum[];
        options?: IParserOptions;
    }[]): Promise<IVChart>;
    updateDataSync(id: StringOrNumber, data: DataView | Datum[] | string, parserOptions?: IParserOptions, userUpdateOptions?: IUpdateDataResult): IVChart;
    updateFullDataSync(data: IDataValues | IDataValues[], reRender?: boolean, userUpdateOptions?: IUpdateSpecResult): IVChart;
    updateFullData(data: IDataValues | IDataValues[], reRender?: boolean): Promise<IVChart>;
    updateSpec(spec: ISpec, forceMerge?: boolean, morphConfig?: IMorphConfig, userUpdateOptions?: IUpdateSpecResult): Promise<IVChart>;
    updateSpecSync(spec: ISpec, forceMerge?: boolean, morphConfig?: IMorphConfig, userUpdateOptions?: IUpdateSpecResult): 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<ExtendEventParam>): void;
    on(eType: EventType, query: EventQuery, handler: EventCallback<ExtendEventParam>): void;
    off(eType: EventType, handler?: EventCallback<ExtendEventParam>): void;
    updateState(state: Record<string, Omit<IMarkStateSpec<unknown>, 'style'>>, filter?: (series: ISeries, mark: IMark, stateKey: string) => boolean): void;
    setSelected(datum: MaybeArray<any> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier): void;
    setHovered(datum: MaybeArray<Datum> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier): void;
    clearState(state: string): void;
    clearAllStates(): void;
    clearSelected(): void;
    clearHovered(): 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 _setFontFamilyTheme;
    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(): IStage;
    getCanvas(): HTMLCanvasElement | undefined;
    getContainer(): Maybe<HTMLElement>;
    getComponents(): import("../component/interface").IComponent[];
    getScale(scaleId: string): import("@visactor/vscale").IBaseScale;
    setDimensionIndex(value: StringOrNumber, opt?: DimensionIndexOption): void;
    stopAnimation(): void;
    pauseAnimation(): void;
    resumeAnimation(): void;
    convertDatumToPosition(datum: Datum, dataLinkInfo?: DataLinkSeries, isRelativeToCanvas?: boolean, checkInViewData?: 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;
    updateIndicatorDataById(id: string, datum?: Datum): void;
    updateIndicatorDataByIndex(index?: number, datum?: Datum): void;
    geoZoomByIndex(regionIndex: number, zoom: number, center?: {
        x: number;
        y: number;
    }): void;
    geoZoomById(regionId: string | number, zoom: number, center?: {
        x: number;
        y: number;
    }): void;
    _geoZoomByQuery(query: MaybeArray<IRegionQuerier>, zoom: number, center?: {
        x: number;
        y: number;
    }): void;
    private _initChartPlugin;
    private _chartPluginApply;
    protected _getMode(): (typeof RenderModeEnum)["desktop-browser"] | "desktop-browser" | "mobile-browser" | "node" | "worker" | "miniApp" | "wx" | "tt" | "harmony" | "desktop-miniApp" | "lynx";
    protected getTheme: (...keys: string[]) => any;
    protected _getChartOption(type: string): IChartOption;
}
export declare const registerVChartCore: () => void;