@visactor/vchart-types 0.10.0-alpha.2

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

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

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

@@ -0,0 +1,13 @@
+import type { IRangeAreaChartSpec } from './interface';
+import { RangeAreaChartSpecTransformer } from './range-area-transformer';
+import { BaseChart } from '../base';
+export declare class RangeAreaChart<T extends IRangeAreaChartSpec = IRangeAreaChartSpec> extends BaseChart<T> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof RangeAreaChartSpecTransformer;
+    readonly transformerConstructor: typeof RangeAreaChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerRangeAreaChart: () => void;

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

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

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

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

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

@@ -0,0 +1,13 @@
+import type { IRangeColumn3dChartSpec } from '../interface';
+import { RangeColumn3dChartSpecTransformer } from './range-column-3d-transformer';
+import { BaseChart } from '../../base';
+export declare class RangeColumn3dChart<T extends IRangeColumn3dChartSpec = IRangeColumn3dChartSpec> extends BaseChart<T> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof RangeColumn3dChartSpecTransformer;
+    readonly transformerConstructor: typeof RangeColumn3dChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerRangeColumn3dChart: () => void;

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

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

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

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

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

@@ -0,0 +1,13 @@
+import type { IRangeColumnChartSpec } from './interface';
+import { RangeColumnChartSpecTransformer } from './range-column-transformer';
+import { BaseChart } from '../base';
+export declare class RangeColumnChart<T extends IRangeColumnChartSpec = IRangeColumnChartSpec> extends BaseChart<T> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof RangeColumnChartSpecTransformer;
+    readonly transformerConstructor: typeof RangeColumnChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerRangeColumnChart: () => void;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/types/chart/scatter/scatter.d.ts

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

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

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

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

@@ -0,0 +1,24 @@
+import type { IChartSpec, ISeriesSpec } from '../../typings/spec/common';
+import type { ICartesianAxisSpec } from '../../component/axis/cartesian/interface';
+import type { IDataZoomSpec, IScrollBarSpec } from '../../component/data-zoom';
+import type { ICartesianCrosshairSpec } from '../../component/crosshair/interface';
+import type { ILayoutSpec } from '../../layout/interface';
+import type { IRegionSpec } from '../../region/interface';
+import type { IPadding } from '../../typings';
+export interface ISequenceChartSpec extends IChartSpec {
+    type: 'sequence';
+    appendPadding?: IPadding;
+    axes?: ICartesianAxisSpec[];
+    dataZooms?: IDataZoomSpec[];
+    scrollBars?: IScrollBarSpec[];
+    crosshair?: ICartesianCrosshairSpec | ICartesianCrosshairSpec[];
+    layout?: ILayoutSpec;
+    region?: IRegionSpec[];
+}
+export interface ISequenceSeriesSpec extends ISeriesSpec {
+    height?: number;
+    padding?: number;
+    dataDot?: any;
+    dotSeriesIndex?: number;
+    dotSeriesSpec?: ISeriesSpec;
+}

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

@@ -0,0 +1,7 @@
+import { BaseChartSpecTransformer } from '../base';
+import type { ISequenceChartSpec } from './interface';
+export declare class SequenceChartSpecTransformer<T extends ISequenceChartSpec = ISequenceChartSpec> extends BaseChartSpecTransformer<T> {
+    private _getSeriesDataLength;
+    addAttrToComponentSpec(componentSpec: any, attr: string, value: any): any;
+    transformSpec(spec: T): void;
+}

package/types/chart/sequence/sequence.d.ts

@@ -0,0 +1,14 @@
+import { BaseChart } from '../base/base-chart';
+import type { ISequenceChartSpec } from './interface';
+import type { ISeriesConstructor } from '../../series/interface';
+import type { IModelSpecInfo } from '../../model/interface';
+import { SequenceChartSpecTransformer } from './sequence-transformer';
+export declare class SequenceChart<T extends ISequenceChartSpec = ISequenceChartSpec> extends BaseChart<T> {
+    static readonly type: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof SequenceChartSpecTransformer;
+    readonly transformerConstructor: typeof SequenceChartSpecTransformer;
+    readonly type: string;
+    protected _createSeries(constructor: ISeriesConstructor, specInfo: IModelSpecInfo): void;
+}
+export declare const registerSequenceChart: () => void;

package/types/chart/stack.d.ts

@@ -0,0 +1,11 @@
+import type { IRegion } from '../region/interface';
+import type { IChart } from './interface';
+export declare class Stack {
+    protected _chart: IChart;
+    constructor(chart: IChart);
+    init(): void;
+    stackAll(): void;
+    stackRegion: ({ model }: {
+        model: IRegion;
+    }) => void;
+}

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

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

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

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

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

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

package/types/chart/sunburst/sunburst.d.ts

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

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

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

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

@@ -0,0 +1,6 @@
+import type { ITreemapSeriesSpec } from '../../series/treemap/interface';
+import type { IChartSpec } from '../../typings/spec/common';
+export interface ITreemapChartSpec extends Omit<IChartSpec, 'data' | 'series'>, ITreemapSeriesSpec {
+    type: 'treemap';
+    series?: ITreemapSeriesSpec[];
+}

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

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

package/types/chart/treemap/treemap.d.ts

@@ -0,0 +1,14 @@
+import { BaseChart } from '../base/base-chart';
+import type { ITreemapChartSpec } from './interface';
+import type { AdaptiveSpec } from '../../typings';
+import { TreemapChartSpecTransformer } from './treemap-transformer';
+export declare class TreemapChart<T extends ITreemapChartSpec = ITreemapChartSpec> extends BaseChart<AdaptiveSpec<T, 'data' | 'series'>> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof TreemapChartSpecTransformer;
+    readonly transformerConstructor: typeof TreemapChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerTreemapChart: () => void;

package/types/chart/util.d.ts

@@ -0,0 +1,23 @@
+import type { IChartSpec } from '../typings';
+import type { ICartesianChartSpec } from './cartesian/interface';
+import type { IChartOption } from './interface/common';
+import type { IUpdateSpecResult } from '../model/interface';
+export declare function setDefaultCrosshairForCartesianChart(spec: ICartesianChartSpec): void;
+export declare function calculateChartSize(spec: {
+    width?: number;
+    height?: number;
+}, option: Pick<IChartOption, 'canvas' | 'container' | 'mode' | 'modeParams'>, defaultSize: {
+    width: number;
+    height: number;
+}): {
+    width: number;
+    height: number;
+};
+export declare function mergeUpdateResult(target: IUpdateSpecResult, ...sources: IUpdateSpecResult[]): IUpdateSpecResult;
+export declare function getTrimPaddingConfig(chartType: string, spec: IChartSpec): {
+    paddingInner: number;
+    paddingOuter: number;
+} | {
+    paddingOuter: number;
+    paddingInner?: undefined;
+};

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

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

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

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

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

@@ -0,0 +1,7 @@
+import type { AdaptiveSpec } from '../../typings';
+import { BarChartSpecTransformer } from '../bar';
+import type { IWaterfallChartSpec } from './interface';
+export declare class WaterfallChartSpecTransformer<T extends IWaterfallChartSpec = IWaterfallChartSpec> extends BarChartSpecTransformer<AdaptiveSpec<T, 'type' | 'series' | 'label'>> {
+    transformSpec(spec: AdaptiveSpec<T, 'type' | 'series' | 'label'>): void;
+    protected _getDefaultSeriesSpec(spec: AdaptiveSpec<T, 'type' | 'series' | 'label'>): any;
+}

package/types/chart/waterfall/waterfall.d.ts

@@ -0,0 +1,14 @@
+import { BarChart } from '../bar';
+import type { IWaterfallChartSpec } from './interface';
+import type { AdaptiveSpec } from '../../typings';
+import { WaterfallChartSpecTransformer } from './waterfall-transformer';
+export declare class WaterfallChart<T extends IWaterfallChartSpec = IWaterfallChartSpec> extends BarChart<AdaptiveSpec<T, 'type' | 'series' | 'label'>> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof WaterfallChartSpecTransformer;
+    readonly transformerConstructor: typeof WaterfallChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerWaterfallChart: () => void;

package/types/chart/word-cloud/3d/index.d.ts

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

package/types/chart/word-cloud/3d/word-cloud-3d-transformer.d.ts

@@ -0,0 +1,6 @@
+import type { AdaptiveSpec } from '../../../typings';
+import { BaseWordCloudChartSpecTransformer } from '../base/word-cloud-base-transformer';
+import type { IWordCloud3dChartSpec } from '../interface';
+export declare class WordCloud3dChartSpecTransformer<T extends IWordCloud3dChartSpec = IWordCloud3dChartSpec> extends BaseWordCloudChartSpecTransformer<AdaptiveSpec<T, 'type' | 'series'>> {
+    protected _getDefaultSeriesSpec(spec: IWordCloud3dChartSpec): any;
+}

package/types/chart/word-cloud/3d/word-cloud-3d.d.ts

@@ -0,0 +1,15 @@
+import type { IWordCloud3dChartSpec } from '../interface';
+import { BaseWordCloudChart } from '../base/base';
+import type { AdaptiveSpec } from '../../../typings';
+import { WordCloud3dChartSpecTransformer } from './word-cloud-3d-transformer';
+export declare class WordCloud3dChart<T extends IWordCloud3dChartSpec = IWordCloud3dChartSpec> extends BaseWordCloudChart<AdaptiveSpec<T, 'type' | 'series'>> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof WordCloud3dChartSpecTransformer;
+    readonly transformerConstructor: typeof WordCloud3dChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerWordCloud3dChart: () => void;
+export declare const registerWordCloudShape3dChart: () => void;

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

@@ -0,0 +1,9 @@
+import { BaseChart } from '../../base/base-chart';
+import type { IWordCloudChartSpec } from '../interface';
+import { BaseWordCloudChartSpecTransformer } from './word-cloud-base-transformer';
+export declare class BaseWordCloudChart<T extends IWordCloudChartSpec> extends BaseChart<T> {
+    static readonly transformerConstructor: typeof BaseWordCloudChartSpecTransformer;
+    readonly transformerConstructor: typeof BaseWordCloudChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+}

package/types/chart/word-cloud/base/index.d.ts

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

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

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

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

@@ -0,0 +1,6 @@
+import { BaseChart } from '../base-chart';
+export declare class BaseWordCloudChart extends BaseChart {
+    readonly type: string;
+    readonly seriesType: string;
+    transformSpec(spec: any): void;
+}

package/types/chart/word-cloud/index.d.ts

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

package/types/chart/word-cloud/interface.d.ts

@@ -0,0 +1,10 @@
+import type { IWordCloud3dSeriesSpec, IWordCloudSeriesSpec } from '../../series/word-cloud/interface';
+import type { IChartExtendsSeriesSpec, IChartSpec } from '../../typings/spec/common';
+export interface IWordCloudChartSpec extends IChartSpec, IChartExtendsSeriesSpec<IWordCloudSeriesSpec> {
+    type: 'wordCloud';
+    series?: IWordCloudSeriesSpec[];
+}
+export interface IWordCloud3dChartSpec extends IChartSpec, IChartExtendsSeriesSpec<IWordCloud3dSeriesSpec> {
+    type: 'wordCloud3d';
+    series?: IWordCloud3dSeriesSpec[];
+}

package/types/chart/word-cloud/word-cloud-3d.d.ts

@@ -0,0 +1,11 @@
+import type { IWordCloud3dChartSpec } from './interface';
+import { BaseWordCloudChart } from './base';
+export declare class WordCloud3dChart extends BaseWordCloudChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _getDefaultSeriesSpec(spec: IWordCloud3dChartSpec): any;
+}
+export declare const registerWordCloud3dChart: () => void;
+export declare const registerWordCloudShape3dChart: () => void;

package/types/chart/word-cloud/word-cloud-transformer.d.ts

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

package/types/chart/word-cloud/word-cloud.d.ts

@@ -0,0 +1,14 @@
+import type { IWordCloudChartSpec } from './interface';
+import { BaseWordCloudChart } from './base/base';
+import { WordCloudChartSpecTransformer } from './word-cloud-transformer';
+export declare class WordCloudChart<T extends IWordCloudChartSpec = IWordCloudChartSpec> extends BaseWordCloudChart<T> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly view: string;
+    static readonly transformerConstructor: typeof WordCloudChartSpecTransformer;
+    readonly transformerConstructor: typeof WordCloudChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerWordCloudChart: () => void;
+export declare const registerWordCloudShapeChart: () => void;

package/types/compile/compilable-base.d.ts

@@ -0,0 +1,11 @@
+import type { Compiler } from './compiler';
+import type { ICompilableInitOption, ICompilable } from './interface';
+export declare abstract class CompilableBase implements ICompilable {
+    protected _option: ICompilableInitOption;
+    getOption(): ICompilableInitOption;
+    getCompiler: () => Compiler;
+    constructor(option: ICompilableInitOption);
+    getVGrammarView(): import("@visactor/vgrammar-core").IView;
+    abstract compile(): void;
+    release(): void;
+}

package/types/compile/compiler.d.ts

@@ -0,0 +1,71 @@
+import type { InteractionSpec, IView } from '@visactor/vgrammar-core';
+import type { CompilerListenerParameters, CompilerModel, IGrammarItem, IRenderContainer, IRenderOption } from './interface';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { EventSourceType } from '../event/interface';
+import type { IChart } from '../chart/interface';
+import type { VChart } from '../core/vchart';
+import type { IColor, Stage } from '@visactor/vrender-core';
+import type { IMorphConfig } from '../animation/spec';
+type EventListener = {
+    type: string;
+    callback: (...args: any[]) => void;
+};
+export declare class Compiler {
+    protected _view: IView;
+    getVGrammarView(): IView;
+    protected _viewListeners: Map<(...args: any[]) => any, EventListener>;
+    protected _windowListeners: Map<(...args: any[]) => any, EventListener>;
+    protected _canvasListeners: Map<(...args: any[]) => any, EventListener>;
+    isInited: boolean;
+    private _isRunning;
+    private _nextRafId;
+    protected _width: number;
+    protected _height: number;
+    protected _container: IRenderContainer;
+    protected _option: IRenderOption;
+    protected _model: CompilerModel;
+    protected _interactions: (InteractionSpec & {
+        seriesId?: number;
+        regionId?: number;
+    })[];
+    getModel(): CompilerModel;
+    private _compileChart;
+    constructor(container: IRenderContainer, option: IRenderOption);
+    getRenderer(): import("@visactor/vgrammar-core").IRenderer;
+    getCanvas(): HTMLCanvasElement | undefined;
+    getStage(): Stage | undefined;
+    initView(): void;
+    private _setCanvasStyle;
+    compileInteractions(): void;
+    compile(ctx: {
+        chart: IChart;
+        vChart: VChart;
+    }, option: any): void;
+    clear(ctx: {
+        chart: IChart;
+        vChart: VChart;
+    }, removeGraphicItems?: boolean): void;
+    renderNextTick(morphConfig?: IMorphConfig): void;
+    render(morphConfig?: IMorphConfig): void;
+    updateViewBox(viewBox: IBoundsLike, reRender?: boolean): void;
+    resize(width: number, height: number, reRender?: boolean): void;
+    setBackground(color: IColor): void;
+    setSize(width: number, height: number): void;
+    setViewBox(viewBox: IBoundsLike, reRender?: boolean): void;
+    addEventListener(source: EventSourceType, type: string, callback: (params: CompilerListenerParameters) => void): void;
+    removeEventListener(source: EventSourceType, type: string, callback: (params: CompilerListenerParameters) => void): void;
+    protected releaseEvent(): void;
+    release(): void;
+    releaseGrammar(removeGraphicItems?: boolean): void;
+    protected _releaseModel(): void;
+    addGrammarItem(grammarItem: IGrammarItem): void;
+    removeGrammarItem(grammarItem: IGrammarItem, reserveVGrammarModel?: boolean): void;
+    addInteraction(interaction: InteractionSpec & {
+        seriesId?: number;
+        regionId?: number;
+    }): void;
+    removeInteraction(seriesId: number): void;
+    updateDepend(items?: IGrammarItem[]): boolean;
+    private _getGlobalThis;
+}
+export {};