@visactor/vchart-types 0.16.17-alpha.2

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

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

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/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.d.ts

@@ -0,0 +1,9 @@
+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;
+}
+export declare const registerHistogramChart: () => void;

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

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

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 { IWordCloudChartSpec, IWordCloud3dChartSpec } from './word-cloud';
+import { WordCloudChart, WordCloud3dChart, registerWordCloudChart, registerWordCloud3dChart } from './word-cloud';
+import { BaseChart } from './base-chart';
+import type { ICartesianChartSpec } from './cartesian';
+import { CartesianChart } from './cartesian';
+import type { IPolarChartSpec } from './polar';
+import { PolarChart, RoseLikeChart, ProgressLikeChart } 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, WordCloudChart, WordCloud3dChart, TreemapChart, BaseChart, PolarChart, ProgressLikeChart, RoseLikeChart, CartesianChart };
+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 };
+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, IWordCloud3dChartSpec, IWordCloudChartSpec, IPolarChartSpec, ICartesianChartSpec };

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

@@ -0,0 +1,87 @@
+import type { IEvent } from '../../event/interface';
+import type { LayoutCallBack } from '../../layout/interface';
+import type { IRunningConfig as IMorphConfig, IView } from '@visactor/vgrammar-core';
+import type { IParserOptions } from '@visactor/vdataset/es/parser';
+import type { IComponent } from '../../component/interface';
+import type { IMark } from '../../mark/interface';
+import type { IModel, IUpdateSpecResult } from '../../model/interface';
+import type { IRegion } from '../../region/interface';
+import type { ISeries } from '../../series/interface';
+import type { IChartEvaluateOption, IChartInitOption, IChartLayoutOption, IChartOption, IChartRenderOption, ILayoutParams } from './common';
+import type { IBoundsLike, IPadding } from '@visactor/vutils';
+import type { ICompilable } from '../../compile/interface';
+import type { IRegionQuerier, MaybeArray, Datum, IMarkStateSpec, StringOrNumber, IShowTooltipOption, IDataValues, ILayoutRect } from '../../typings';
+import type { DataView } from '@visactor/vdataset';
+import type { IThemeColorScheme } from '../../theme/color-scheme/interface';
+export type DimensionIndexOption = {
+    filter?: (cmp: IComponent) => boolean;
+    tooltip?: boolean;
+    showTooltipOption?: IShowTooltipOption;
+    crosshair?: boolean;
+};
+export interface IChart extends ICompilable {
+    padding: IPadding;
+    readonly type: string;
+    getSpec: () => any;
+    setSpec: (s: any) => void;
+    reDataFlow: () => void;
+    setCanvasRect: (width: number, height: number) => void;
+    getCanvasRect: () => ILayoutRect;
+    getOption: () => IChartOption;
+    getEvent: () => IEvent;
+    setLayout: (layout: LayoutCallBack) => void;
+    layout: (context: ILayoutParams) => void;
+    getLayoutTag: () => boolean;
+    setLayoutTag: (tag: boolean) => boolean;
+    updateData: (id: StringOrNumber, data: unknown, updateGlobalScale?: boolean, options?: IParserOptions) => void;
+    updateFullData: (data: IDataValues | IDataValues[]) => void;
+    updateGlobalScaleDomain: () => void;
+    created: () => void;
+    transformSpec: (spec: any) => void;
+    init: (option: IChartInitOption) => void;
+    onLayoutStart: (ctx: IChartLayoutOption) => void;
+    onLayoutEnd: (ctx: IChartLayoutOption) => void;
+    onEvaluateEnd: (ctx: IChartEvaluateOption) => void;
+    onRender: (ctx: IChartRenderOption) => void;
+    onResize: (width: number, height: number) => void;
+    onLayout: (view: IView) => void;
+    getAllSeries: () => ISeries[];
+    getRegionsInIndex: (index?: number[]) => IRegion[];
+    getRegionsInIds: (ids: number[]) => IRegion[];
+    getAllRegions: () => IRegion[];
+    getRegionsInUserIdOrIndex: (user_ids?: StringOrNumber[], index?: number[]) => IRegion[];
+    getRegionsInQuerier: (query: MaybeArray<IRegionQuerier>) => IRegion[];
+    getSeriesInIndex: (index?: number[]) => ISeries[];
+    getSeriesInIds: (ids?: number[]) => ISeries[];
+    getSeriesInUserIdOrIndex: (user_ids?: StringOrNumber[], index?: number[]) => ISeries[];
+    getSeriesInUserId: (userId: StringOrNumber) => ISeries | undefined;
+    getComponentByIndex: (key: string, index: number) => IComponent | undefined;
+    getComponentByUserId: (userId: StringOrNumber) => IComponent | undefined;
+    getComponentsByKey: (key: string) => IComponent[];
+    getAllComponents: () => IComponent[];
+    getModelById: (id: number) => IModel | undefined;
+    getModelByUserId: (userId: StringOrNumber) => IModel | undefined;
+    getModelInFilter: (filter: string | {
+        type: string;
+        index: number;
+    } | ((model: IModel) => boolean)) => IModel | undefined;
+    getAllModels: () => IModel[];
+    getMarkById: (id: number) => IMark | undefined;
+    getAllMarks: () => IMark[];
+    updateSpec: (spec: any, morphConfig?: IMorphConfig) => IUpdateSpecResult;
+    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;
+    updateViewBox: (viewBox: IBoundsLike, reLayout: boolean) => void;
+    getCanvas: () => HTMLCanvasElement | undefined;
+    setCurrentTheme: (reInit?: boolean) => void;
+    getColorScheme: () => IThemeColorScheme | undefined;
+    getSeriesData: (id: StringOrNumber | undefined, index: number | undefined) => DataView | undefined;
+    setDimensionIndex: (value: StringOrNumber, opt: DimensionIndexOption) => void;
+}
+export interface IChartConstructor {
+    readonly type: string;
+    readonly series?: string | string[];
+    readonly view: string;
+    new (spec: any, options: IChartOption): IChart;
+}

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

@@ -0,0 +1,32 @@
+import type { LayoutCallBack } from '../../layout/interface';
+import type { IRenderOption } from '../../compile/interface';
+import type { IModelOption } from '../../model/interface';
+import type { IView } from '@visactor/vgrammar-core';
+import type { IBoundsLike } from '@visactor/vutils';
+export interface ILayoutParams {
+    srView?: IView;
+    group?: any;
+}
+export interface IAttributeParams {
+    srView?: IView;
+    group?: any;
+}
+export interface IChartOption extends Omit<IModelOption, 'getChartViewRect' | 'getChartLayoutRect' | 'globalScale' | 'getChart'> {
+    container: HTMLElement | null;
+    canvas?: HTMLCanvasElement | OffscreenCanvas | string;
+    modeParams?: IRenderOption['modeParams'];
+    viewBox?: IBoundsLike;
+    layout?: LayoutCallBack;
+}
+export interface IChartCreatedOption {
+}
+export interface IChartInitOption {
+}
+export interface IChartUpdateOption {
+}
+export interface IChartLayoutOption {
+}
+export interface IChartEvaluateOption {
+}
+export interface IChartRenderOption {
+}

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

@@ -0,0 +1,3 @@
+export * from './common';
+export * from './type';
+export * from './chart';

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

@@ -0,0 +1,35 @@
+export type ChartType = keyof typeof ChartTypeEnum | string;
+export declare enum ChartTypeEnum {
+    common = "common",
+    area = "area",
+    line = "line",
+    bar = "bar",
+    bar3d = "bar3d",
+    histogram = "histogram",
+    histogram3d = "histogram3d",
+    rangeColumn = "rangeColumn",
+    rangeColumn3d = "rangeColumn3d",
+    rangeArea = "rangeArea",
+    map = "map",
+    pie = "pie",
+    pie3d = "pie3d",
+    radar = "radar",
+    rose = "rose",
+    scatter = "scatter",
+    sequence = "sequence",
+    circularProgress = "circularProgress",
+    linearProgress = "linearProgress",
+    wordCloud = "wordCloud",
+    wordCloud3d = "wordCloud3d",
+    funnel = "funnel",
+    funnel3d = "funnel3d",
+    waterfall = "waterfall",
+    boxPlot = "boxPlot",
+    gauge = "gauge",
+    sankey = "sankey",
+    treemap = "treemap",
+    sunburst = "sunburst",
+    circlePacking = "circlePacking",
+    heatmap = "heatmap",
+    correlation = "correlation"
+}

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

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

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

@@ -0,0 +1,7 @@
+import type { ICartesianChartSpec } from '../cartesian/interface';
+import type { ILineSeriesSpec } from '../../series/line/interface';
+import type { IChartExtendsSeriesSpec } from '../..';
+export interface ILineChartSpec extends ICartesianChartSpec, IChartExtendsSeriesSpec<ILineSeriesSpec> {
+    type: 'line';
+    series?: ILineSeriesSpec[];
+}

package/types/chart/line/line.d.ts

@@ -0,0 +1,12 @@
+import { CartesianChart } from '../cartesian/cartesian';
+import type { ILineChartSpec } from './interface';
+export declare class LineChart extends CartesianChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _canStack: boolean;
+    protected _getDefaultSeriesSpec(spec: ILineChartSpec): any;
+    transformSpec(spec: any): void;
+}
+export declare const registerLineChart: () => void;

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

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

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

@@ -0,0 +1,6 @@
+import type { IChartExtendsSeriesSpec, IChartSpec } from '../../typings/spec/common';
+import type { IMapSeriesSpec } from '../../series/map/interface';
+export interface IMapChartSpec extends IChartSpec, IChartExtendsSeriesSpec<IMapSeriesSpec> {
+    type: 'map';
+    series?: IMapSeriesSpec[];
+}

package/types/chart/map/map.d.ts

@@ -0,0 +1,13 @@
+import { BaseChart } from '../base-chart';
+import type { IMapChartSpec } from './interface';
+import type { IMapSeriesSpec } from '../../series/map/interface';
+export declare class MapChart extends BaseChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _getDefaultSeriesSpec(spec: IMapChartSpec): IMapSeriesSpec;
+    protected isValidSeries(type: string): boolean;
+    transformSpec(spec: IMapChartSpec): void;
+}
+export declare const registerMapChart: () => void;

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

@@ -0,0 +1,5 @@
+import { PolarChart } from '../polar/polar';
+export declare class BasePieChart extends PolarChart {
+    protected needAxes(): boolean;
+    protected _getDefaultSeriesSpec(spec: any): any;
+}

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

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

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

@@ -0,0 +1,11 @@
+import type { IPieSeriesSpec, IPie3dSeriesSpec } from '../../series/pie/interface';
+import type { IIndicatorSpec } from '../../component/indicator/interface';
+import type { IChartExtendsSeriesSpec, IChartSpec } from '../../typings/spec/common';
+export interface IPieChartSpec extends IChartSpec, IChartExtendsSeriesSpec<IPieSeriesSpec> {
+    type: 'pie';
+    indicator?: IIndicatorSpec;
+}
+export interface IPie3dChartSpec extends IChartSpec, IChartExtendsSeriesSpec<IPie3dSeriesSpec> {
+    type: 'pie3d';
+    indicator?: IIndicatorSpec;
+}

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

@@ -0,0 +1,9 @@
+import { BasePieChart } from './base';
+export declare class Pie3dChart extends BasePieChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    transformSpec(spec: any): void;
+}
+export declare const registerPie3dChart: () => void;

package/types/chart/pie/pie.d.ts

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

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

@@ -0,0 +1,4 @@
+export * from './polar';
+export * from './progress-like';
+export * from './rose-like';
+export * from './interface';

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

@@ -0,0 +1,7 @@
+import type { IPolarAxisSpec } from '../../component/axis/polar/interface';
+import type { IPolarCrosshairSpec } from '../../component/crosshair/interface';
+import type { IChartSpec } from '../../typings';
+export interface IPolarChartSpec extends IChartSpec {
+    axes?: IPolarAxisSpec[];
+    crosshair?: IPolarCrosshairSpec | IPolarCrosshairSpec[];
+}

package/types/chart/polar/polar.d.ts

@@ -0,0 +1,9 @@
+import type { IIndicatorSpec } from '../../component/indicator/interface';
+import { BaseChart } from '../base-chart';
+export declare class PolarChart extends BaseChart {
+    readonly seriesType: string;
+    protected isValidSeries(type: string): boolean;
+    protected _getDefaultSeriesSpec(spec: any): any;
+    protected getIndicatorSpec(spec: any): IIndicatorSpec[];
+    transformSpec(spec: any): void;
+}

package/types/chart/polar/progress-like.d.ts

@@ -0,0 +1,7 @@
+import type { IPolarAxisSpec } from '../../component/axis/polar/interface';
+import { PolarChart } from './polar';
+export declare class ProgressLikeChart extends PolarChart {
+    protected needAxes(): boolean;
+    protected _getDefaultSeriesSpec(spec: any): any;
+    protected _transformProgressAxisSpec(spec: any, angleAxisDefaultSpec: IPolarAxisSpec, radiusAxisDefaultSpec: IPolarAxisSpec, angleAxisAppendSpec?: Partial<IPolarAxisSpec>, radiusAxisAppendSpec?: Partial<IPolarAxisSpec>): void;
+}

package/types/chart/polar/rose-like.d.ts

@@ -0,0 +1,7 @@
+import { PolarChart } from './polar';
+export declare class RoseLikeChart extends PolarChart {
+    protected _canStack: boolean;
+    protected needAxes(): boolean;
+    protected _getDefaultSeriesSpec(spec: any): any;
+    transformSpec(spec: any): void;
+}

package/types/chart/progress/circular/circular.d.ts

@@ -0,0 +1,11 @@
+import { ProgressLikeChart } from '../../polar/progress-like';
+export declare class CircularProgressChart extends ProgressLikeChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _canStack: boolean;
+    protected _getDefaultSeriesSpec(spec: any): any;
+    transformSpec(spec: any): void;
+}
+export declare const registerCircularProgressChart: () => void;

package/types/chart/progress/circular/index.d.ts

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

package/types/chart/progress/circular/interface.d.ts

@@ -0,0 +1,7 @@
+import type { IChartExtendsSeriesSpec } from '../../..';
+import type { ICircularProgressSeriesSpec } from '../../../series/progress/circular/interface';
+import type { IProgressChartSpec } from '../interface';
+export interface ICircularProgressChartSpec extends IProgressChartSpec, IChartExtendsSeriesSpec<ICircularProgressSeriesSpec> {
+    type: 'circularProgress';
+    series?: ICircularProgressSeriesSpec[];
+}

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

@@ -0,0 +1,8 @@
+import type { IChartSpec } from '../../typings/spec/common';
+import type { ICartesianAxisSpec } from '../../component/axis/cartesian/interface';
+import type { IPolarAxisSpec } from '../../component/axis/polar/interface';
+export interface IProgressChartSpec extends IChartSpec {
+    seriesField?: string;
+    cornerRadius?: number;
+    axes?: ICartesianAxisSpec[] | IPolarAxisSpec[];
+}

package/types/chart/progress/linear/index.d.ts

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

package/types/chart/progress/linear/interface.d.ts

@@ -0,0 +1,9 @@
+import type { IProgressChartSpec } from '../interface';
+import type { ICartesianAxisSpec } from '../../../component/axis/cartesian/interface';
+import type { ILinearProgressSeriesSpec } from '../../../series/progress/linear/interface';
+import type { IChartExtendsSeriesSpec } from '../../..';
+export interface ILinearProgressChartSpec extends IProgressChartSpec, IChartExtendsSeriesSpec<ILinearProgressSeriesSpec> {
+    type: 'linearProgress';
+    axes?: ICartesianAxisSpec[];
+    series?: ILinearProgressSeriesSpec[];
+}

package/types/chart/progress/linear/linear.d.ts

@@ -0,0 +1,13 @@
+import { CartesianChart } from '../../cartesian/cartesian';
+import type { ILinearProgressChartSpec } from './interface';
+export declare class LinearProgressChart extends CartesianChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _canStack: boolean;
+    protected needAxes(): boolean;
+    protected _getDefaultSeriesSpec(spec: ILinearProgressChartSpec): ILinearProgressChartSpec;
+    transformSpec(spec: ILinearProgressChartSpec): void;
+}
+export declare const registerLinearProgressChart: () => void;

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

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

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

@@ -0,0 +1,7 @@
+import type { IChartExtendsSeriesSpec } from '../../typings/spec/common';
+import type { IRadarSeriesSpec } from '../../series/radar/interface';
+import type { IPolarChartSpec } from '../polar/interface';
+export interface IRadarChartSpec extends IPolarChartSpec, IChartExtendsSeriesSpec<IRadarSeriesSpec> {
+    type: 'radar';
+    series?: IRadarSeriesSpec[];
+}

package/types/chart/radar/radar.d.ts

@@ -0,0 +1,10 @@
+import { RoseLikeChart } from '../polar/rose-like';
+export declare class RadarChart extends RoseLikeChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _getDefaultSeriesSpec(spec: any): any;
+    transformSpec(spec: any): void;
+}
+export declare const registerRadarChart: () => void;

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

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

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

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

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

@@ -0,0 +1,10 @@
+import { CartesianChart } from '../cartesian/cartesian';
+export declare class RangeAreaChart 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;
+}
+export declare const registerRangeAreaChart: () => void;

package/types/chart/range-column/index.d.ts

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

package/types/chart/range-column/interface.d.ts

@@ -0,0 +1,11 @@
+import type { IChartExtendsSeriesSpec } from '../../typings/spec/common';
+import type { IRangeColumnSeriesSpec, IRangeColumn3dSeriesSpec } from '../../series/range-column/interface';
+import type { ICartesianChartSpec } from '../cartesian/interface';
+export interface IRangeColumnChartSpec extends ICartesianChartSpec, IChartExtendsSeriesSpec<IRangeColumnSeriesSpec> {
+    type: 'rangeColumn';
+    series?: IRangeColumnSeriesSpec[];
+}
+export interface IRangeColumn3dChartSpec extends ICartesianChartSpec, IChartExtendsSeriesSpec<IRangeColumn3dSeriesSpec> {
+    type: 'rangeColumn3d';
+    series?: IRangeColumn3dSeriesSpec[];
+}

package/types/chart/range-column/range-column-3d.d.ts

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

package/types/chart/range-column/range-column.d.ts

@@ -0,0 +1,10 @@
+import { CartesianChart } from '../cartesian/cartesian';
+export declare class RangeColumnChart 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;
+}
+export declare const registerRangeColumnChart: () => void;

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

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

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

@@ -0,0 +1,7 @@
+import type { IChartExtendsSeriesSpec } from '../../typings/spec/common';
+import type { IRoseSeriesSpec } from '../../series/rose/interface';
+import type { IPolarChartSpec } from '../polar/interface';
+export interface IRoseChartSpec extends IPolarChartSpec, IChartExtendsSeriesSpec<IRoseSeriesSpec> {
+    type: 'rose';
+    series?: IRoseSeriesSpec[];
+}

package/types/chart/rose/rose.d.ts

@@ -0,0 +1,10 @@
+import { RoseLikeChart } from '../polar/rose-like';
+export declare class RoseChart extends RoseLikeChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _getDefaultSeriesSpec(spec: any): any;
+    transformSpec(spec: any): void;
+}
+export declare const registerRoseChart: () => void;

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

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

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

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