@visactor/vchart-types 0.10.0-alpha.2

package/types/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/types/chart/cartesian/index.d.ts

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

package/types/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 | IMarkLineSpec[];
+    markArea?: IMarkAreaSpec | IMarkAreaSpec[];
+    markPoint?: IMarkPointSpec | IMarkPointSpec[];
+}

package/types/chart/chart-meta/data.d.ts

@@ -0,0 +1,15 @@
+import type { IData } from './../../typings/spec/common';
+import { DataView } from '@visactor/vdataset';
+import type { DataSet } from '@visactor/vdataset';
+import type { StringOrNumber } from '../../typings';
+export declare class ChartData {
+    protected _dataArr: DataView[];
+    get dataList(): DataView[];
+    protected _onError: (...args: any[]) => void;
+    protected _dataSet: DataSet;
+    constructor(dataSet: DataSet, onError: (...args: any[]) => void);
+    parseData(dataSpec: IData): void;
+    updateData(dataSpec: IData, fullUp?: boolean, forceMerge?: boolean): boolean;
+    private _dataValueForEach;
+    getSeriesData(id: StringOrNumber | undefined, index: number | undefined): DataView | undefined;
+}

package/types/chart/circle-packing/circle-packing-transformer.d.ts

@@ -0,0 +1,7 @@
+import type { ICirclePackingSeriesSpec } from '../../series/circle-packing/interface';
+import { BaseChartSpecTransformer } from '../base';
+import type { ICirclePackingChartSpec } from './interface';
+export declare class CirclePackingChartSpecTransformer<T extends ICirclePackingChartSpec = ICirclePackingChartSpec> extends BaseChartSpecTransformer<T> {
+    protected _getDefaultSeriesSpec(spec: ICirclePackingChartSpec): ICirclePackingSeriesSpec;
+    transformSpec(spec: T): void;
+}

package/types/chart/circle-packing/circle-packing.d.ts

@@ -0,0 +1,13 @@
+import { BaseChart } from '../base/base-chart';
+import type { ICirclePackingChartSpec } from './interface';
+import { CirclePackingChartSpecTransformer } from './circle-packing-transformer';
+export declare class CirclePackingChart<T extends ICirclePackingChartSpec = ICirclePackingChartSpec> extends BaseChart<T> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof CirclePackingChartSpecTransformer;
+    readonly transformerConstructor: typeof CirclePackingChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerCirclePackingChart: () => void;

package/types/chart/circle-packing/index.d.ts

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

package/types/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/types/chart/common/common-transformer.d.ts

@@ -0,0 +1,7 @@
+import type { AdaptiveSpec } from '../../typings';
+import { BaseChartSpecTransformer } from '../base';
+import type { ICommonChartSpec } from './interface';
+export declare class CommonChartSpecTransformer<T extends ICommonChartSpec = ICommonChartSpec> extends BaseChartSpecTransformer<AdaptiveSpec<T, 'series'>> {
+    protected _getDefaultSeriesSpec(spec: AdaptiveSpec<T, 'series'>): any;
+    transformSpec(spec: AdaptiveSpec<T, 'series'>): void;
+}

package/types/chart/common/common.d.ts

@@ -0,0 +1,13 @@
+import { BaseChart } from '../base/base-chart';
+import type { ICommonChartSpec } from './interface';
+import type { AdaptiveSpec } from '../../typings';
+import { CommonChartSpecTransformer } from './common-transformer';
+export declare class CommonChart<T extends ICommonChartSpec = ICommonChartSpec> extends BaseChart<AdaptiveSpec<T, 'series'>> {
+    static readonly type: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof CommonChartSpecTransformer;
+    readonly transformerConstructor: typeof CommonChartSpecTransformer;
+    readonly type: string;
+    protected _canStack: boolean;
+}
+export declare const registerCommonChart: () => void;

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

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

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

@@ -0,0 +1,41 @@
+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 { ICorrelationSeriesSpec } from '../../series/correlation/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 | ICorrelationSeriesSpec)[];
+    axes?: ICartesianAxisSpec[] | IPolarAxisSpec[];
+    crosshair?: ICartesianCrosshairSpec | ICartesianCrosshairSpec[] | IPolarCrosshairSpec | IPolarCrosshairSpec[];
+    markLine?: IMarkLineSpec | IMarkLineSpec[];
+    markArea?: IMarkAreaSpec;
+    markPoint?: IMarkPointSpec;
+}

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

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

package/types/chart/correlation/correlation.d.ts

@@ -0,0 +1,13 @@
+import { BaseChart } from '../base/base-chart';
+import type { ICorrelationChartSpec } from './interface';
+import { CorrelationChartSpecTransformer } from './correlation-transformer';
+export declare class CorrelationChart<T extends ICorrelationChartSpec = ICorrelationChartSpec> extends BaseChart<T> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof CorrelationChartSpecTransformer;
+    readonly transformerConstructor: typeof CorrelationChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerCorrelationChart: () => void;

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

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

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

@@ -0,0 +1,6 @@
+import type { ICorrelationSeriesSpec } from '../../series/correlation/interface';
+import type { IChartExtendsSeriesSpec, IChartSpec } from '../../typings/spec/common';
+export interface ICorrelationChartSpec extends Omit<IChartSpec, 'padding'>, IChartExtendsSeriesSpec<ICorrelationSeriesSpec> {
+    type: 'correlation';
+    series?: ICorrelationSeriesSpec[];
+}

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

@@ -0,0 +1,14 @@
+import type { IFunnel3dChartSpec } from '../interface';
+import type { AdaptiveSpec } from '../../../typings';
+import { FunnelChartSpecTransformer } from '../funnel-transformer';
+import { BaseChart } from '../../base';
+export declare class Funnel3dChart<T extends IFunnel3dChartSpec = IFunnel3dChartSpec> extends BaseChart<AdaptiveSpec<T, 'type'>> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof FunnelChartSpecTransformer;
+    readonly transformerConstructor: typeof FunnelChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerFunnel3dChart: () => void;

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

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

package/types/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/types/chart/funnel/funnel-3d.d.ts

@@ -0,0 +1,8 @@
+import { BaseFunnelChart } from './base';
+export declare class Funnel3dChart extends BaseFunnelChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerFunnel3dChart: () => void;

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

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

package/types/chart/funnel/funnel.d.ts

@@ -0,0 +1,13 @@
+import type { IFunnelChartSpec } from './interface';
+import { FunnelChartSpecTransformer } from './funnel-transformer';
+import { BaseChart } from '../base';
+export declare class FunnelChart<T extends IFunnelChartSpec = IFunnelChartSpec> extends BaseChart<T> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof FunnelChartSpecTransformer;
+    readonly transformerConstructor: typeof FunnelChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerFunnelChart: () => void;

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

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

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

@@ -0,0 +1,9 @@
+import type { IChartExtendsSeriesSpec } from '../../typings';
+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/types/chart/gauge/gauge-transformer.d.ts

@@ -0,0 +1,9 @@
+import type { AdaptiveSpec } from '../../typings';
+import { ProgressLikeChartSpecTransformer } from '../polar';
+import type { IGaugeChartSpec } from './interface';
+export declare class GaugeChartSpecTransformer<T extends IGaugeChartSpec = IGaugeChartSpec> extends ProgressLikeChartSpecTransformer<AdaptiveSpec<T, 'axes'>> {
+    protected _getDefaultSeriesSpec(spec: T): any;
+    protected _getDefaultCircularProgressSeriesSpec(spec: T): any;
+    transformSpec(spec: AdaptiveSpec<T, 'axes'>): void;
+    protected _transformGaugeAxisSpec(spec: AdaptiveSpec<T, 'axes'>): void;
+}

package/types/chart/gauge/gauge.d.ts

@@ -0,0 +1,14 @@
+import type { IGaugeChartSpec } from './interface';
+import { GaugeChartSpecTransformer } from './gauge-transformer';
+import type { AdaptiveSpec } from '../../typings';
+import { BaseChart } from '../base';
+export declare class GaugeChart<T extends IGaugeChartSpec = IGaugeChartSpec> extends BaseChart<AdaptiveSpec<T, 'axes'>> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof GaugeChartSpecTransformer;
+    readonly transformerConstructor: typeof GaugeChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerGaugeChart: () => void;

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

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

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

@@ -0,0 +1,10 @@
+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';
+import type { IPolarChartSpec } from '../polar';
+export interface IGaugeChartSpec extends Omit<IPolarChartSpec, 'axes'>, Omit<IGaugePointerSeriesSpec, 'data' | 'type' | 'morph'> {
+    type: 'gauge';
+    gauge?: Omit<IGaugeSeriesSpec, 'data'> | Omit<ICircularProgressSeriesSpec, 'data'>;
+    axes?: (IPolarAxisSpec | ILinearAxisSpec)[];
+}

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

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

package/types/chart/heatmap/heatmap.d.ts

@@ -0,0 +1,13 @@
+import type { IHeatmapChartSpec } from './interface';
+import { HeatmapChartSpecTransformer } from './heatmap-transformer';
+import { BaseChart } from '../base';
+export declare class HeatmapChart<T extends IHeatmapChartSpec = IHeatmapChartSpec> extends BaseChart<T> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof HeatmapChartSpecTransformer;
+    readonly transformerConstructor: typeof HeatmapChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerHeatmapChart: () => void;

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

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

package/types/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/types/chart/histogram/3d/histogram-3d.d.ts

@@ -0,0 +1,14 @@
+import { BaseHistogramChart } from '../base/base';
+import type { IHistogram3dChartSpec } from '../interface';
+import type { AdaptiveSpec } from '../../../typings';
+import { HistogramChartSpecTransformer } from '../histogram-transformer';
+export declare class Histogram3dChart<T extends IHistogram3dChartSpec> extends BaseHistogramChart<AdaptiveSpec<T, 'type'>> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof HistogramChartSpecTransformer;
+    readonly transformerConstructor: typeof HistogramChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerHistogram3dChart: () => void;

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

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

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

@@ -0,0 +1,8 @@
+import { BaseChart } from '../../base';
+import type { IHistogramChartSpec } from '../interface';
+import { BaseHistogramChartSpecTransformer } from './histogram-base-transformer';
+export declare class BaseHistogramChart<T extends IHistogramChartSpec> extends BaseChart<T> {
+    static readonly transformerConstructor: typeof BaseHistogramChartSpecTransformer;
+    readonly transformerConstructor: typeof BaseHistogramChartSpecTransformer;
+    protected _canStack: boolean;
+}

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

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

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

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

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

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

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

@@ -0,0 +1,8 @@
+import { BaseHistogramChart } from './base';
+export declare class Histogram3dChart extends BaseHistogramChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerHistogram3dChart: () => void;

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

@@ -0,0 +1,5 @@
+import { BaseHistogramChartSpecTransformer } from './base';
+import type { IHistogramChartSpec } from './interface';
+export declare class HistogramChartSpecTransformer<T extends IHistogramChartSpec = IHistogramChartSpec> extends BaseHistogramChartSpecTransformer<T> {
+    transformSpec(spec: T): void;
+}

package/types/chart/histogram/histogram.d.ts

@@ -0,0 +1,13 @@
+import { BaseHistogramChart } from './base/base';
+import type { IHistogramChartSpec } from './interface';
+import { HistogramChartSpecTransformer } from './histogram-transformer';
+export declare class HistogramChart<T extends IHistogramChartSpec = IHistogramChartSpec> extends BaseHistogramChart<T> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof HistogramChartSpecTransformer;
+    readonly transformerConstructor: typeof HistogramChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerHistogramChart: () => void;

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

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

package/types/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';
+}

package/types/chart/index.d.ts

@@ -0,0 +1,60 @@
+import type { IAreaChartSpec } from './area';
+import { AreaChart, registerAreaChart } from './area';
+import type { IBarChartSpec, IBar3dChartSpec } from './bar';
+import { BarChart, Bar3dChart, registerBarChart, registerBar3dChart } from './bar';
+import type { IBoxPlotChartSpec } from './box-plot';
+import { BoxPlotChart, registerBoxplotChart } from './box-plot';
+import type { ICirclePackingChartSpec } from './circle-packing';
+import { CirclePackingChart, registerCirclePackingChart } from './circle-packing';
+import type { ICommonChartSpec } from './common';
+import { CommonChart, registerCommonChart } from './common';
+import type { IFunnelChartSpec, IFunnel3dChartSpec } from './funnel';
+import { FunnelChart, Funnel3dChart, registerFunnelChart, registerFunnel3dChart } from './funnel';
+import type { IGaugeChartSpec } from './gauge';
+import { GaugeChart, registerGaugeChart } from './gauge';
+import type { IHeatmapChartSpec } from './heatmap';
+import { HeatmapChart, registerHeatmapChart } from './heatmap';
+import type { IHistogramChartSpec, IHistogram3dChartSpec } from './histogram';
+import { HistogramChart, Histogram3dChart, registerHistogramChart, registerHistogram3dChart } from './histogram';
+import type { ILineChartSpec } from './line';
+import { LineChart, registerLineChart } from './line';
+import type { IMapChartSpec } from './map';
+import { MapChart, registerMapChart } from './map';
+import type { IPieChartSpec, IPie3dChartSpec } from './pie';
+import { PieChart, Pie3dChart, registerPieChart, registerPie3dChart } from './pie';
+import type { ICircularProgressChartSpec } from './progress/circular';
+import { CircularProgressChart, registerCircularProgressChart } from './progress/circular';
+import type { ILinearProgressChartSpec } from './progress/linear';
+import { LinearProgressChart, registerLinearProgressChart } from './progress/linear';
+import type { IRadarChartSpec } from './radar';
+import { RadarChart, registerRadarChart } from './radar';
+import type { IRangeAreaChartSpec } from './range-area';
+import { RangeAreaChart, registerRangeAreaChart } from './range-area';
+import type { IRangeColumnChartSpec, IRangeColumn3dChartSpec } from './range-column';
+import { RangeColumnChart, RangeColumn3dChart, registerRangeColumnChart, registerRangeColumn3dChart } from './range-column';
+import type { IRoseChartSpec } from './rose';
+import { RoseChart, registerRoseChart } from './rose';
+import type { ISankeyChartSpec } from './sankey';
+import { SankeyChart, registerSankeyChart } from './sankey';
+import type { IScatterChartSpec } from './scatter';
+import { ScatterChart, registerScatterChart } from './scatter';
+import type { ISequenceChartSpec } from './sequence';
+import { SequenceChart, registerSequenceChart } from './sequence';
+import type { ISunburstChartSpec } from './sunburst';
+import { SunburstChart, registerSunburstChart } from './sunburst';
+import type { ITreemapChartSpec } from './treemap';
+import { TreemapChart, registerTreemapChart } from './treemap';
+import type { IWaterfallChartSpec } from './waterfall';
+import { WaterfallChart, registerWaterfallChart } from './waterfall';
+import type { ICorrelationChartSpec } from './correlation';
+import { CorrelationChart, registerCorrelationChart } from './correlation';
+import type { ILiquidChartSpec } from './liquid';
+import { LiquidChart, registerLiquidChart } from './liquid';
+import type { IWordCloudChartSpec, IWordCloud3dChartSpec } from './word-cloud';
+import { WordCloudChart, WordCloud3dChart, registerWordCloudChart, registerWordCloud3dChart } from './word-cloud';
+import { BaseChart } from './base/base-chart';
+import type { ICartesianChartSpec } from './cartesian';
+import type { IPolarChartSpec } from './polar';
+export { AreaChart, BarChart, Bar3dChart, BoxPlotChart, CirclePackingChart, CommonChart, FunnelChart, Funnel3dChart, GaugeChart, HeatmapChart, HistogramChart, Histogram3dChart, LineChart, MapChart, PieChart, Pie3dChart, CircularProgressChart, LinearProgressChart, RadarChart, RangeColumnChart, RangeColumn3dChart, RangeAreaChart, RoseChart, SankeyChart, ScatterChart, SunburstChart, SequenceChart, WaterfallChart, CorrelationChart, LiquidChart, WordCloudChart, WordCloud3dChart, TreemapChart, BaseChart };
+export { registerLineChart, registerAreaChart, registerBarChart, registerBar3dChart, registerBoxplotChart, registerCirclePackingChart, registerCircularProgressChart, registerCommonChart, registerFunnelChart, registerFunnel3dChart, registerGaugeChart, registerHeatmapChart, registerHistogramChart, registerHistogram3dChart, registerLinearProgressChart, registerMapChart, registerPie3dChart, registerPieChart, registerRadarChart, registerRangeAreaChart, registerRangeColumn3dChart, registerRangeColumnChart, registerRoseChart, registerSankeyChart, registerScatterChart, registerSequenceChart, registerSunburstChart, registerTreemapChart, registerWaterfallChart, registerWordCloud3dChart, registerWordCloudChart, registerCorrelationChart, registerLiquidChart };
+export type { IAreaChartSpec, IBarChartSpec, IBar3dChartSpec, IBoxPlotChartSpec, ICirclePackingChartSpec, ICommonChartSpec, IFunnelChartSpec, IFunnel3dChartSpec, IGaugeChartSpec, IHeatmapChartSpec, IHistogramChartSpec, IHistogram3dChartSpec, ILineChartSpec, IMapChartSpec, IPieChartSpec, IPie3dChartSpec, ICircularProgressChartSpec, ILinearProgressChartSpec, IRadarChartSpec, IRangeColumnChartSpec, IRangeColumn3dChartSpec, IRangeAreaChartSpec, IRoseChartSpec, IScatterChartSpec, ISankeyChartSpec, ISequenceChartSpec, ISunburstChartSpec, ITreemapChartSpec, IWaterfallChartSpec, ICorrelationChartSpec, ILiquidChartSpec, IWordCloud3dChartSpec, IWordCloudChartSpec, IPolarChartSpec, ICartesianChartSpec };