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

package/build/es5/animation/animate-manager.d.ts

@@ -0,0 +1,12 @@
+import { StateManager } from '../compile/signal';
+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/build/es5/animation/config.d.ts

@@ -0,0 +1,25 @@
+import type { MarkAnimationSpec } from './interface';
+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 DEFAULT_MARK_ANIMATION: Record<string, (params?: any, preset?: any) => MarkAnimationSpec>;

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

@@ -0,0 +1,29 @@
+export type { MarkAnimationSpec } from '@visactor/vgrammar';
+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/build/es5/animation/spec.d.ts

@@ -0,0 +1,24 @@
+import type { IAnimationConfig } from '@visactor/vgrammar';
+import type { EasingType } from '@visactor/vrender';
+export type { IMorphConfig, IMorphAnimationConfig } from '@visactor/vgrammar';
+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/build/es5/animation/utils.d.ts

@@ -0,0 +1,19 @@
+import type { IAnimationConfig } from '@visactor/vgrammar';
+import type { MarkAnimationSpec, IAnimationState } from './interface';
+import type { IStateAnimateSpec, IAnimationSpec, IMorphSeriesSpec } from './spec';
+import type { SeriesMarkNameEnum } from '../series/interface';
+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;
+}): MarkAnimationSpec;
+export declare function userAnimationConfig<M extends string, Preset extends string>(markName: SeriesMarkNameEnum | string, spec: IAnimationSpec<M, Preset>): {
+    appear: any;
+    disappear: any;
+    enter: any;
+    exit: any;
+    update: any;
+    normal: any;
+};
+export declare function shouldDoMorph(hasAnimation: boolean, morphConfig?: IMorphSeriesSpec, animationConfig?: ReturnType<typeof userAnimationConfig>): boolean;
+export declare function isTimeLineAnimation(animationConfig: IAnimationConfig): boolean;
+export declare function isChannelAnimation(animationConfig: IAnimationConfig): boolean;

package/build/es5/chart/area/area.d.ts

@@ -0,0 +1,10 @@
+import { CartesianChart } from '../cartesian/cartesian';
+import type { IAreaChartSpec } from './interface';
+export declare class AreaChart extends CartesianChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _getDefaultSeriesSpec(spec: IAreaChartSpec): any;
+    transformSpec(spec: any): void;
+}

package/build/es5/chart/area/index.d.ts

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

package/build/es5/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/build/es5/chart/bar/bar-3d.d.ts

@@ -0,0 +1,8 @@
+import { CartesianChart } from '../cartesian/cartesian';
+export declare class Bar3dChart extends CartesianChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _getDefaultSeriesSpec(spec: any): any;
+}

package/build/es5/chart/bar/bar.d.ts

@@ -0,0 +1,9 @@
+import { CartesianChart } from '../cartesian/cartesian';
+export declare class BarChart extends CartesianChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _getDefaultSeriesSpec(spec: any): any;
+    transformSpec(spec: any): void;
+}

package/build/es5/chart/bar/index.d.ts

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

package/build/es5/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/build/es5/chart/base-chart.d.ts

@@ -0,0 +1,146 @@
+import type { ISeriesSpec, Datum, IMarkStateSpec, IRegionQuerier, MaybeArray, IPadding, IRect, StringOrNumber, IChartSpec } from '../typings';
+import type { LayoutCallBack } from '../layout/interface';
+import type { ILayoutModelState, ILayoutOrientPadding, ILayoutRect, 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 { ITheme } from '../theme/interface';
+import type { IParserOptions } from '@visactor/vdataset/es/parser';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { IMorphConfig, IMark as IVGrammarMark, IView } from '@visactor/vgrammar';
+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 _theme: ITheme;
+    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 _modelOption: IModelOption;
+    protected _globalScale: IGlobalScale;
+    protected _idMap: Map<number, IModel | IMark>;
+    protected _event: IEvent;
+    getEvent(): IEvent;
+    protected _dataSet: DataSet;
+    protected _option: IChartOption;
+    protected _layoutTag: boolean;
+    getLayoutTag(): boolean;
+    setLayoutTag(tag: boolean, morphConfig?: IMorphConfig): boolean;
+    readonly state: ILayoutModelState;
+    protected _stack: Stack;
+    padding: IPadding;
+    protected _paddingSpec: ILayoutOrientPadding;
+    protected _canvasRect: ILayoutRect;
+    protected _backgroundMark: IRectMark;
+    constructor(spec: any, option: IChartOption);
+    created(): void;
+    transformSpec(spec: any): void;
+    init(options?: any): void;
+    onResize(width: number, height: number): void;
+    updateViewBox(viewBox: IBoundsLike): void;
+    createBackground(bg: IChartSpec['background']): void;
+    createRegion(regionSpec: any[]): void;
+    initRegion(): void;
+    createSeries(seriesSpec: ISeriesSpec[]): void;
+    initSeries(): void;
+    getAllSeries: () => ISeries[];
+    getSeriesById(id: number): ISeries | undefined;
+    private _createComponent;
+    createComponent(spec: any): void;
+    initComponent(): void;
+    getAllComponents(): IComponent[];
+    getAllModels(): IModel[];
+    createLayout(): void;
+    setLayout(layout: LayoutCallBack): void;
+    private _initLayoutFunc;
+    layout(params: ILayoutParams): void;
+    onLayoutStart(option: IChartLayoutOption): void;
+    onLayoutEnd(option: IChartLayoutOption): void;
+    onEvaluateEnd(option: IChartEvaluateOption): void;
+    getLayoutElements(): (IRegion | ISeries | IComponent)[];
+    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;
+    updateParseData(id: string, data: Datum[], options?: IParserOptions): void;
+    updateData(id: StringOrNumber, data: unknown, updateGlobalScale?: boolean, options?: IParserOptions): void;
+    onRender(option: IChartRenderOption): void;
+    getCanvasRect(): Omit<IRect, 'x' | 'y'>;
+    getSeriesData(id: StringOrNumber | undefined, index: number | undefined): DataView | undefined;
+    private _transformSpecScale;
+    createGlobalScale(): void;
+    updateGlobalScaleDomain(): void;
+    updateGlobalScale(result: IUpdateSpecResult): void;
+    updateGlobalScaleTheme(): void;
+    updateSpec(spec: any, morphConfig?: IMorphConfig): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    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 _mergeUpdateResult;
+    private _updateLayoutRect;
+    getCurrentTheme(): ITheme;
+    setCurrentTheme(theme: ITheme): void;
+    protected setRegionTheme(): void;
+    protected setComponentTheme(theme: ITheme): void;
+    protected setSeriesTheme(theme: ITheme): void;
+    compile(): void;
+    afterCompile(): void;
+    compileLayout(): void;
+    compileBackground(): void;
+    compileRegions(): void;
+    compileSeries(): void;
+    compileComponents(): void;
+    release(): void;
+    onLayout(srView: IView): void;
+    checkUpdate(mark: IVGrammarMark, model: IModel, sceneRoot: IVGrammarMark): 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;
+    initEvent(): void;
+    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;
+}

package/build/es5/chart/box-plot/box-plot.d.ts

@@ -0,0 +1,10 @@
+import { CartesianChart } from '../cartesian/cartesian';
+import type { IBoxPlotChartSpec } from './interface';
+export declare class BoxPlotChart extends CartesianChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _getDefaultSeriesSpec(spec: IBoxPlotChartSpec): any;
+    transformSpec(spec: IBoxPlotChartSpec): void;
+}

package/build/es5/chart/box-plot/index.d.ts

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

package/build/es5/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/build/es5/chart/cartesian/cartesian.d.ts

@@ -0,0 +1,8 @@
+import { BaseChart } from '../base-chart';
+export declare class CartesianChart extends BaseChart {
+    readonly seriesType: string;
+    protected isValidSeries(type: string): boolean;
+    protected needAxes(): boolean;
+    protected _getDefaultSeriesSpec(spec: any): any;
+    transformSpec(spec: any): void;
+}

package/build/es5/chart/cartesian/index.d.ts

@@ -0,0 +1,2 @@
+export * from './cartesian';
+export * from './interface';

package/build/es5/chart/cartesian/interface.d.ts

@@ -0,0 +1,15 @@
+import type { IChartSpec } from '../../typings/spec/common';
+import type { ICartesianAxisSpec } from '../../component/axis/cartesian/interface';
+import type { ICartesianCrosshairSpec } from '../../component/crosshair/interface';
+import type { IMarkLineSpec } from '../../component/marker/mark-line/interface';
+import type { IMarkAreaSpec } from '../../component/marker/mark-area/interface';
+import type { IMarkPointSpec } from '../../component/marker/mark-point/interface';
+import type { DirectionType } from '../../typings';
+export interface ICartesianChartSpec extends IChartSpec {
+    direction?: DirectionType;
+    axes?: ICartesianAxisSpec[];
+    crosshair?: ICartesianCrosshairSpec | ICartesianCrosshairSpec[];
+    markLine?: IMarkLineSpec;
+    markArea?: IMarkAreaSpec;
+    markPoint?: IMarkPointSpec;
+}

package/build/es5/chart/circle-packing/circle-packing.d.ts

@@ -0,0 +1,11 @@
+import type { ICirclePackingSeriesSpec } from '../../series/circle-packing/interface';
+import { BaseChart } from '../base-chart';
+import type { ICirclePackingChartSpec } from './interface';
+export declare class CirclePackingChart extends BaseChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected getDefaultSeriesSpec(spec: ICirclePackingChartSpec): ICirclePackingSeriesSpec;
+    transformSpec(spec: ICirclePackingChartSpec): void;
+}

package/build/es5/chart/circle-packing/index.d.ts

@@ -0,0 +1,2 @@
+export * from './interface';
+export * from './circle-packing';

package/build/es5/chart/circle-packing/interface.d.ts

@@ -0,0 +1,6 @@
+import type { ICirclePackingSeriesSpec } from '../../series/circle-packing/interface';
+import type { IChartExtendsSeriesSpec, IChartSpec } from '../../typings/spec/common';
+export interface ICirclePackingChartSpec extends IChartSpec, IChartExtendsSeriesSpec<ICirclePackingSeriesSpec> {
+    type: 'circlePacking';
+    series?: ICirclePackingSeriesSpec[];
+}

package/build/es5/chart/common/common.d.ts

@@ -0,0 +1,6 @@
+import { BaseChart } from '../base-chart';
+export declare class CommonChart extends BaseChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+}

package/build/es5/chart/common/index.d.ts

@@ -0,0 +1,2 @@
+export * from './interface';
+export * from './common';

package/build/es5/chart/common/interface.d.ts

@@ -0,0 +1,40 @@
+import type { ILineSeriesSpec } from '../../series/line/interface';
+import type { IAreaSeriesSpec } from '../../series/area/interface';
+import type { IChartSpec } from '../../typings/spec/common';
+import type { IBar3dSeriesSpec, IBarSeriesSpec } from '../../series/bar/interface';
+import type { IRangeColumnChartSpec } from '../range-column';
+import type { IRangeAreaChartSpec } from '../range-area';
+import type { IDotSeriesSpec } from '../../series/dot/interface';
+import type { IMapSeriesSpec } from '../../series/map/interface';
+import type { IPie3dSeriesSpec, IPieSeriesSpec } from '../../series/pie/interface';
+import type { ILinkSeriesSpec } from '../../series/link/interface';
+import type { IRadarSeriesSpec } from '../../series/radar/interface';
+import type { IRoseSeriesSpec } from '../../series/rose/interface';
+import type { IScatterSeriesSpec } from '../../series/scatter/interface';
+import type { IWordCloud3dSeriesSpec, IWordCloudSeriesSpec } from '../../series/word-cloud/interface';
+import type { IGaugePointerSeriesSpec, IGaugeSeriesSpec } from '../../series/gauge';
+import type { IBoxPlotSeriesSpec } from '../../series/box-plot/interface';
+import type { ICirclePackingSeriesSpec } from '../../series/circle-packing/interface';
+import type { IFunnelSeriesSpec, IFunnel3dSeriesSpec } from '../../series/funnel/interface';
+import type { IHeatmapSeriesSpec } from '../../series/heatmap/interface';
+import type { ICircularProgressSeriesSpec } from '../../series/progress/circular/interface';
+import type { ILinearProgressSeriesSpec } from '../../series/progress/linear/interface';
+import type { ISankeySeriesSpec } from '../../series/sankey/interface';
+import type { ISunburstSeriesSpec } from '../../series/sunburst/interface';
+import type { ITreemapSeriesSpec } from '../../series/treemap/interface';
+import type { IWaterfallSeriesSpec } from '../../series/waterfall/interface';
+import type { ICartesianAxisSpec, IPolarAxisSpec } from '../../component';
+import type { ICartesianCrosshairSpec, IPolarCrosshairSpec } from '../../component/crosshair/interface';
+import type { IMarkLineSpec } from '../../component/marker/mark-line/interface';
+import type { IMarkAreaSpec } from '../../component/marker/mark-area/interface';
+import type { IMarkPointSpec } from '../../component/marker/mark-point/interface';
+export interface ICommonChartSpec extends Omit<IChartSpec, 'series'> {
+    type: 'common';
+    seriesField?: string;
+    series?: (IAreaSeriesSpec | ILineSeriesSpec | IBar3dSeriesSpec | IBarSeriesSpec | IRangeColumnChartSpec | IRangeAreaChartSpec | IDotSeriesSpec | IMapSeriesSpec | IPie3dSeriesSpec | IPieSeriesSpec | ILinkSeriesSpec | IRadarSeriesSpec | IRoseSeriesSpec | IScatterSeriesSpec | ICircularProgressSeriesSpec | ILinearProgressSeriesSpec | IWordCloudSeriesSpec | IWordCloud3dSeriesSpec | IFunnelSeriesSpec | IFunnel3dSeriesSpec | IBoxPlotSeriesSpec | IGaugeSeriesSpec | ISankeySeriesSpec | ITreemapSeriesSpec | ISunburstSeriesSpec | ICirclePackingSeriesSpec | IWaterfallSeriesSpec | IHeatmapSeriesSpec | IGaugePointerSeriesSpec)[];
+    axes?: ICartesianAxisSpec[] | IPolarAxisSpec[];
+    crosshair?: ICartesianCrosshairSpec | ICartesianCrosshairSpec[] | IPolarCrosshairSpec | IPolarCrosshairSpec[];
+    markLine?: IMarkLineSpec;
+    markArea?: IMarkAreaSpec;
+    markPoint?: IMarkPointSpec;
+}

package/build/es5/chart/funnel/base.d.ts

@@ -0,0 +1,9 @@
+import type { IFunnelSeriesSpec } from '../../series/funnel/interface';
+import type { IFunnelChartSpec } from './interface';
+import { BaseChart } from '../base-chart';
+export declare class BaseFunnelChart extends BaseChart {
+    seriesType: string;
+    protected needAxes(): boolean;
+    protected _getDefaultSeriesSpec(spec: IFunnelChartSpec): IFunnelSeriesSpec;
+    transformSpec(spec: IFunnelChartSpec): void;
+}

package/build/es5/chart/funnel/funnel-3d.d.ts

@@ -0,0 +1,7 @@
+import { BaseFunnelChart } from './base';
+export declare class Funnel3dChart extends BaseFunnelChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+}

package/build/es5/chart/funnel/funnel.d.ts

@@ -0,0 +1,7 @@
+import { BaseFunnelChart } from './base';
+export declare class FunnelChart extends BaseFunnelChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+}

package/build/es5/chart/funnel/index.d.ts

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

package/build/es5/chart/funnel/interface.d.ts

@@ -0,0 +1,9 @@
+import type { IChartExtendsSeriesSpec } from '../..';
+import type { IFunnelSeriesSpec, IFunnel3dSeriesSpec } from '../../series/funnel/interface';
+import type { IChartSpec } from '../../typings/spec';
+export interface IFunnelChartSpec extends IChartSpec, IChartExtendsSeriesSpec<IFunnelSeriesSpec> {
+    type: 'funnel';
+}
+export interface IFunnel3dChartSpec extends IChartSpec, IChartExtendsSeriesSpec<IFunnel3dSeriesSpec> {
+    type: 'funnel3d';
+}

package/build/es5/chart/gauge/gauge.d.ts

@@ -0,0 +1,11 @@
+import { ProgressLikeChart } from '../polar/progress-like';
+export declare class GaugeChart extends ProgressLikeChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _getDefaultSeriesSpec(spec: any): any;
+    protected _getDefaultCircularProgressSeriesSpec(spec: any): any;
+    transformSpec(spec: any): void;
+    protected _transformGaugeAxisSpec(spec: any): void;
+}

package/build/es5/chart/gauge/index.d.ts

@@ -0,0 +1,2 @@
+export * from './interface';
+export * from './gauge';

package/build/es5/chart/gauge/interface.d.ts

@@ -0,0 +1,10 @@
+import type { IChartSpec } from '../../typings/spec/common';
+import type { IPolarAxisSpec } from '../../component/axis/polar/interface';
+import type { IGaugePointerSeriesSpec, IGaugeSeriesSpec } from '../../series/gauge';
+import type { ILinearAxisSpec } from '../../component/axis/interface';
+import type { ICircularProgressSeriesSpec } from '../../series/progress/circular/interface';
+export interface IGaugeChartSpec extends IChartSpec, Omit<IGaugePointerSeriesSpec, 'data' | 'type' | 'morph'> {
+    type: 'gauge';
+    gauge?: Omit<IGaugeSeriesSpec, 'data'> | Omit<ICircularProgressSeriesSpec, 'data'>;
+    axes?: (IPolarAxisSpec | ILinearAxisSpec)[];
+}

package/build/es5/chart/heatmap/heatmap.d.ts

@@ -0,0 +1,8 @@
+import { CartesianChart } from '../cartesian/cartesian';
+export declare class HeatmapChart extends CartesianChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _getDefaultSeriesSpec(spec: any): any;
+}

package/build/es5/chart/heatmap/index.d.ts

@@ -0,0 +1,2 @@
+export * from './heatmap';
+export * from './interface';

package/build/es5/chart/heatmap/interface.d.ts

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

package/build/es5/chart/histogram/base.d.ts

@@ -0,0 +1,5 @@
+import { CartesianChart } from '../cartesian/cartesian';
+export declare class BaseHistogramChart extends CartesianChart {
+    transformSpec(spec: any): void;
+    protected _getDefaultSeriesSpec(spec: any): any;
+}

package/build/es5/chart/histogram/histogram-3d.d.ts

@@ -0,0 +1,7 @@
+import { BaseHistogramChart } from './base';
+export declare class Histogram3dChart extends BaseHistogramChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+}

package/build/es5/chart/histogram/histogram.d.ts

@@ -0,0 +1,8 @@
+import { BaseHistogramChart } from './base';
+export declare class HistogramChart extends BaseHistogramChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    transformSpec(spec: any): void;
+}

package/build/es5/chart/histogram/index.d.ts

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

package/build/es5/chart/histogram/interface.d.ts

@@ -0,0 +1,9 @@
+import type { IBarSeriesSpec, IBar3dSeriesSpec } from '../../series/bar/interface';
+import type { IChartExtendsSeriesSpec } from '../../typings';
+import type { ICartesianChartSpec } from '../cartesian/interface';
+export interface IHistogramChartSpec extends ICartesianChartSpec, Omit<IChartExtendsSeriesSpec<IBarSeriesSpec>, 'type'> {
+    type: 'histogram';
+}
+export interface IHistogram3dChartSpec extends ICartesianChartSpec, Omit<IChartExtendsSeriesSpec<IBar3dSeriesSpec>, 'type'> {
+    type: 'histogram3d';
+}