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

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

@@ -0,0 +1,100 @@
+import type { IFunnelSeries, SeriesMarkMap } from '../interface';
+import { SeriesMarkNameEnum } from '../interface';
+import type { IOrientType, Maybe, Datum, StringOrNumber } from '../../typings';
+import { SeriesTypeEnum } from '../interface';
+import type { IPolygonMark } from '../../mark/polygon/polygon';
+import { BaseSeries } from '../base/base-series';
+import { MarkTypeEnum } from '../../mark/interface';
+import type { ITextMark } from '../../mark/text';
+import type { IFunnelSeriesSpec, IFunnelSeriesTheme } from './interface';
+import type { IRuleMark } from '../../mark/rule';
+import { SeriesData } from '../base/series-data';
+export declare class FunnelSeries extends BaseSeries<IFunnelSeriesSpec> implements IFunnelSeries {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    protected _funnelMarkName: SeriesMarkNameEnum;
+    protected _funnelMarkType: MarkTypeEnum;
+    protected _transformMarkName: SeriesMarkNameEnum;
+    protected _transformMarkType: MarkTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _categoryField: string;
+    getCategoryField(): string;
+    setCategoryField(f: string): string;
+    protected _valueField: string;
+    getValueField(): string;
+    setValueField(f: string): string;
+    protected _viewDataTransform: SeriesData;
+    protected _theme: Maybe<IFunnelSeriesTheme>;
+    protected _funnelAlign: 'left' | 'center' | 'right' | 'top' | 'bottom';
+    protected _funnelOrient: IOrientType;
+    protected _shape: 'rect' | 'trapezoid';
+    protected _funnelMark: IPolygonMark | null;
+    protected _funnelTransformMark: IPolygonMark | null;
+    protected _labelMark: ITextMark | null;
+    protected _transformLabelMark: ITextMark | null;
+    protected _funnelOuterLabelMark: {
+        label?: ITextMark;
+        line?: IRuleMark;
+    };
+    setAttrFromSpec(): void;
+    initData(): void;
+    getStatisticFields(): {
+        key: string;
+        operations: Array<'max' | 'min' | 'values'>;
+    }[];
+    protected _statisticViewData(): void;
+    initMark(): void;
+    protected initTooltip(): void;
+    getDimensionField(): string[];
+    getMeasureField(): string[];
+    getGroupFields(): string[];
+    initMarkStyle(): void;
+    initAnimation(): void;
+    initGroups(): void;
+    getStackGroupFields(): string[];
+    getStackValueField(): string;
+    setValueFieldToStack(): void;
+    setValueFieldToPercent(): void;
+    protected initEvent(): void;
+    getPoints(datum: Datum): {
+        x: number;
+        y: number;
+    }[];
+    isTransformLevel(datum: Datum): boolean;
+    protected _buildMarkAttributeContext(): void;
+    valueToPosition(category: StringOrNumber): {
+        x: number;
+        y: number;
+    };
+    dataToPosition(datum: any): {
+        x: number;
+        y: number;
+    };
+    dataToPositionX(datum: any): number;
+    dataToPositionY(datum: any): number;
+    dataToPositionZ(datum: any): number;
+    private _getMainAxisLength;
+    private _getSecondaryAxisLength;
+    private _getPositionByData;
+    private _getPolygonPoints;
+    private _getPolygonCenter;
+    private _adjustPoints;
+    private _computeLabelPosition;
+    private _computeLabelLimit;
+    private _computeOuterLabelPosition;
+    private _computeOuterLabelLimit;
+    private _computeOuterLabelLinePosition;
+    protected _computeMaxSize(): number;
+    protected _computeMinSize(): number;
+    protected _isHorizontal(): boolean;
+    private _isReverse;
+    setValueFieldToStackOffsetSilhouette(): void;
+    getDefaultShapeType(): string;
+    updateSpec(spec: IFunnelSeriesSpec): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+}

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

@@ -0,0 +1,61 @@
+import type { Datum, IMarkSpec, IMarkTheme, ISeriesSpec, IOrientType, IPathMarkSpec, IPolygonMarkSpec, IRuleMarkSpec, ITextMarkSpec, IPyramid3dMarkSpec } from '../../typings';
+import type { IPercent } from '../../model/interface';
+import type { IAnimationSpec } from '../../animation/spec';
+import type { SeriesMarkNameEnum } from '../interface';
+type FunnelMarks = 'funnel';
+export type FunnelAppearPreset = 'clipIn' | 'fadeIn';
+export interface IFunnelSeriesSpec extends ISeriesSpec, IAnimationSpec<FunnelMarks, FunnelAppearPreset> {
+    type: 'funnel';
+    categoryField: string;
+    valueField: string;
+    funnelOrient?: IOrientType;
+    shape?: 'rect' | 'trapezoid';
+    isTransform?: boolean;
+    isCone?: boolean;
+    funnelAlign?: 'left' | 'center' | 'right';
+    gap?: number;
+    range?: {
+        min?: number;
+        max?: number;
+    };
+    maxSize?: number | IPercent;
+    minSize?: number | IPercent;
+    [SeriesMarkNameEnum.funnel]?: IMarkSpec<IPathMarkSpec>;
+    [SeriesMarkNameEnum.transform]?: IMarkSpec<IPathMarkSpec>;
+    [SeriesMarkNameEnum.label]?: IFunnelLabelSpec;
+    [SeriesMarkNameEnum.outerLabel]?: IFunnelOuterLabelSpec;
+    [SeriesMarkNameEnum.transformLabel]?: IFunnelLabelSpec;
+}
+interface IFunnelLabelSpec extends IMarkSpec<ITextMarkSpec> {
+    limit?: 'shapeSize' | number;
+    formatMethod?: (text: string | string[], datum?: Datum) => string | string[];
+}
+export interface IFunnelOuterLabelSpec extends IFunnelLabelSpec {
+    position?: 'left' | 'right' | 'top' | 'bottom';
+    spaceWidth?: number;
+    alignLabel?: boolean;
+    style?: ITextMarkSpec;
+    line?: IMarkSpec<IRuleMarkSpec>;
+}
+export interface IFunnelSeriesTheme {
+    [SeriesMarkNameEnum.funnel]?: Partial<IMarkTheme<IPolygonMarkSpec>>;
+    [SeriesMarkNameEnum.transform]?: Partial<IMarkTheme<IPolygonMarkSpec>>;
+    [SeriesMarkNameEnum.label]?: Partial<IMarkTheme<ITextMarkSpec>>;
+    [SeriesMarkNameEnum.outerLabel]?: Partial<IMarkTheme<ITextMarkSpec>> & {
+        line?: Partial<IMarkTheme<IRuleMarkSpec>>;
+    };
+    [SeriesMarkNameEnum.transformLabel]?: Partial<IMarkTheme<ITextMarkSpec>>;
+}
+export type IFunnel3dSeriesSpec = {
+    type: 'funnel3d';
+} & Omit<IFunnelSeriesSpec, 'type'>;
+export interface IFunnel3dSeriesTheme {
+    [SeriesMarkNameEnum.funnel3d]?: Partial<IMarkTheme<IPyramid3dMarkSpec>>;
+    [SeriesMarkNameEnum.transform3d]?: Partial<IMarkTheme<IPyramid3dMarkSpec>>;
+    [SeriesMarkNameEnum.label]?: Partial<IMarkTheme<ITextMarkSpec>>;
+    [SeriesMarkNameEnum.outerLabel]?: Partial<IMarkTheme<ITextMarkSpec>> & {
+        line?: Partial<IMarkTheme<IRuleMarkSpec>>;
+    };
+    [SeriesMarkNameEnum.transformLabel]?: Partial<IMarkTheme<ITextMarkSpec>>;
+}
+export {};

package/build/es5/series/funnel/tooltip-helper.d.ts

@@ -0,0 +1,9 @@
+import type { ISeriesTooltipHelper } from '../interface';
+import { BaseSeriesTooltipHelper } from '../base/tooltip-helper';
+import type { TooltipHandlerParams } from '../../component/tooltip/interface';
+import type { Datum } from '@visactor/vgrammar';
+export declare class FunnelSeriesTooltipHelper extends BaseSeriesTooltipHelper implements ISeriesTooltipHelper {
+    titleValueCallback: (datum: Datum, params?: TooltipHandlerParams) => any;
+    contentValueCallback: (datum: Datum, params?: TooltipHandlerParams) => any;
+    contentKeyCallback: (datum: Datum, params?: TooltipHandlerParams) => any;
+}

package/build/es5/series/gauge/gauge-pointer.d.ts

@@ -0,0 +1,32 @@
+import { MarkTypeEnum } from '../../mark/interface';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface';
+import type { IGaugePointerSeriesSpec, IGaugePointerSeriesTheme } from './interface';
+import type { Datum, Maybe } from '../../typings';
+import { ProgressLikeSeries } from '../polar/progress-like';
+export declare class GaugePointerSeries extends ProgressLikeSeries<IGaugePointerSeriesSpec> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _theme: Maybe<IGaugePointerSeriesTheme>;
+    protected _spec: IGaugePointerSeriesSpec;
+    private _pinMark;
+    private _pointerMark;
+    private _pinBackgroundMark;
+    protected _pointerType: MarkTypeEnum;
+    setAttrFromSpec(): void;
+    initMark(): void;
+    initMarkStyle(): void;
+    initGroups(): void;
+    private initPointerMarkStyle;
+    protected _getPointerWidth(): number;
+    protected _getPointerHeight(datum: Datum): number;
+    protected _getPointerAngle(datum: Datum): number;
+    protected _getRotatedPointerCenterOffset(datum: Datum): {
+        x: number;
+        y: number;
+    };
+    private initPinBackgroundMarkStyle;
+    private initPinMarkStyle;
+    initAnimation(): void;
+}

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

@@ -0,0 +1,25 @@
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface';
+import type { IGaugeSeriesSpec, IGaugeSeriesTheme } from './interface';
+import { ProgressLikeSeries } from '../polar/progress-like/progress-like';
+import type { Datum } from '@visactor/vgrammar';
+import type { Maybe } from '../../typings';
+export declare class GaugeSeries extends ProgressLikeSeries<IGaugeSeriesSpec> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _theme: Maybe<IGaugeSeriesTheme>;
+    private _segmentMark;
+    private _trackMark;
+    protected _stack: boolean;
+    protected _padAngle: number;
+    setAttrFromSpec(): void;
+    initData(): void;
+    initMark(): void;
+    initMarkStyle(): void;
+    private initSegmentMarkStyle;
+    private initTrackMarkStyle;
+    protected _getAngleValueStart(datum: Datum): number;
+    protected _getAngleValueEnd(datum: Datum): number;
+    initAnimation(): void;
+}

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

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

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

@@ -0,0 +1,44 @@
+import type { IMarkSpec, IMarkTheme } from '../../typings/spec';
+import type { IArcMarkSpec, IPathMarkSpec, IProgressArcMarkSpec, IRectMarkSpec } from '../../typings/visual';
+import type { IProgressLikeSeriesSpec, IProgressLikeSeriesTheme } from '../polar/progress-like/interface';
+import type { IAnimationSpec } from '../../animation/spec';
+import type { ProgressLikeAppearPreset } from '../polar/progress-like';
+import type { SeriesMarkNameEnum } from '../interface';
+export type GaugePointerMarks = 'pointer' | 'pin' | 'pinBackground';
+export interface IGaugePointerSeriesSpec extends IProgressLikeSeriesSpec, IAnimationSpec<GaugePointerMarks, ProgressLikeAppearPreset> {
+    type: 'gaugePointer';
+    valueField: string | string[];
+    radiusField: string;
+    [SeriesMarkNameEnum.pin]?: IMarkSpec<IPathMarkSpec> & PinMarkSpec;
+    [SeriesMarkNameEnum.pinBackground]?: IMarkSpec<IPathMarkSpec> & PinMarkSpec;
+    [SeriesMarkNameEnum.pointer]?: IMarkSpec<IPathMarkSpec | IRectMarkSpec> & PointerMarkSpec;
+}
+export type PointerMarkSpec = {
+    type: 'path' | 'rect';
+    width?: number;
+    height?: number;
+    innerPadding?: number;
+    outerPadding?: number;
+    center?: [number, number];
+};
+export type PinMarkSpec = {
+    width?: number;
+    height?: number;
+};
+export interface IGaugePointerSeriesTheme extends IProgressLikeSeriesTheme {
+    [SeriesMarkNameEnum.pin]?: Partial<IMarkTheme<IPathMarkSpec> & PinMarkSpec>;
+    [SeriesMarkNameEnum.pinBackground]?: Partial<IMarkTheme<IPathMarkSpec> & PinMarkSpec>;
+    [SeriesMarkNameEnum.pointer]?: Partial<IMarkTheme<IPathMarkSpec | IRectMarkSpec> & PointerMarkSpec>;
+}
+export type GaugeMarks = 'segment' | 'track';
+export interface IGaugeSeriesSpec extends IProgressLikeSeriesSpec, IAnimationSpec<GaugeMarks, ProgressLikeAppearPreset> {
+    type: 'gauge';
+    padAngle?: number;
+    [SeriesMarkNameEnum.segment]?: IMarkSpec<IProgressArcMarkSpec>;
+    [SeriesMarkNameEnum.track]?: IMarkSpec<IArcMarkSpec>;
+}
+export interface IGaugeSeriesTheme extends IProgressLikeSeriesTheme {
+    padAngle?: number;
+    [SeriesMarkNameEnum.segment]?: Partial<IMarkTheme<IProgressArcMarkSpec>>;
+    [SeriesMarkNameEnum.track]?: Partial<IMarkTheme<IArcMarkSpec>>;
+}

package/build/es5/series/geo/geo.d.ts

@@ -0,0 +1,52 @@
+import type { IGeoCoordinateHelper } from '../../component/geo/interface';
+import type { IPoint } from '../../typings';
+import type { IGeoSeries } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import { BaseSeries } from '../base/base-series';
+import type { SeriesData } from '../base/series-data';
+import type { DataView } from '@visactor/vdataset';
+import type { IGeoSeriesSpec } from './interface';
+export declare abstract class GeoSeries<T extends IGeoSeriesSpec = IGeoSeriesSpec> extends BaseSeries<T> implements IGeoSeries {
+    type: SeriesTypeEnum;
+    readonly coordinate = "geo";
+    protected _mapViewData: SeriesData;
+    getMapViewData(): DataView;
+    protected _mapViewDataStatistics: DataView;
+    _nameField: string;
+    get nameField(): string;
+    set nameField(f: string);
+    _valueField: string;
+    get valueField(): string;
+    set valueField(f: string);
+    _coordinateHelper: IGeoCoordinateHelper;
+    getCoordinateHelper(): IGeoCoordinateHelper;
+    setCoordinateHelper(h: IGeoCoordinateHelper): void;
+    getStatisticFields(): {
+        key: string;
+        operations: Array<'max' | 'min' | 'values'>;
+    }[];
+    getGroupFields(): string[];
+    dataToPosition(datum: any): IPoint | null;
+    protected nameToPosition(datum: any): IPoint | null;
+    protected abstract _getDatumCenter(datum: any): [number, number];
+    protected abstract _getDatumName(datum: any): string;
+    dataToLatitude(latValue: number): number;
+    dataToLongitude(lonValue: number): number;
+    valueToPosition(lonValue: number, latValue: number): IPoint;
+    positionToData(p: IPoint): void;
+    latitudeToData(lat: number): void;
+    longitudeToData(lon: number): void;
+    dataToPositionX(data: any): number;
+    dataToPositionY(data: any): number;
+    dataToPositionZ(data: any): number;
+    release(): void;
+    getStackGroupFields(): string[];
+    getStackValueField(): string;
+    setValueFieldToStack(): void;
+    setValueFieldToPercent(): void;
+    setValueFieldToStackOffsetSilhouette(): void;
+    compileData(): void;
+    protected initStatisticalData(): void;
+    getSeriesKeys(): string[];
+    fillData(): void;
+}

package/build/es5/series/geo/interface.d.ts

@@ -0,0 +1,4 @@
+import type { ISeriesSpec } from '../..';
+export interface IGeoSeriesSpec extends ISeriesSpec {
+    valueField?: string;
+}

package/build/es5/series/heatmap/animation.d.ts

@@ -0,0 +1,3 @@
+import type { IAnimationTypeConfig } from '@visactor/vgrammar';
+export type HeatmapAppearPreset = 'fadeIn';
+export declare function heatmapPresetAnimation(preset: HeatmapAppearPreset | boolean): IAnimationTypeConfig;

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

@@ -0,0 +1,43 @@
+import { CartesianSeries } from '../cartesian/cartesian';
+import type { Maybe } from '../../typings';
+import type { IHeatmapSeriesSpec, IHeatmapSeriesTheme } from './interface';
+import type { IAxisHelper } from '../../component/axis/cartesian/interface';
+import type { ITextMark } from '../../mark/text';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface';
+import type { ICellMark } from '../../mark/cell';
+export declare const DefaultBandWidth = 6;
+export declare class HeatmapSeries extends CartesianSeries<IHeatmapSeriesSpec> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _theme: Maybe<IHeatmapSeriesTheme>;
+    protected _cellMark: ICellMark;
+    protected _backgroundMark: ICellMark;
+    protected _fieldValue: string[];
+    getFieldValue(): string[];
+    setFieldValue(f: string | string[]): void;
+    setAttrFromSpec(): void;
+    initMark(): void;
+    initMarkStyle(): void;
+    initLabelMarkStyle(textMark: ITextMark): void;
+    initCellMarkStyle(): void;
+    initCellBackgroundMarkStyle(): void;
+    getColorAttribute(): {
+        scale: any;
+        field: any;
+    };
+    initAnimation(): void;
+    protected getCellSize(axisHelper: IAxisHelper): number;
+    updateSpec(spec: IHeatmapSeriesSpec): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    protected initTooltip(): void;
+    getDefaultShapeType(): string;
+    getDimensionField(): string[];
+    getMeasureField(): string[];
+}

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

@@ -0,0 +1,23 @@
+import type { ICartesianSeriesSpec, ICartesianSeriesTheme } from '../cartesian/interface';
+import type { IMarkSpec, IMarkTheme } from '../../typings/spec/common';
+import type { IRectMarkSpec } from '../../typings/visual';
+import type { IAnimationSpec } from '../../animation/spec';
+import type { HeatmapAppearPreset } from './animation';
+import type { ILabelSpec } from '../../component/label';
+import type { IMarkProgressiveConfig } from '../../mark/interface';
+import type { SeriesMarkNameEnum } from '../interface';
+type HeatmapMarks = 'cell' | 'background' | 'label';
+export interface IHeatmapSeriesSpec extends ICartesianSeriesSpec, IAnimationSpec<HeatmapMarks, HeatmapAppearPreset>, IMarkProgressiveConfig {
+    type: 'heatmap';
+    valueField?: string;
+    [SeriesMarkNameEnum.cell]?: IMarkSpec<IRectMarkSpec>;
+    [SeriesMarkNameEnum.cellBackground]?: IMarkSpec<IRectMarkSpec>;
+    [SeriesMarkNameEnum.label]?: ILabelSpec & {
+        position?: 'inside' | 'inside-top' | 'inside-bottom' | 'inside-right' | 'inside-left';
+    };
+}
+export interface IHeatmapSeriesTheme extends ICartesianSeriesTheme {
+    [SeriesMarkNameEnum.cell]?: Partial<IMarkTheme<IRectMarkSpec>>;
+    [SeriesMarkNameEnum.cellBackground]?: Partial<IMarkTheme<IRectMarkSpec>>;
+}
+export {};

package/build/es5/series/heatmap/tooltip-helper.d.ts

@@ -0,0 +1,6 @@
+import type { ITooltipPattern, TooltipActiveType } from '../../typings';
+import { BaseSeriesTooltipHelper } from '../base/tooltip-helper';
+import type { IDimensionInfo } from '../../event/events/dimension/interface';
+export declare class HeatmapSeriesTooltipHelper extends BaseSeriesTooltipHelper {
+    getDefaultTooltipPattern(activeType: TooltipActiveType, dimensionInfo?: IDimensionInfo[]): ITooltipPattern | null;
+}

package/build/es5/series/index.d.ts

@@ -0,0 +1,66 @@
+import { WaterfallSeries } from './waterfall/waterfall';
+import type { IWaterfallSeriesSpec } from './waterfall/interface';
+import { BoxPlotSeries } from './box-plot/box-plot';
+import type { IBoxPlotSeriesSpec } from './box-plot/interface';
+import { LineSeries } from './line/line';
+import type { ILineSeriesSpec } from './line/interface';
+import { BarSeries } from './bar/bar';
+import { Bar3dSeries } from './bar/bar-3d';
+import type { IBar3dSeriesSpec, IBarSeriesSpec } from './bar/interface';
+import { RangeColumnSeries } from './range-column/range-column';
+import { RangeColumn3dSeries } from './range-column/range-column-3d';
+import type { IRangeColumn3dSeriesSpec, IRangeColumnSeriesSpec } from './range-column/interface';
+import { RangeAreaSeries } from './range-area/range-area';
+import type { IRangeAreaSeriesSpec } from './range-area/interface';
+import { MapSeries } from './map/map';
+import type { IMapSeriesSpec } from './map/interface';
+import { PieSeries } from './pie/pie';
+import { Pie3dSeries } from './pie/pie-3d';
+import type { IPie3dSeriesSpec } from './pie/interface';
+import type { IPieSeriesSpec } from './pie/interface';
+import { ScatterSeries } from './scatter/scatter';
+import type { IScatterSeriesSpec } from './scatter/interface';
+import { RoseSeries } from './rose/rose';
+import type { IRoseSeriesSpec } from './rose/interface';
+import { RadarSeries } from './radar/radar';
+import type { IRadarSeriesSpec } from './radar/interface';
+import { AreaSeries } from './area/area';
+import type { IAreaSeriesSpec } from './area/interface';
+import { DotSeries } from './dot/dot';
+import type { IDotSeriesSpec } from './dot/interface';
+import { LinkSeries } from './link/link';
+import type { ILinkSeriesSpec } from './link/interface';
+import { CircularProgressSeries } from './progress/circular/circular';
+import type { ICircularProgressSeriesSpec } from './progress/circular/interface';
+import { LinearProgressSeries } from './progress/linear/linear';
+import type { ILinearProgressSeriesSpec } from './progress/linear/interface';
+import { WordCloudSeries } from './word-cloud/word-cloud';
+import { WordCloud3dSeries } from './word-cloud/word-cloud-3d';
+import type { IWordCloud3dSeriesSpec, IWordCloudSeriesSpec } from './word-cloud/interface';
+import { FunnelSeries } from './funnel/funnel';
+import { Funnel3dSeries } from './funnel/funnel-3d';
+import type { IFunnel3dSeriesSpec, IFunnelSeriesSpec } from './funnel/interface';
+import { SunburstSeries } from './sunburst/sunburst';
+import type { ISunburstSeriesSpec } from './sunburst/interface';
+import { CirclePackingSeries } from './circle-packing/circle-packing';
+import type { ICirclePackingSeriesSpec } from './circle-packing/interface';
+import { SankeySeries } from './sankey/sankey';
+import type { ISankeySeriesSpec } from './sankey/interface';
+import { TreeMapSeries } from './treemap/treemap';
+import type { ITreemapSeriesSpec } from './treemap/interface';
+import type { IGaugePointerSeriesSpec, IGaugeSeriesSpec } from './gauge';
+import { GaugePointerSeries, GaugeSeries } from './gauge';
+import { HeatmapSeries } from './heatmap/heatmap';
+import type { IHeatmapSeriesSpec } from './heatmap/interface';
+import { BaseSeries } from './base/base-series';
+import type { ICartesianSeriesSpec } from './cartesian';
+import { CartesianSeries } from './cartesian';
+import { PolarSeries } from './polar/polar';
+import type { IPolarSeriesSpec } from './polar/interface';
+import type { IProgressLikeSeriesSpec } from './polar/progress-like';
+import { ProgressLikeSeries } from './polar/progress-like';
+import type { IRoseLikeSeriesSpec } from './polar/rose-like';
+import { RoseLikeSeries } from './polar/rose-like';
+import type { ISeries } from './interface';
+export { WaterfallSeries, Bar3dSeries, BarSeries, BoxPlotSeries, LineSeries, RadarSeries, RangeAreaSeries, RangeColumn3dSeries, RangeColumnSeries, MapSeries, Pie3dSeries, PieSeries, SankeySeries, ScatterSeries, SunburstSeries, RoseLikeSeries, RoseSeries, AreaSeries, DotSeries, LinearProgressSeries, LinkSeries, CirclePackingSeries, CircularProgressSeries, WordCloud3dSeries, WordCloudSeries, Funnel3dSeries, FunnelSeries, TreeMapSeries, GaugePointerSeries, GaugeSeries, HeatmapSeries, BaseSeries, CartesianSeries, PolarSeries, ProgressLikeSeries };
+export type { ISeries, IRoseLikeSeriesSpec, IAreaSeriesSpec, IBar3dSeriesSpec, IBarSeriesSpec, IBoxPlotSeriesSpec, ICartesianSeriesSpec, ICirclePackingSeriesSpec, ICircularProgressSeriesSpec, IDotSeriesSpec, IFunnel3dSeriesSpec, IFunnelSeriesSpec, IGaugePointerSeriesSpec, IGaugeSeriesSpec, IHeatmapSeriesSpec, ILineSeriesSpec, ILinearProgressSeriesSpec, ILinkSeriesSpec, IMapSeriesSpec, IPie3dSeriesSpec, IPieSeriesSpec, IPolarSeriesSpec, IProgressLikeSeriesSpec, IRadarSeriesSpec, IRangeAreaSeriesSpec, IRangeColumn3dSeriesSpec, IRangeColumnSeriesSpec, IRoseSeriesSpec, ISankeySeriesSpec, IScatterSeriesSpec, ISunburstSeriesSpec, ITreemapSeriesSpec, IWaterfallSeriesSpec, IWordCloud3dSeriesSpec, IWordCloudSeriesSpec };

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

@@ -0,0 +1,120 @@
+import type { DataView } from '@visactor/vdataset';
+import type { IGrammarItem } from '../../compile/interface';
+import type { IGroupMark } from '../../mark/group';
+import type { IModelMarkInfo, IModelOption } from '../../model/interface';
+import type { IRegion } from '../../region/interface';
+import type { RenderMode } from '../../typings/spec/common';
+import type { ISeries } from './series';
+import type { IMarkProgressiveConfig } from '../../mark/interface';
+import type { StringOrNumber } from '../../typings';
+import type { ILabelSpec } from '../../component/label';
+export interface ISeriesSeriesInfo {
+    key: string;
+    index?: number;
+    style: (attribute: string) => any;
+    shapeType: string;
+}
+export interface ISeriesOption extends IModelOption {
+    mode: RenderMode;
+    region: IRegion;
+    getSeriesData: (id: StringOrNumber | undefined, index: number | undefined) => DataView | undefined;
+}
+export interface ISeriesConstructor {
+    type: string;
+    mark?: SeriesMarkMap;
+    new (spec: any, options: ISeriesOption): ISeries;
+}
+export interface ISeriesInitOption {
+}
+export interface ISeriesUpdateDataOption {
+}
+export interface ISeriesStackDataNode {
+    nodes: {
+        [key: string]: ISeriesStackDataMeta;
+    };
+}
+export interface ISeriesStackDataLeaf {
+    values: any[];
+}
+export type ISeriesStackDataMeta = ISeriesStackDataNode | ISeriesStackDataLeaf;
+export type ISeriesStackData = ISeriesStackDataNode;
+export type ISeriesStyle = ISeriesStyleItem[];
+export type ISeriesStyleItem = {
+    name: string;
+} & {
+    [markName: string]: {
+        style?: any;
+    };
+};
+export interface ISeriesMarkInitOption {
+    themeSpec?: any;
+    markSpec?: any;
+    skipBeforeLayouted?: boolean;
+    parent?: IGroupMark | false;
+    isSeriesMark?: boolean;
+    depend?: IGrammarItem | IGrammarItem[];
+    key?: string;
+    groupKey?: string;
+    morph?: boolean;
+    defaultMorphElementKey?: string;
+    dataView?: DataView | false;
+    dataProductId?: string;
+    dataStatistics?: DataView;
+    progressive?: IMarkProgressiveConfig;
+    label?: ILabelSpec;
+    support3d?: boolean;
+}
+export interface ISeriesMarkInfo extends IModelMarkInfo {
+    name: SeriesMarkNameEnum | string;
+}
+export declare enum SeriesMarkNameEnum {
+    label = "label",
+    point = "point",
+    line = "line",
+    area = "area",
+    bar = "bar",
+    bar3d = "bar3d",
+    boxPlot = "boxPlot",
+    outlier = "outlier",
+    circlePacking = "circlePacking",
+    group = "group",
+    gridBackground = "gridBackground",
+    grid = "grid",
+    dot = "dot",
+    title = "title",
+    subTitle = "subTitle",
+    symbol = "symbol",
+    funnel = "funnel",
+    funnel3d = "funnel3d",
+    transform = "transform",
+    transform3d = "transform3d",
+    transformLabel = "transformLabel",
+    outerLabel = "outerLabel",
+    outerLabelLine = "outerLabelLine",
+    pin = "pin",
+    pinBackground = "pinBackground",
+    pointer = "pointer",
+    segment = "segment",
+    track = "track",
+    cell = "cell",
+    cellBackground = "cellBackground",
+    link = "link",
+    arrow = "arrow",
+    pie = "pie",
+    pie3d = "pie3d",
+    labelLine = "labelLine",
+    progress = "progress",
+    minLabel = "minLabel",
+    maxLabel = "maxLabel",
+    rose = "rose",
+    node = "node",
+    sunburst = "sunburst",
+    nonLeaf = "nonLeaf",
+    leaf = "leaf",
+    nonLeafLabel = "nonLeafLabel",
+    leaderLine = "leaderLine",
+    stackLabel = "stackLabel",
+    word = "word",
+    fillingWord = "fillingWord"
+}
+export type SeriesMarkMap = Partial<Record<SeriesMarkNameEnum, ISeriesMarkInfo>>;

package/build/es5/series/interface/index.d.ts

@@ -0,0 +1,5 @@
+export * from './common';
+export * from './series';
+export * from './theme';
+export * from './tooltip-helper';
+export * from './type';