@visactor/vchart-types 0.10.0-alpha.2

package/types/animation/animate-manager.d.ts

@@ -0,0 +1,12 @@
+import { StateManager } from '../compile/signal/state-manager';
+import type { StateValueMap } from '../compile/signal/interface';
+import type { IAnimate, IAnimateState } from './interface';
+import { AnimationStateEnum } from './interface';
+export declare class AnimateManager extends StateManager implements IAnimate {
+    protected _stateMap: IAnimateState & StateValueMap;
+    readonly id: number;
+    protected stateKeyToSignalName: (key: string) => string;
+    getAnimationStateSignalName(): string;
+    updateAnimateState(state: AnimationStateEnum, noRender?: boolean): void;
+    protected _getDefaultStateMap(): IAnimateState & StateValueMap;
+}

package/types/animation/config.d.ts

@@ -0,0 +1,60 @@
+export declare const DEFAULT_ANIMATION_CONFIG: {
+    appear: {
+        duration: number;
+        easing: string;
+    };
+    update: {
+        type: string;
+        duration: number;
+        easing: string;
+    };
+    enter: {
+        duration: number;
+        easing: string;
+    };
+    exit: {
+        duration: number;
+        easing: string;
+    };
+    disappear: {
+        duration: number;
+        easing: string;
+    };
+};
+export declare const ScaleInOutAnimation: {
+    appear: {
+        type: string;
+    };
+    enter: {
+        type: string;
+    };
+    exit: {
+        type: string;
+    };
+    disappear: {
+        type: string;
+    };
+};
+export declare const FadeInOutAnimation: {
+    appear: {
+        type: string;
+    };
+    enter: {
+        type: string;
+    };
+    exit: {
+        type: string;
+    };
+    disappear: {
+        type: string;
+    };
+};
+export declare const registerScaleInOutAnimation: () => void;
+export declare const registerFadeInOutAnimation: () => void;
+export declare const registerCartesianGroupClipAnimation: () => void;
+export declare const registerLineAnimation: () => void;
+export declare const registerVGrammarCommonAnimation: () => void;
+export declare const registerVGrammarRectAnimation: () => void;
+export declare const registerVGrammarArcAnimation: () => void;
+export declare const registerVGrammarLineOrAreaAnimation: () => void;
+export declare const registerVGrammarPolygonAnimation: () => void;

package/types/animation/interface.d.ts

@@ -0,0 +1,29 @@
+export type { MarkAnimationSpec } from '@visactor/vgrammar-core';
+import type { ICompilable } from '../compile/interface';
+export declare enum AnimationStateEnum {
+    appear = "appear",
+    disappear = "disappear",
+    enter = "enter",
+    update = "update",
+    state = "state",
+    exit = "exit",
+    normal = "normal",
+    none = "none"
+}
+export type IAnimationState = keyof typeof AnimationStateEnum;
+export interface IAnimateState {
+    animationState: {
+        callback: (datum: any, element: any) => AnimationStateEnum;
+    };
+}
+export interface IAnimate extends ICompilable {
+    id: number;
+    updateAnimateState: (state: AnimationStateEnum, noRender?: boolean) => void;
+    getAnimationStateSignalName: () => string;
+}
+export interface ICartesianGroupAnimationParams {
+    direction: () => 'x' | 'y';
+    orient: () => 'positive' | 'negative';
+    width: () => number;
+    height: () => number;
+}

package/types/animation/spec.d.ts

@@ -0,0 +1,24 @@
+import type { IAnimationConfig } from '@visactor/vgrammar-core';
+import type { EasingType } from '@visactor/vrender-core';
+export type { IRunningConfig as IMorphConfig, IMorphAnimationConfig } from '@visactor/vgrammar-core';
+export type IStateAnimateSpec<Preset extends string> = {
+    preset?: Preset | false;
+    duration?: number;
+    delay?: number;
+    easing?: EasingType;
+    oneByOne?: boolean;
+};
+export type IMarkAnimateSpec<MarkName extends string> = Partial<Record<MarkName, false | IAnimationConfig | IAnimationConfig[]>>;
+export interface IAnimationSpec<MarkName extends string, Preset extends string> {
+    animationAppear?: boolean | IStateAnimateSpec<Preset> | IMarkAnimateSpec<MarkName>;
+    animationEnter?: boolean | Omit<IStateAnimateSpec<Preset>, 'preset'> | IMarkAnimateSpec<MarkName>;
+    animationUpdate?: boolean | Omit<IStateAnimateSpec<Preset>, 'preset'> | IMarkAnimateSpec<MarkName>;
+    animationExit?: boolean | Omit<IStateAnimateSpec<Preset>, 'preset'> | IMarkAnimateSpec<MarkName>;
+    animationDisappear?: boolean | Omit<IStateAnimateSpec<Preset>, 'preset'> | IMarkAnimateSpec<MarkName>;
+    animationNormal?: IMarkAnimateSpec<MarkName>;
+}
+export interface IMorphSeriesSpec {
+    enable?: boolean;
+    morphKey?: string;
+    morphElementKey?: string;
+}

package/types/animation/utils.d.ts

@@ -0,0 +1,18 @@
+import type { IAnimationConfig } from '@visactor/vgrammar-core';
+import type { MarkAnimationSpec, IAnimationState } from './interface';
+import type { IStateAnimateSpec, IAnimationSpec } from './spec';
+import type { SeriesMarkNameEnum } from '../series/interface/type';
+import type { ISeries } from '../series';
+import type { ISeriesSpec } from '../typings';
+import type { ISeriesMarkAttributeContext } from '../compile/mark';
+export declare const AnimationStates: string[];
+export declare function animationConfig<Preset extends string>(defaultConfig?: MarkAnimationSpec, userConfig?: Partial<Record<IAnimationState, boolean | IStateAnimateSpec<Preset> | IAnimationConfig | IAnimationConfig[]>>, params?: {
+    dataIndex: (datum: any) => number;
+    dataCount: () => number;
+}): MarkAnimationSpec;
+export declare function userAnimationConfig<M extends string, Preset extends string>(markName: SeriesMarkNameEnum | string, spec: IAnimationSpec<M, Preset>, ctx: ISeriesMarkAttributeContext): Partial<Record<"none" | "normal" | "state" | "exit" | "update" | "appear" | "enter" | "disappear", boolean | IAnimationConfig | IAnimationConfig[] | IStateAnimateSpec<Preset>>>;
+export declare function shouldMarkDoMorph(spec: ISeriesSpec & IAnimationSpec<string, string>, markName: string): boolean;
+export declare function isTimeLineAnimation(animationConfig: IAnimationConfig): boolean;
+export declare function isChannelAnimation(animationConfig: IAnimationConfig): boolean;
+export declare function uniformAnimationConfig<Preset extends string>(config: Partial<Record<IAnimationState, boolean | IStateAnimateSpec<Preset> | IAnimationConfig | IAnimationConfig[]>>, ctx: ISeriesMarkAttributeContext): Partial<Record<"none" | "normal" | "state" | "exit" | "update" | "appear" | "enter" | "disappear", boolean | IAnimationConfig | IAnimationConfig[] | IStateAnimateSpec<Preset>>>;
+export declare function isAnimationEnabledForSeries(series: ISeries): boolean;

package/types/chart/area/area-transformer.d.ts

@@ -0,0 +1,6 @@
+import { CartesianChartSpecTransformer } from '../cartesian';
+import type { IAreaChartSpec } from './interface';
+export declare class AreaChartSpecTransformer<T extends IAreaChartSpec = IAreaChartSpec> extends CartesianChartSpecTransformer<T> {
+    protected _getDefaultSeriesSpec(spec: T): any;
+    transformSpec(spec: T): void;
+}

package/types/chart/area/area.d.ts

@@ -0,0 +1,14 @@
+import type { IAreaChartSpec } from './interface';
+import { AreaChartSpecTransformer } from './area-transformer';
+import { BaseChart } from '../base';
+export declare class AreaChart<T extends IAreaChartSpec = IAreaChartSpec> extends BaseChart<T> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof AreaChartSpecTransformer;
+    readonly transformerConstructor: typeof AreaChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _canStack: boolean;
+}
+export declare const registerAreaChart: () => void;

package/types/chart/area/index.d.ts

@@ -0,0 +1,3 @@
+export * from './area';
+export * from './interface';
+export * from './area-transformer';

package/types/chart/area/interface.d.ts

@@ -0,0 +1,7 @@
+import type { ICartesianChartSpec } from '../cartesian/interface';
+import type { IAreaSeriesSpec } from '../../series/area/interface';
+import type { IChartExtendsSeriesSpec } from '../../typings/spec';
+export interface IAreaChartSpec extends ICartesianChartSpec, IChartExtendsSeriesSpec<IAreaSeriesSpec> {
+    type: 'area';
+    series?: IAreaSeriesSpec[];
+}

package/types/chart/bar/3d/bar-3d-transformer.d.ts

@@ -0,0 +1,6 @@
+import type { AdaptiveSpec } from '../../../typings';
+import type { IBar3dChartSpec } from '../interface';
+import { BarChartSpecTransformer } from '../bar-transformer';
+export declare class Bar3dChartSpecTransformer<T extends IBar3dChartSpec = IBar3dChartSpec> extends BarChartSpecTransformer<AdaptiveSpec<T, 'type' | 'series'>> {
+    protected _getDefaultSeriesSpec(spec: AdaptiveSpec<T, 'type' | 'series'>): any;
+}

package/types/chart/bar/3d/bar-3d.d.ts

@@ -0,0 +1,14 @@
+import type { IBar3dChartSpec } from '../interface';
+import { BarChart } from '../bar';
+import type { AdaptiveSpec } from '../../../typings';
+import { Bar3dChartSpecTransformer } from './bar-3d-transformer';
+export declare class Bar3dChart<T extends IBar3dChartSpec = IBar3dChartSpec> extends BarChart<AdaptiveSpec<T, 'type' | 'series'>> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof Bar3dChartSpecTransformer;
+    readonly transformerConstructor: typeof Bar3dChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerBar3dChart: () => void;

package/types/chart/bar/3d/index.d.ts

@@ -0,0 +1,2 @@
+export * from './bar-3d';
+export * from './bar-3d-transformer';

package/types/chart/bar/bar-3d.d.ts

@@ -0,0 +1,9 @@
+import { BarChart } from './bar';
+export declare class Bar3dChart extends BarChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _getDefaultSeriesSpec(spec: any): any;
+}
+export declare const registerBar3dChart: () => void;

package/types/chart/bar/bar-transformer.d.ts

@@ -0,0 +1,6 @@
+import { CartesianChartSpecTransformer } from '../cartesian';
+import type { IBarChartSpec } from './interface';
+export declare class BarChartSpecTransformer<T extends IBarChartSpec = IBarChartSpec> extends CartesianChartSpecTransformer<T> {
+    protected _getDefaultSeriesSpec(spec: T): any;
+    transformSpec(spec: T): void;
+}

package/types/chart/bar/bar.d.ts

@@ -0,0 +1,14 @@
+import type { IBarChartSpec } from './interface';
+import { BarChartSpecTransformer } from './bar-transformer';
+import { BaseChart } from '../base';
+export declare class BarChart<T extends IBarChartSpec = IBarChartSpec> extends BaseChart<T> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof BarChartSpecTransformer;
+    readonly transformerConstructor: typeof BarChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _canStack: boolean;
+}
+export declare const registerBarChart: () => void;

package/types/chart/bar/index.d.ts

@@ -0,0 +1,4 @@
+export * from './bar';
+export * from './3d';
+export * from './interface';
+export * from './bar-transformer';

package/types/chart/bar/interface.d.ts

@@ -0,0 +1,11 @@
+import type { IBarSeriesSpec, IBar3dSeriesSpec } from '../../series/bar/interface';
+import type { IChartExtendsSeriesSpec } from '../../typings/spec/common';
+import type { ICartesianChartSpec } from '../cartesian/interface';
+export interface IBarChartSpec extends ICartesianChartSpec, IChartExtendsSeriesSpec<IBarSeriesSpec> {
+    type: 'bar';
+    series?: IBarSeriesSpec[];
+}
+export interface IBar3dChartSpec extends ICartesianChartSpec, IChartExtendsSeriesSpec<IBar3dSeriesSpec> {
+    type: 'bar3d';
+    series?: IBar3dSeriesSpec[];
+}

package/types/chart/base/base-chart-transformer.d.ts

@@ -0,0 +1,22 @@
+import type { IChartSpec } from '../../typings';
+import type { IChartSpecInfo, IChartSpecTransformer, IChartSpecTransformerOption } from '../interface';
+import type { IModelConstructor, IModelSpecInfo } from '../../model/interface';
+import type { IRegionConstructor } from '../../region/interface';
+import type { ISeriesConstructor } from '../../series';
+import type { IComponentConstructor } from '../../component/interface/common';
+export declare class BaseChartSpecTransformer<T extends IChartSpec> implements IChartSpecTransformer {
+    readonly type: string;
+    readonly seriesType: string;
+    protected _option: IChartSpecTransformerOption;
+    constructor(option: IChartSpecTransformerOption);
+    initChartSpec(chartSpec: T): IChartSpecInfo;
+    transformSpec(chartSpec: T): void;
+    transformModelSpec(chartSpec: T): IChartSpecInfo;
+    createSpecInfo(chartSpec: T, transform?: (constructor: IModelConstructor, specInfo: IModelSpecInfo, chartSpecInfo?: IChartSpecInfo) => void): IChartSpecInfo;
+    protected _isValidSeries(seriesType: string): boolean;
+    protected _getDefaultSeriesSpec(chartSpec: any): any;
+    forEachRegionInSpec<K>(chartSpec: T, callbackfn: (constructor: IRegionConstructor, specInfo: IModelSpecInfo, chartSpecInfo?: IChartSpecInfo) => K, chartSpecInfo?: IChartSpecInfo): K[];
+    forEachSeriesInSpec<K>(chartSpec: T, callbackfn: (constructor: ISeriesConstructor, specInfo: IModelSpecInfo, chartSpecInfo?: IChartSpecInfo) => K, chartSpecInfo?: IChartSpecInfo): K[];
+    forEachComponentInSpec<K>(chartSpec: T, callbackfn: (constructor: IComponentConstructor, specInfo: IModelSpecInfo, chartSpecInfo?: IChartSpecInfo) => K, chartSpecInfo?: IChartSpecInfo): K[];
+    transformSeriesSpec(spec: T): void;
+}

package/types/chart/base/base-chart.d.ts

@@ -0,0 +1,149 @@
+import type { IRegionConstructor } from '../../region/interface';
+import { ChartData } from '../chart-meta/data';
+import type { Datum, IMarkStateSpec, IRegionQuerier, MaybeArray, IPadding, IRect, StringOrNumber, IChartSpec, IDataValues, ILayoutRect, ILayoutOrientPadding } from '../../typings';
+import type { ILayoutItem, LayoutCallBack } from '../../layout/interface';
+import type { ILayoutModelState, IModel, IModelOption, IModelSpecInfo, IUpdateSpecResult } from '../../model/interface';
+import type { IChart, IChartLayoutOption, IChartRenderOption, IChartOption, IChartEvaluateOption, ILayoutParams, DimensionIndexOption, IChartSpecTransformerOption, IChartSpecTransformer } from '../interface';
+import type { ISeries, ISeriesConstructor } from '../../series/interface';
+import type { IRegion } from '../../region/interface';
+import type { IComponent, IComponentConstructor } from '../../component/interface';
+import type { IMark } from '../../mark/interface';
+import type { IEvent } from '../../event/interface';
+import type { DataView } from '@visactor/vdataset';
+import type { DataSet } from '@visactor/vdataset/es/data-set';
+import { Stack } from '../stack';
+import type { IParserOptions } from '@visactor/vdataset/es/parser';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { IRunningConfig as IMorphConfig, IView } from '@visactor/vgrammar-core';
+import { CompilableBase } from '../../compile/compilable-base';
+import type { IGlobalScale } from '../../scale/interface';
+import type { IRectMark } from '../../mark/rect';
+export declare class BaseChart<T extends IChartSpec> extends CompilableBase implements IChart {
+    readonly type: string;
+    readonly seriesType: string;
+    readonly transformerConstructor: new (option: IChartSpecTransformerOption) => IChartSpecTransformer;
+    readonly id: number;
+    protected _transformer: IChartSpecTransformer;
+    protected _spec: T;
+    getSpec(): T;
+    setSpec(s: T): void;
+    getOption(): IChartOption;
+    protected _regions: IRegion[];
+    protected _series: ISeries[];
+    protected _components: IComponent[];
+    protected _layoutFunc: LayoutCallBack;
+    protected _layoutRect: IRect;
+    getLayoutRect(): IRect;
+    protected _viewRect: ILayoutRect;
+    getViewRect(): ILayoutRect;
+    protected _viewBox: IBoundsLike;
+    protected _layoutTag: boolean;
+    getLayoutTag(): boolean;
+    setLayoutTag(tag: boolean, morphConfig?: IMorphConfig, reLayout?: boolean): boolean;
+    protected _modelOption: IModelOption;
+    protected _globalScale: IGlobalScale;
+    protected _idMap: Map<number, IModel | IMark>;
+    protected _event: IEvent;
+    getEvent(): IEvent;
+    protected _dataSet: DataSet;
+    protected _chartData: ChartData;
+    get chartData(): ChartData;
+    protected _option: IChartOption;
+    readonly state: ILayoutModelState;
+    protected _stack: Stack;
+    protected _canStack: boolean;
+    padding: IPadding;
+    protected _paddingSpec: ILayoutOrientPadding;
+    protected _canvasRect: ILayoutRect;
+    protected _backgroundMark: IRectMark;
+    constructor(spec: T, option: IChartOption);
+    created(): void;
+    init(): void;
+    reDataFlow(): void;
+    onResize(width: number, height: number, reRender?: boolean): void;
+    updateViewBox(viewBox: IBoundsLike, reLayout: boolean): void;
+    private _createBackground;
+    protected _createRegion(constructor: IRegionConstructor, specInfo: IModelSpecInfo): void;
+    protected _createSeries(constructor: ISeriesConstructor, specInfo: IModelSpecInfo): void;
+    getAllSeries: () => ISeries[];
+    getSeriesById(id: number): ISeries | undefined;
+    protected _createComponent(constructor: IComponentConstructor, specInfo: IModelSpecInfo): void;
+    getAllComponents(): IComponent[];
+    getAllModels(): IModel[];
+    getModelInFilter(filter: string | {
+        type: string;
+        index: number;
+    } | ((model: IModel) => boolean)): IModel;
+    private _createLayout;
+    setLayout(layout: LayoutCallBack): void;
+    private _initLayoutFunc;
+    layout(params: ILayoutParams): void;
+    onLayoutStart(option: IChartLayoutOption): void;
+    onLayoutEnd(option: IChartLayoutOption): void;
+    onEvaluateEnd(option: IChartEvaluateOption): void;
+    getLayoutElements(): ILayoutItem[];
+    getRegionsInIndex: (index?: number[]) => IRegion[];
+    getAllRegions: () => IRegion[];
+    getRegionsInIds: (ids: number[]) => IRegion[];
+    getRegionsInQuerier: (region?: MaybeArray<IRegionQuerier>) => IRegion[];
+    getRegionsInUserId: (userId: StringOrNumber) => IRegion | undefined;
+    getRegionsInUserIdOrIndex: (user_ids?: StringOrNumber[], index?: number[]) => IRegion[];
+    getComponents: () => IComponent[];
+    getSeriesInIndex: (index?: number[]) => ISeries[];
+    getSeriesInIds: (ids?: number[]) => ISeries[];
+    getSeriesInUserId: (userId: StringOrNumber) => ISeries | undefined;
+    getSeriesInUserIdOrIndex: (user_ids?: StringOrNumber[], index?: number[]) => ISeries[];
+    getComponentByIndex: (key: string, index: number) => IComponent;
+    getComponentsByKey: (key: string) => IComponent[];
+    getComponentByUserId: (userId: StringOrNumber) => IComponent;
+    getComponentsByType: (type: string) => IComponent[];
+    getModelById(id: number): IModel | undefined;
+    getModelByUserId(userId: StringOrNumber): IModel | undefined;
+    getAllMarks(): IMark[];
+    getMarkById(id: number): IMark | undefined;
+    updateData(id: StringOrNumber, data: unknown, updateGlobalScale?: boolean, options?: IParserOptions): void;
+    updateFullData(data: IDataValues | IDataValues[], updateGlobalScale?: boolean): void;
+    onRender(option: IChartRenderOption): void;
+    setCanvasRect(width: number, height: number): void;
+    getCanvasRect(): Omit<IRect, 'x' | 'y'>;
+    getSeriesData(id: StringOrNumber | undefined, index: number | undefined): DataView | undefined;
+    private _transformSpecScale;
+    private _createGlobalScale;
+    updateGlobalScaleDomain(): void;
+    updateGlobalScale(result: IUpdateSpecResult): void;
+    updateGlobalScaleTheme(): void;
+    updateSpec(spec: T): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    updateChartConfig(result: IUpdateSpecResult, oldSpec: IChartSpec): void;
+    updateDataSpec(result: IUpdateSpecResult): void;
+    updateRegionSpec(result: IUpdateSpecResult): void;
+    updateComponentSpec(result: IUpdateSpecResult): void;
+    updateSeriesSpec(result: IUpdateSpecResult): void;
+    getCanvas(): HTMLCanvasElement;
+    private _updateLayoutRect;
+    setCurrentTheme(): void;
+    clear(): void;
+    compile(): void;
+    afterCompile(): void;
+    compileLayout(): void;
+    compileBackground(): void;
+    compileRegions(): void;
+    compileSeries(): void;
+    compileComponents(): void;
+    release(): void;
+    onLayout(srView: IView): 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 _initEvent;
+    protected _enableMarkAnimation(states: string | string[]): void;
+    protected _disableMarkAnimation(states: string | string[]): void;
+    protected _setStateInDatum(stateKey: string, checkReverse: boolean, datum: MaybeArray<Datum> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier): void;
+    setDimensionIndex(value: StringOrNumber, opt: DimensionIndexOption): void;
+    getColorScheme(): import("../..").IThemeColorScheme;
+}

package/types/chart/base/index.d.ts

@@ -0,0 +1,2 @@
+export * from './base-chart';
+export * from './base-chart-transformer';

package/types/chart/base/util.d.ts

@@ -0,0 +1,7 @@
+import type { IModelSpecInfo } from '../../model/interface';
+import type { IRegionSpec, IRegionSpecInfo } from '../../region/interface';
+import type { IChartSpecInfo } from '../interface';
+import type { ISeriesSpecInfo } from '../../series/interface';
+import type { ISeriesSpec } from '../../typings';
+export declare const getRelatedRegionInfo: (modelInfo: IModelSpecInfo, currentChartSpecInfo: IChartSpecInfo) => IRegionSpecInfo<IRegionSpec> | undefined;
+export declare const getRelatedSeriesInfo: (modelInfo: IModelSpecInfo, currentChartSpecInfo: IChartSpecInfo) => Array<ISeriesSpecInfo<ISeriesSpec>> | undefined;

package/types/chart/base-chart.d.ts

@@ -0,0 +1,148 @@
+import { ChartData } from './chart-meta/data';
+import type { ISeriesSpec, Datum, IMarkStateSpec, IRegionQuerier, MaybeArray, IPadding, IRect, StringOrNumber, IChartSpec, IDataValues, ILayoutRect, ILayoutOrientPadding } from '../typings';
+import type { ILayoutItem, LayoutCallBack } from '../layout/interface';
+import type { ILayoutModelState, IModel, IModelOption, IUpdateSpecResult } from '../model/interface';
+import type { IChart, IChartLayoutOption, IChartRenderOption, IChartOption, IChartEvaluateOption, ILayoutParams, DimensionIndexOption } from './interface';
+import type { ISeries } from '../series/interface';
+import type { IRegion } from '../region/interface';
+import type { IComponent } from '../component/interface';
+import { type IMark } from '../mark/interface';
+import type { IEvent } from '../event/interface';
+import type { DataView } from '@visactor/vdataset';
+import type { DataSet } from '@visactor/vdataset/es/data-set';
+import { Stack } from './stack';
+import type { IParserOptions } from '@visactor/vdataset/es/parser';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { IRunningConfig as IMorphConfig, IView } from '@visactor/vgrammar-core';
+import { CompilableBase } from '../compile/compilable-base';
+import type { IGlobalScale } from '../scale/interface';
+import type { IRectMark } from '../mark/rect';
+export declare class BaseChart extends CompilableBase implements IChart {
+    readonly type: string;
+    readonly id: number;
+    protected _spec: any;
+    getSpec(): any;
+    setSpec(s: any): void;
+    getOption(): IChartOption;
+    protected _regions: IRegion[];
+    protected _series: ISeries[];
+    protected _components: IComponent[];
+    protected _layoutFunc: LayoutCallBack;
+    protected _layoutRect: IRect;
+    getLayoutRect(): IRect;
+    protected _viewRect: ILayoutRect;
+    getViewRect(): ILayoutRect;
+    protected _viewBox: IBoundsLike;
+    protected _layoutTag: boolean;
+    getLayoutTag(): boolean;
+    setLayoutTag(tag: boolean, morphConfig?: IMorphConfig, reLayout?: boolean): boolean;
+    protected _modelOption: IModelOption;
+    protected _globalScale: IGlobalScale;
+    protected _idMap: Map<number, IModel | IMark>;
+    protected _event: IEvent;
+    getEvent(): IEvent;
+    protected _dataSet: DataSet;
+    protected _chartData: ChartData;
+    get chartData(): ChartData;
+    protected _option: IChartOption;
+    readonly state: ILayoutModelState;
+    protected _stack: Stack;
+    protected _canStack: boolean;
+    padding: IPadding;
+    protected _paddingSpec: ILayoutOrientPadding;
+    protected _canvasRect: ILayoutRect;
+    protected _backgroundMark: IRectMark;
+    constructor(spec: any, option: IChartOption);
+    created(): void;
+    transformSpec(spec: any): void;
+    init(): void;
+    reDataFlow(): void;
+    onResize(width: number, height: number): void;
+    updateViewBox(viewBox: IBoundsLike, reLayout: boolean): void;
+    private _createBackground;
+    private _createRegion;
+    protected _createSeries(seriesSpec: ISeriesSpec[]): void;
+    getAllSeries: () => ISeries[];
+    getSeriesById(id: number): ISeries | undefined;
+    private _createComponent;
+    private _createComponents;
+    getAllComponents(): IComponent[];
+    getAllModels(): IModel[];
+    getModelInFilter(filter: string | {
+        type: string;
+        index: number;
+    } | ((model: IModel) => boolean)): IModel;
+    private _createLayout;
+    setLayout(layout: LayoutCallBack): void;
+    private _initLayoutFunc;
+    layout(params: ILayoutParams): void;
+    onLayoutStart(option: IChartLayoutOption): void;
+    onLayoutEnd(option: IChartLayoutOption): void;
+    onEvaluateEnd(option: IChartEvaluateOption): void;
+    getLayoutElements(): ILayoutItem[];
+    getRegionsInIndex: (index?: number[]) => IRegion[];
+    getAllRegions: () => IRegion[];
+    getRegionsInIds: (ids: number[]) => IRegion[];
+    getRegionsInQuerier: (region?: MaybeArray<IRegionQuerier>) => IRegion[];
+    getRegionsInUserId: (userId: StringOrNumber) => IRegion | undefined;
+    getRegionsInUserIdOrIndex: (user_ids?: StringOrNumber[], index?: number[]) => IRegion[];
+    getComponents: () => IComponent[];
+    getSeriesInIndex: (index?: number[]) => ISeries[];
+    getSeriesInIds: (ids?: number[]) => ISeries[];
+    getSeriesInUserId: (userId: StringOrNumber) => ISeries | undefined;
+    getSeriesInUserIdOrIndex: (user_ids?: StringOrNumber[], index?: number[]) => ISeries[];
+    getComponentByIndex: (key: string, index: number) => IComponent;
+    getComponentsByKey: (key: string) => IComponent[];
+    getComponentByUserId: (userId: StringOrNumber) => IComponent;
+    getModelById(id: number): IModel | undefined;
+    getModelByUserId(userId: StringOrNumber): IModel | undefined;
+    getAllMarks(): IMark[];
+    getMarkById(id: number): IMark | undefined;
+    updateData(id: StringOrNumber, data: unknown, updateGlobalScale?: boolean, options?: IParserOptions): void;
+    updateFullData(data: IDataValues | IDataValues[], updateGlobalScale?: boolean): void;
+    onRender(option: IChartRenderOption): void;
+    setCanvasRect(width: number, height: number): void;
+    getCanvasRect(): Omit<IRect, 'x' | 'y'>;
+    getSeriesData(id: StringOrNumber | undefined, index: number | undefined): DataView | undefined;
+    private _transformSpecScale;
+    private _createGlobalScale;
+    updateGlobalScaleDomain(): void;
+    updateGlobalScale(result: IUpdateSpecResult): void;
+    updateGlobalScaleTheme(): void;
+    updateSpec(spec: any): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    updateChartConfig(result: IUpdateSpecResult, oldSpec: IChartSpec): void;
+    updateDataSpec(result: IUpdateSpecResult): void;
+    updateRegionSpec(result: IUpdateSpecResult): void;
+    updateComponentSpec(result: IUpdateSpecResult): void;
+    updateSeriesSpec(result: IUpdateSpecResult): void;
+    getCanvas(): HTMLCanvasElement;
+    protected isValidSeries(seriesType: string): boolean;
+    protected _getDefaultSeriesSpec(spec: any): any;
+    private _updateLayoutRect;
+    setCurrentTheme(): void;
+    clear(): void;
+    compile(): void;
+    afterCompile(): void;
+    compileLayout(): void;
+    compileBackground(): void;
+    compileRegions(): void;
+    compileSeries(): void;
+    compileComponents(): void;
+    release(): void;
+    onLayout(srView: IView): 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 _initEvent;
+    protected _enableMarkAnimation(states: string | string[]): void;
+    protected _disableMarkAnimation(states: string | string[]): void;
+    protected _setStateInDatum(stateKey: string, checkReverse: boolean, datum: MaybeArray<Datum> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier): void;
+    setDimensionIndex(value: StringOrNumber, opt: DimensionIndexOption): void;
+    getColorScheme(): import("..").IThemeColorScheme;
+}

package/types/chart/box-plot/box-plot-transformer.d.ts

@@ -0,0 +1,6 @@
+import { CartesianChartSpecTransformer } from '../cartesian';
+import type { IBoxPlotChartSpec } from './interface';
+export declare class BoxPlotChartSpecTransformer<T extends IBoxPlotChartSpec = IBoxPlotChartSpec> extends CartesianChartSpecTransformer<T> {
+    protected _getDefaultSeriesSpec(spec: T): any;
+    transformSpec(spec: T): void;
+}

package/types/chart/box-plot/box-plot.d.ts

@@ -0,0 +1,13 @@
+import type { IBoxPlotChartSpec } from './interface';
+import { BoxPlotChartSpecTransformer } from './box-plot-transformer';
+import { BaseChart } from '../base';
+export declare class BoxPlotChart<T extends IBoxPlotChartSpec = IBoxPlotChartSpec> extends BaseChart<T> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof BoxPlotChartSpecTransformer;
+    readonly transformerConstructor: typeof BoxPlotChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerBoxplotChart: () => void;

package/types/chart/box-plot/index.d.ts

@@ -0,0 +1,3 @@
+export * from './box-plot';
+export * from './interface';
+export * from './box-plot-transformer';

package/types/chart/box-plot/interface.d.ts

@@ -0,0 +1,7 @@
+import type { IBoxPlotSeriesSpec } from '../../series/box-plot/interface';
+import type { ICartesianChartSpec } from '../cartesian/interface';
+import type { IChartExtendsSeriesSpec } from '../../typings/spec/common';
+export interface IBoxPlotChartSpec extends ICartesianChartSpec, IChartExtendsSeriesSpec<IBoxPlotSeriesSpec> {
+    type: 'boxPlot';
+    series?: IBoxPlotSeriesSpec[];
+}

package/types/chart/cartesian/cartesian-transformer.d.ts

@@ -0,0 +1,8 @@
+import { BaseChartSpecTransformer } from '../base';
+import type { ICartesianChartSpec } from './interface';
+export declare class CartesianChartSpecTransformer<T extends ICartesianChartSpec> extends BaseChartSpecTransformer<T> {
+    protected needAxes(): boolean;
+    protected _isValidSeries(type: string): boolean;
+    protected _getDefaultSeriesSpec(spec: any): any;
+    transformSpec(spec: T): void;
+}