@visactor/vchart-types 0.10.0-alpha.2

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

@@ -0,0 +1,105 @@
+import type { IEvent } from '../../event/interface';
+import type { LayoutCallBack } from '../../layout/interface';
+import type { IView } from '@visactor/vgrammar-core';
+import type { IParserOptions } from '@visactor/vdataset/es/parser';
+import type { IComponent, IComponentConstructor } from '../../component/interface';
+import type { IMark } from '../../mark/interface';
+import type { IModel, IModelConstructor, IModelSpecInfo, IUpdateSpecResult } from '../../model/interface';
+import type { IRegion, IRegionConstructor } from '../../region/interface';
+import type { ISeries, ISeriesConstructor } from '../../series/interface';
+import type { IChartEvaluateOption, IChartLayoutOption, IChartOption, IChartRenderOption, IChartSpecInfo, IChartSpecTransformerOption, 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, IData } from '../../typings';
+import type { DataView } from '@visactor/vdataset';
+export type DimensionIndexOption = {
+    filter?: (cmp: IComponent) => boolean;
+    tooltip?: boolean;
+    showTooltipOption?: IShowTooltipOption;
+    crosshair?: boolean;
+};
+export interface IChartData {
+    parseData: (dataSpec: IData) => void;
+    updateData: (dataSpec: IData, fullUp?: boolean, forceMerge?: boolean) => boolean;
+    getSeriesData: (id: StringOrNumber | undefined, index: number | undefined) => DataView | undefined;
+}
+export interface IChart extends ICompilable {
+    padding: IPadding;
+    readonly type: string;
+    readonly chartData: IChartData;
+    readonly transformerConstructor: new (option: IChartSpecTransformerOption) => IChartSpecTransformer;
+    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;
+    init: () => void;
+    onLayoutStart: (ctx: IChartLayoutOption) => void;
+    onLayoutEnd: (ctx: IChartLayoutOption) => void;
+    onEvaluateEnd: (ctx: IChartEvaluateOption) => void;
+    onRender: (ctx: IChartRenderOption) => void;
+    onResize: (width: number, height: number, reRender: boolean) => 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[];
+    getComponentsByType: (type: 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) => 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: () => void;
+    getSeriesData: (id: StringOrNumber | undefined, index: number | undefined) => DataView | undefined;
+    setDimensionIndex: (value: StringOrNumber, opt: DimensionIndexOption) => void;
+}
+export interface IChartSpecTransformer {
+    readonly type: string;
+    readonly seriesType: string;
+    initChartSpec: (spec: any) => IChartSpecInfo;
+    transformSpec: (spec: any) => void;
+    transformModelSpec: (spec: any) => IChartSpecInfo;
+    createSpecInfo: (chartSpec: any, transform?: (constructor: IModelConstructor, specInfo: IModelSpecInfo, chartSpecInfo?: IChartSpecInfo) => void) => IChartSpecInfo;
+    forEachRegionInSpec: <K>(spec: any, callbackfn: (constructor: IRegionConstructor, specInfo: IModelSpecInfo, chartSpecInfo?: IChartSpecInfo) => K, chartSpecInfo?: IChartSpecInfo) => K[];
+    forEachSeriesInSpec: <K>(spec: any, callbackfn: (constructor: ISeriesConstructor, specInfo: IModelSpecInfo, chartSpecInfo?: IChartSpecInfo) => K, chartSpecInfo?: IChartSpecInfo) => K[];
+    forEachComponentInSpec: <K>(spec: any, callbackfn: (constructor: IComponentConstructor, specInfo: IModelSpecInfo, chartSpecInfo?: IChartSpecInfo) => K, chartSpecInfo?: IChartSpecInfo) => K[];
+}
+export interface IChartConstructor {
+    readonly type: string;
+    readonly seriesType?: string;
+    readonly series?: string | string[];
+    readonly view: string;
+    readonly transformerConstructor: new (option: IChartSpecTransformerOption) => IChartSpecTransformer;
+    new (spec: any, options: IChartOption): IChart;
+}

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

@@ -0,0 +1,47 @@
+import type { LayoutCallBack } from '../../layout/interface';
+import type { IRenderOption } from '../../compile/interface';
+import type { IModelOption, IModelSpecInfo } from '../../model/interface';
+import type { IView } from '@visactor/vgrammar-core';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { ITheme } from '../../theme';
+import type { ISeriesSpecInfo } from '../../series';
+import type { IRegionSpecInfo } from '../../region';
+export interface ILayoutParams {
+    srView?: IView;
+    group?: any;
+}
+export interface IAttributeParams {
+    srView?: IView;
+    group?: any;
+}
+export interface IChartOption extends Omit<IModelOption, 'getChartViewRect' | 'getChartLayoutRect' | 'globalScale' | 'getChart' | 'getSeriesData'> {
+    container: HTMLElement | null;
+    canvas?: HTMLCanvasElement | OffscreenCanvas | string;
+    modeParams?: IRenderOption['modeParams'];
+    viewBox?: IBoundsLike;
+    layout?: LayoutCallBack;
+    disableTriggerEvent?: boolean;
+}
+export interface IChartSpecTransformerOption {
+    type: string;
+    seriesType?: string;
+    animation?: boolean;
+    getTheme: () => ITheme;
+}
+export interface IChartSpecInfo {
+    region?: IRegionSpecInfo[];
+    series?: ISeriesSpecInfo[];
+    component?: Record<string, Array<IModelSpecInfo>>;
+}
+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,36 @@
+export type ChartType = keyof typeof ChartTypeEnum | string;
+export declare const 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",
+    liquid = "liquid"
+}

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

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

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 '../../typings';
+export interface ILineChartSpec extends ICartesianChartSpec, IChartExtendsSeriesSpec<ILineSeriesSpec> {
+    type: 'line';
+    series?: ILineSeriesSpec[];
+}

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

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

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

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

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

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

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

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

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

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

package/types/chart/liquid/liquid.d.ts

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,17 @@
+import { BasePieChart } from '../base/base';
+import type { IPie3dChartSpec } from '../interface';
+import type { AdaptiveSpec } from '../../../typings';
+import { BasePieChartSpecTransformer } from '../base';
+export declare class Pie3dChartSpecTransformer<T extends IPie3dChartSpec = IPie3dChartSpec> extends BasePieChartSpecTransformer<AdaptiveSpec<T, 'type'>> {
+    transformSpec(spec: any): void;
+}
+export declare class Pie3dChart<T extends IPie3dChartSpec = IPie3dChartSpec> extends BasePieChart<AdaptiveSpec<T, 'type'>> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof Pie3dChartSpecTransformer;
+    readonly transformerConstructor: typeof Pie3dChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerPie3dChart: () => void;

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

@@ -0,0 +1,8 @@
+import type { AdaptiveSpec } from '../../../typings';
+import { BaseChart } from '../../base';
+import type { IPieChartSpec } from '../interface';
+import { BasePieChartSpecTransformer } from './pie-transformer';
+export declare class BasePieChart<T extends IPieChartSpec> extends BaseChart<AdaptiveSpec<T, 'axes'>> {
+    static readonly transformerConstructor: typeof BasePieChartSpecTransformer;
+    readonly transformerConstructor: typeof BasePieChartSpecTransformer;
+}

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

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

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

@@ -0,0 +1,7 @@
+import type { AdaptiveSpec } from '../../../typings';
+import { PolarChartSpecTransformer } from '../../polar';
+import type { IPieChartSpec } from '../interface';
+export declare class BasePieChartSpecTransformer<T extends IPieChartSpec> extends PolarChartSpecTransformer<AdaptiveSpec<T, 'axes'>> {
+    protected needAxes(): boolean;
+    protected _getDefaultSeriesSpec(spec: any): any;
+}

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,4 @@
+export * from './pie';
+export * from './3d';
+export * from './base';
+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,13 @@
+import { BasePieChart } from './base/base';
+import type { IPieChartSpec } from './interface';
+import { BasePieChartSpecTransformer } from './base';
+export declare class PieChart<T extends IPieChartSpec = IPieChartSpec> extends BasePieChart<T> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof BasePieChartSpecTransformer;
+    readonly transformerConstructor: typeof BasePieChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerPieChart: () => void;

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

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

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

@@ -0,0 +1,9 @@
+import type { IIndicatorSpec } from '../../component';
+import { BaseChartSpecTransformer } from '../base';
+import type { IPolarChartSpec } from './interface';
+export declare class PolarChartSpecTransformer<T extends IPolarChartSpec> extends BaseChartSpecTransformer<T> {
+    protected _isValidSeries(type: string): boolean;
+    protected getIndicatorSpec(spec: any): IIndicatorSpec[];
+    protected _getDefaultSeriesSpec(spec: any): any;
+    transformSpec(spec: T): void;
+}

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

@@ -0,0 +1 @@
+export * from './progress-like-transformer';

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

@@ -0,0 +1,8 @@
+import type { IPolarAxisSpec } from '../../../component';
+import type { IPolarChartSpec } from '../interface';
+import { PolarChartSpecTransformer } from '../polar-transformer';
+export declare class ProgressLikeChartSpecTransformer<T extends IPolarChartSpec> extends PolarChartSpecTransformer<T> {
+    protected needAxes(): boolean;
+    protected _getDefaultSeriesSpec(spec: any): any;
+    protected _transformProgressAxisSpec(spec: T, angleAxisDefaultSpec: IPolarAxisSpec, radiusAxisDefaultSpec: IPolarAxisSpec, angleAxisAppendSpec?: Partial<IPolarAxisSpec>, radiusAxisAppendSpec?: Partial<IPolarAxisSpec>): 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/index.d.ts

@@ -0,0 +1 @@
+export * from './rose-like-transformer';

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

@@ -0,0 +1,7 @@
+import type { IPolarChartSpec } from '../interface';
+import { PolarChartSpecTransformer } from '../polar-transformer';
+export declare class RoseLikeChartSpecTransformer<T extends IPolarChartSpec> extends PolarChartSpecTransformer<T> {
+    protected needAxes(): boolean;
+    protected _getDefaultSeriesSpec(spec: any): any;
+    transformSpec(spec: T): 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-progress-transformer.d.ts

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

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

@@ -0,0 +1,15 @@
+import type { ICircularProgressChartSpec } from './interface';
+import { CircularProgressChartSpecTransformer } from './circular-progress-transformer';
+import type { AdaptiveSpec } from '../../../typings';
+import { BaseChart } from '../../base';
+export declare class CircularProgressChart<T extends ICircularProgressChartSpec = ICircularProgressChartSpec> extends BaseChart<AdaptiveSpec<T, 'axes'>> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof CircularProgressChartSpecTransformer;
+    readonly transformerConstructor: typeof CircularProgressChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _canStack: boolean;
+}
+export declare const registerCircularProgressChart: () => void;

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

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

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

@@ -0,0 +1,7 @@
+import type { IChartExtendsSeriesSpec } from '../../../typings';
+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,3 @@
+export * from './linear';
+export * from './interface';
+export * from './linear-progress-transformer';

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 '../../../typings';
+export interface ILinearProgressChartSpec extends IProgressChartSpec, IChartExtendsSeriesSpec<ILinearProgressSeriesSpec> {
+    type: 'linearProgress';
+    axes?: ICartesianAxisSpec[];
+    series?: ILinearProgressSeriesSpec[];
+}

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

@@ -0,0 +1,7 @@
+import { CartesianChartSpecTransformer } from '../../cartesian';
+import type { ILinearProgressChartSpec } from './interface';
+export declare class LinearProgressChartSpecTransformer<T extends ILinearProgressChartSpec = ILinearProgressChartSpec> extends CartesianChartSpecTransformer<T> {
+    protected needAxes(): boolean;
+    protected _getDefaultSeriesSpec(spec: T): ILinearProgressChartSpec;
+    transformSpec(spec: T): void;
+}

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

@@ -0,0 +1,14 @@
+import type { ILinearProgressChartSpec } from './interface';
+import { LinearProgressChartSpecTransformer } from './linear-progress-transformer';
+import { BaseChart } from '../../base';
+export declare class LinearProgressChart<T extends ILinearProgressChartSpec = ILinearProgressChartSpec> extends BaseChart<T> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof LinearProgressChartSpecTransformer;
+    readonly transformerConstructor: typeof LinearProgressChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _canStack: boolean;
+}
+export declare const registerLinearProgressChart: () => void;

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

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

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

@@ -0,0 +1,6 @@
+import { RoseLikeChartSpecTransformer } from '../polar';
+import type { IRoseChartSpec } from '../rose';
+export declare class RadarChartSpecTransformer<T extends IRoseChartSpec = IRoseChartSpec> extends RoseLikeChartSpecTransformer<T> {
+    protected _getDefaultSeriesSpec(spec: any): any;
+    transformSpec(spec: T): void;
+}

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

@@ -0,0 +1,14 @@
+import type { IRoseChartSpec } from '../rose';
+import { RadarChartSpecTransformer } from './radar-transformer';
+import { BaseChart } from '../base';
+export declare class RadarChart<T extends IRoseChartSpec = IRoseChartSpec> extends BaseChart<T> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof RadarChartSpecTransformer;
+    readonly transformerConstructor: typeof RadarChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _canStack: boolean;
+}
+export declare const registerRadarChart: () => void;

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

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

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[];
+}