@visactor/vchart-types 0.10.0-alpha.2

package/types/series/geo/geo.d.ts

@@ -0,0 +1,55 @@
+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';
+import type { IMark } from '../../mark/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);
+    protected _nameProperty: string;
+    getNameProperty(): string;
+    protected _centroidProperty?: string;
+    getCentroidProperty(): 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;
+    abstract getDatumCenter(datum: any): [number, number];
+    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;
+    compileData(): void;
+    protected initStatisticalData(): void;
+    getSeriesKeys(): string[];
+    fillData(): void;
+    getActiveMarks(): IMark[];
+}

package/types/series/geo/interface.d.ts

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

package/types/series/heatmap/animation.d.ts

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

package/types/series/heatmap/constant.d.ts

@@ -0,0 +1,2 @@
+import type { SeriesMarkMap } from '../interface/common';
+export declare const heatmapSeriesMark: SeriesMarkMap;

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

@@ -0,0 +1,5 @@
+import { BaseSeriesSpecTransformer } from '../base';
+import type { IHeatmapSeriesSpec, IHeatmapSeriesTheme } from './interface';
+export declare class HeatmapSeriesSpecTransformer<T extends IHeatmapSeriesSpec = IHeatmapSeriesSpec, K extends IHeatmapSeriesTheme = IHeatmapSeriesTheme> extends BaseSeriesSpecTransformer<T, K> {
+    protected _transformLabelSpec(spec: T): void;
+}

package/types/series/heatmap/heatmap.d.ts

@@ -0,0 +1,41 @@
+import { CartesianSeries } from '../cartesian/cartesian';
+import type { IHeatmapSeriesSpec } 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/type';
+import type { ICellMark } from '../../mark/cell';
+import type { IMark } from '../../mark/interface';
+import { HeatmapSeriesSpecTransformer } from './heatmap-transformer';
+export declare const DefaultBandWidth = 6;
+export declare class HeatmapSeries<T extends IHeatmapSeriesSpec = IHeatmapSeriesSpec> extends CartesianSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    static readonly transformerConstructor: any;
+    readonly transformerConstructor: typeof HeatmapSeriesSpecTransformer;
+    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;
+    };
+    initInteraction(): void;
+    initAnimation(): void;
+    protected getCellSize(axisHelper: IAxisHelper): number;
+    protected initTooltip(): void;
+    getDefaultShapeType(): string;
+    getDimensionField(): string[];
+    getMeasureField(): string[];
+    getActiveMarks(): IMark[];
+}
+export declare const registerHeatmapSeries: () => void;

package/types/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';
+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/types/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/types/series/index.d.ts

@@ -0,0 +1,70 @@
+import { WaterfallSeries, registerWaterfallSeries } from './waterfall/waterfall';
+import type { IWaterfallSeriesSpec } from './waterfall/interface';
+import { BoxPlotSeries, registerBoxplotSeries } from './box-plot/box-plot';
+import type { IBoxPlotSeriesSpec } from './box-plot/interface';
+import { LineSeries, registerLineSeries } from './line/line';
+import type { ILineSeriesSpec } from './line/interface';
+import { BarSeries, registerBarSeries } from './bar/bar';
+import { Bar3dSeries, registerBar3dSeries } from './bar/bar-3d';
+import type { IBar3dSeriesSpec, IBarSeriesSpec } from './bar/interface';
+import { RangeColumnSeries, registerRangeColumnSeries } from './range-column/range-column';
+import { RangeColumn3dSeries, registerRangeColumn3dSeries } from './range-column/3d/range-column-3d';
+import type { IRangeColumn3dSeriesSpec, IRangeColumnSeriesSpec } from './range-column/interface';
+import { RangeAreaSeries, registerRangeAreaSeries } from './range-area/range-area';
+import type { IRangeAreaSeriesSpec } from './range-area/interface';
+import { MapSeries, registerMapSeries } from './map/map';
+import type { IMapSeriesSpec } from './map/interface';
+import { PieSeries, registerPieSeries } from './pie/pie';
+import { Pie3dSeries, registerPie3dSeries } from './pie/3d/pie-3d';
+import type { IPie3dSeriesSpec } from './pie/interface';
+import type { IPieSeriesSpec } from './pie/interface';
+import { ScatterSeries, registerScatterSeries } from './scatter/scatter';
+import type { IScatterSeriesSpec } from './scatter/interface';
+import { RoseSeries, registerRoseSeries } from './rose/rose';
+import type { IRoseSeriesSpec } from './rose/interface';
+import { RadarSeries, registerRadarSeries } from './radar/radar';
+import type { IRadarSeriesSpec } from './radar/interface';
+import { AreaSeries, registerAreaSeries } from './area/area';
+import type { IAreaSeriesSpec } from './area/interface';
+import { DotSeries, registerDotSeries } from './dot/dot';
+import type { IDotSeriesSpec } from './dot/interface';
+import { LinkSeries, registerLinkSeries } from './link/link';
+import type { ILinkSeriesSpec } from './link/interface';
+import { CircularProgressSeries, registerCircularProgressSeries } from './progress/circular/circular';
+import type { ICircularProgressSeriesSpec } from './progress/circular/interface';
+import { LinearProgressSeries, registerLinearProgressSeries } from './progress/linear/linear';
+import type { ILinearProgressSeriesSpec } from './progress/linear/interface';
+import { WordCloudSeries, registerWordCloudSeries } from './word-cloud/word-cloud';
+import { WordCloud3dSeries, registerWordCloud3dSeries } from './word-cloud/word-cloud-3d';
+import type { IWordCloud3dSeriesSpec, IWordCloudSeriesSpec } from './word-cloud/interface';
+import { FunnelSeries, registerFunnelSeries } from './funnel/funnel';
+import { Funnel3dSeries, registerFunnel3dSeries } from './funnel/3d/funnel-3d';
+import type { IFunnel3dSeriesSpec, IFunnelSeriesSpec } from './funnel/interface';
+import { SunburstSeries, registerSunBurstSeries } from './sunburst/sunburst';
+import type { ISunburstSeriesSpec } from './sunburst/interface';
+import { CirclePackingSeries, registerCirclePackingSeries } from './circle-packing/circle-packing';
+import type { ICirclePackingSeriesSpec } from './circle-packing/interface';
+import { SankeySeries, registerSankeySeries } from './sankey/sankey';
+import type { ISankeySeriesSpec } from './sankey/interface';
+import { TreemapSeries, registerTreemapSeries } from './treemap/treemap';
+import type { ITreemapSeriesSpec } from './treemap/interface';
+import type { IGaugePointerSeriesSpec, IGaugeSeriesSpec } from './gauge';
+import { GaugePointerSeries, GaugeSeries, registerGaugePointerSeries, registerGaugeSeries } from './gauge';
+import { HeatmapSeries, registerHeatmapSeries } from './heatmap/heatmap';
+import type { IHeatmapSeriesSpec } from './heatmap/interface';
+import { CorrelationSeries } from './correlation/correlation';
+import type { ICorrelationSeriesSpec } from './correlation/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, ICartesianSeries, IPolarSeries, IGeoSeries } 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, CorrelationSeries };
+export { registerAreaSeries, registerBar3dSeries, registerBarSeries, registerBoxplotSeries, registerCirclePackingSeries, registerCircularProgressSeries, registerDotSeries, registerFunnel3dSeries, registerFunnelSeries, registerGaugePointerSeries, registerGaugeSeries, registerHeatmapSeries, registerLineSeries, registerLinearProgressSeries, registerLinkSeries, registerMapSeries, registerPie3dSeries, registerPieSeries, registerRadarSeries, registerRangeAreaSeries, registerRangeColumn3dSeries, registerRangeColumnSeries, registerRoseSeries, registerSankeySeries, registerScatterSeries, registerSunBurstSeries, registerTreemapSeries, registerWaterfallSeries, registerWordCloud3dSeries, registerWordCloudSeries };
+export type { ISeries, ICartesianSeries, IPolarSeries, IGeoSeries, 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, ICorrelationSeriesSpec };
+export * from './interface';

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

@@ -0,0 +1,81 @@
+import type { DataView } from '@visactor/vdataset';
+import type { IGrammarItem } from '../../compile/interface';
+import type { IGroupMark } from '../../mark/group';
+import type { IModelConstructor, IModelMarkInfo, IModelOption, IModelSpecInfo } 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 { ISeriesSpec, StringOrNumber } from '../../typings';
+import type { TransformedLabelSpec } from '../../component/label';
+import type { SeriesMarkNameEnum, SeriesTypeEnum } from './type';
+import type { ICustomPath2D } from '@visactor/vrender-core';
+export interface ISeriesSeriesInfo {
+    key: string;
+    index?: number;
+    style: (attribute: string) => any;
+    shapeType: string;
+}
+export interface ISeriesOption extends IModelOption {
+    mode: RenderMode;
+    region: IRegion;
+    sourceDataList: DataView[];
+    getSeriesData: (id: StringOrNumber | undefined, index: number | undefined) => DataView | undefined;
+}
+export interface ISeriesConstructor extends IModelConstructor {
+    readonly 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[];
+    total?: number;
+}
+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;
+    seriesId?: number;
+    progressive?: IMarkProgressiveConfig;
+    support3d?: boolean;
+    customShape?: (datum: any[], attrs: any, path: ICustomPath2D) => ICustomPath2D;
+    stateSort?: (stateA: string, stateB: string) => number;
+    componentType?: string;
+}
+export interface ISeriesMarkInfo extends IModelMarkInfo {
+    name: SeriesMarkNameEnum | string;
+}
+export type SeriesMarkMap = Partial<Record<SeriesMarkNameEnum, ISeriesMarkInfo>>;
+export interface ISeriesSpecInfo<T extends ISeriesSpec = ISeriesSpec> extends IModelSpecInfo {
+    type: string | SeriesTypeEnum;
+    spec: T;
+    markLabelSpec?: Partial<Record<SeriesMarkNameEnum, TransformedLabelSpec[]>>;
+}

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

package/types/series/interface/series.d.ts

@@ -0,0 +1,179 @@
+import type { PanEventParam, ZoomEventParam } from '../../event/interface';
+import type { IModel } from '../../model/interface';
+import type { DataSet, DataView, ITransformOptions } from '@visactor/vdataset';
+import type { IMark } from '../../mark/interface';
+import type { CoordinateType, IPoint, IPolarPoint } from '../../typings/coordinate';
+import type { IRegion } from '../../region/interface';
+import type { IBaseScale } from '@visactor/vscale';
+import type { IAxisHelper } from '../../component/axis/cartesian/interface';
+import type { IPolarAxisHelper } from '../../component/axis/polar/interface';
+import type { ISeriesSeriesInfo, ISeriesSpecInfo, ISeriesStackData } from './common';
+import type { ISeriesTooltipHelper } from './tooltip-helper';
+import type { IInvalidType, Datum, DirectionType, IGroup, StringOrNumber } from '../../typings';
+import type { ISeriesMarkAttributeContext, StateValueType } from '../../compile/mark';
+import type { StatisticOperations } from '../../data/transforms/dimension-statistics';
+import type { IGroupMark } from '../../mark/group';
+import type { IGeoCoordinateHelper } from '../../component/geo/interface';
+import type { ILabelMark } from '../../mark/label';
+export interface ISeries extends IModel {
+    readonly type: string;
+    readonly name?: string;
+    tooltipHelper: ISeriesTooltipHelper;
+    getSpec: () => any;
+    readonly coordinate: CoordinateType;
+    onLayoutEnd: (ctx: any) => void;
+    getRawData: () => DataView | undefined;
+    getViewDataFilter: () => DataView | undefined;
+    getViewData: () => DataView | undefined;
+    getViewDataProductId: () => string | undefined;
+    getRawDataStatisticsByField: (field: string, isNumeric?: boolean) => {
+        values?: any[];
+        min?: number;
+        max?: number;
+    };
+    getViewDataStatistics?: () => DataView | undefined;
+    getDataSet?: () => DataSet;
+    getFieldAlias: (field: string) => string;
+    updateRawData: (d: any) => void;
+    setData?: (dv: DataView) => void;
+    rawDataUpdate: (d: DataView) => void;
+    viewDataUpdate: (d: DataView) => void;
+    viewDataStatisticsUpdate: (d: DataView) => void;
+    addViewDataFilter: (option: ITransformOptions) => void;
+    reFilterViewData: () => void;
+    reTransformViewData: () => void;
+    fillData: () => void;
+    getRegion: () => IRegion;
+    initMark: () => void;
+    getMarks: () => IMark[];
+    getMarksWithoutRoot: () => IMark[];
+    getMarkNameMap: () => Record<string, IMark>;
+    getMarksInType: (type: string | string[]) => IMark[];
+    getMarkInName: (name: string) => IMark | undefined;
+    getMarkInId: (id: number) => IMark | undefined;
+    getRootMark: () => IGroupMark;
+    getActiveMarks: () => IMark[];
+    getStackData: () => ISeriesStackData;
+    getStack: () => boolean;
+    getStackValue: () => StringOrNumber | undefined;
+    getPercent: () => boolean;
+    getStackOffsetSilhouette: () => boolean;
+    getStackValueField: () => string;
+    setValueFieldToStack: () => void;
+    setValueFieldToPercent: () => void;
+    setValueFieldToStackOffsetSilhouette: () => void;
+    getStackGroupFields: () => string[];
+    getSeriesField: () => string | undefined;
+    getSeriesKeys: () => string[];
+    getSeriesStyle: (datum: Datum) => ISeriesSeriesInfo['style'];
+    getSeriesInfoInField: (field: string) => ISeriesSeriesInfo[];
+    getSeriesInfoList: () => ISeriesSeriesInfo[];
+    getGroups: () => IGroup | undefined;
+    getDimensionField: () => string[];
+    getMeasureField: () => string[];
+    getStatisticFields: () => {
+        key: string;
+        operations: StatisticOperations;
+    }[];
+    setSeriesField: (field: string) => void;
+    handleZoom?: (e: ZoomEventParam) => void;
+    handlePan?: (e: PanEventParam) => void;
+    dataToPosition: (datum: Datum) => IPoint | null;
+    dataToPositionX: (datum: Datum) => number | null;
+    dataToPositionY: (datum: Datum) => number | null;
+    dataToPositionZ?: (datum: Datum) => number | null;
+    valueToPosition: (value1: any, value2?: any) => IPoint;
+    getColorAttribute: () => {
+        scale: IBaseScale;
+        field: string;
+    };
+    getDefaultColorDomain: () => any[];
+    getInvalidType: () => IInvalidType;
+    getDefaultShapeType: () => string;
+    initLabelMarkStyle?: (labelMark: ILabelMark) => void;
+    getGroupFields: () => string[];
+    getSpecInfo: () => ISeriesSpecInfo;
+    getMarkAttributeContext: () => ISeriesMarkAttributeContext;
+}
+export interface ICartesianSeries extends ISeries {
+    readonly coordinate: 'cartesian';
+    readonly direction: DirectionType;
+    scaleX: IBaseScale;
+    setScaleX: (s: IBaseScale) => void;
+    scaleY: IBaseScale;
+    setScaleY: (s: IBaseScale) => void;
+    scaleZ?: IBaseScale;
+    setScaleZ: (s: IBaseScale) => void;
+    fieldX: string[];
+    setFieldX: (field: string | string[], level?: number) => void;
+    fieldX2: string;
+    setFieldX2: (field: string) => void;
+    fieldY: string[];
+    setFieldY: (field: string | string[], level?: number) => void;
+    fieldY2: string;
+    setFieldY2: (field: string) => void;
+    fieldZ?: string[];
+    setFieldZ: (field: string | string[], level?: number) => void;
+    positionToData: (p: IPoint) => any | null;
+    positionToDataX: (xPos: number) => any | null;
+    positionToDataY: (yPos: number) => any | null;
+    getXAxisHelper: () => IAxisHelper;
+    setXAxisHelper: (h: IAxisHelper) => void;
+    getYAxisHelper: () => IAxisHelper;
+    setYAxisHelper: (h: IAxisHelper) => void;
+    getZAxisHelper: () => IAxisHelper | undefined;
+    setZAxisHelper: (h: IAxisHelper) => void;
+    dataToPositionX1: (datum: Datum) => number | null;
+    dataToPositionY1: (datum: Datum) => number | null;
+    valueToPosition: (value1: any, value2: any) => IPoint;
+    valueToPositionX: (value: StringOrNumber | StringOrNumber[], datum?: any) => any;
+    valueToPositionY: (value: StringOrNumber | StringOrNumber[], datum?: any) => any;
+}
+export interface IPolarSeries extends ISeries {
+    readonly coordinate: 'polar';
+    outerRadius: number;
+    innerRadius: number;
+    getRadiusField: () => string[];
+    setRadiusField: (field: string | string[], level?: number) => void;
+    getAngleField: () => string[];
+    setAngleField: (field: string | string[], level?: number) => void;
+    radiusScale: IBaseScale;
+    setRadiusScale: (s: IBaseScale) => void;
+    angleScale: IBaseScale;
+    setAngleScale: (s: IBaseScale) => void;
+    positionToData: (point: IPolarPoint) => any;
+    radiusToData: (radius: number) => any;
+    angleToData: (angle: number) => any;
+    radiusAxisHelper: IPolarAxisHelper;
+    angleAxisHelper: IPolarAxisHelper;
+    valueToPosition: (value1: any, value2: any) => IPoint;
+}
+export interface IGeoSeries extends ISeries {
+    readonly coordinate: 'geo';
+    nameField?: string;
+    valueField?: string;
+    getMapViewData: () => DataView;
+    getNameProperty: () => string;
+    dataToPosition: (datum: any) => IPoint | null;
+    dataToLatitude: (latValue: any) => number | null;
+    dataToLongitude: (lonValue: any) => number | null;
+    positionToData: (p: IPoint) => any;
+    latitudeToData: (lat: number) => any;
+    longitudeToData: (lon: number) => any;
+    getCoordinateHelper: () => IGeoCoordinateHelper;
+    setCoordinateHelper: (helper: IGeoCoordinateHelper) => void;
+    valueToPosition: (value1: any, value2: any) => IPoint;
+    getDatumCenter: (datum: any) => [number, number];
+}
+export interface IArcSeries extends IPolarSeries {
+    center: (() => IPoint) | IPoint;
+    getRadius: (state?: StateValueType) => number;
+    getInnerRadius: (state?: StateValueType) => number;
+    computeRadius: (r: number, k?: number) => number;
+    computeDatumRadius: (datum: any, state?: StateValueType) => number;
+}
+export interface IFunnelSeries extends ISeries {
+    getPoints: (datum: any) => IPoint[];
+    getCategoryField: () => string;
+    valueToPosition: (value: any) => IPoint;
+}

package/types/series/interface/theme.d.ts

@@ -0,0 +1,106 @@
+import type { IWaterfallSeriesTheme } from '../waterfall/interface';
+import type { IBoxPlotSeriesTheme } from '../box-plot/interface';
+import type { IBar3dSeriesTheme, IBarSeriesTheme } from '../bar/interface';
+import type { ILineSeriesTheme } from '../line/interface';
+import type { IScatterSeriesTheme } from '../scatter/interface';
+import type { IAreaSeriesTheme } from '../area/interface';
+import type { IRadarSeriesTheme } from '../radar/interface';
+import type { IPie3dSeriesTheme, IPieSeriesTheme } from '../pie/interface';
+import type { IRoseSeriesTheme } from '../rose/interface';
+import type { IMapSeriesTheme } from '../map/interface';
+import type { ICircularProgressSeriesTheme } from '../progress/circular/interface';
+import type { ILinkSeriesTheme } from '../link/interface';
+import type { IDotSeriesTheme } from '../dot/interface';
+import type { IWordCloud3dSeriesTheme, IWordCloudSeriesTheme } from '../word-cloud/interface';
+import type { IFunnel3dSeriesTheme, IFunnelSeriesTheme } from '../funnel/interface';
+import type { ILinearProgressSeriesTheme } from '../progress/linear/interface';
+import type { IGaugePointerSeriesTheme, IGaugeSeriesTheme } from '../gauge';
+import type { ISankeySeriesTheme } from '../sankey/interface';
+import type { ITreemapSeriesTheme } from '../treemap/interface';
+import type { ISunburstSeriesTheme } from '../sunburst/interface';
+import type { IRangeColumnSeriesTheme } from '../range-column/interface';
+import type { ICirclePackingSeriesTheme } from '../circle-packing/interface';
+import type { IHeatmapSeriesTheme } from '../heatmap/interface';
+import type { ICorrelationSeriesTheme } from '../correlation/interface';
+import { SeriesTypeEnum } from './type';
+import type { SeriesMarkMap } from './common';
+import type { IRangeAreaSeriesTheme } from '../range-area/interface';
+import type { ILiquidSeriesTheme } from '../liquid/interface';
+export interface ISeriesTheme {
+    [SeriesTypeEnum.bar]?: IBarSeriesTheme;
+    [SeriesTypeForThemeEnum.bar_vertical]?: IBarSeriesTheme;
+    [SeriesTypeForThemeEnum.bar_horizontal]?: IBarSeriesTheme;
+    [SeriesTypeEnum.bar3d]?: IBar3dSeriesTheme;
+    [SeriesTypeForThemeEnum.bar3d_vertical]?: IBar3dSeriesTheme;
+    [SeriesTypeForThemeEnum.bar3d_horizontal]?: IBar3dSeriesTheme;
+    [SeriesTypeEnum.line]?: ILineSeriesTheme;
+    [SeriesTypeForThemeEnum.line_vertical]?: ILineSeriesTheme;
+    [SeriesTypeForThemeEnum.line_horizontal]?: ILineSeriesTheme;
+    [SeriesTypeEnum.area]?: IAreaSeriesTheme;
+    [SeriesTypeForThemeEnum.area_vertical]?: IAreaSeriesTheme;
+    [SeriesTypeForThemeEnum.area_horizontal]?: IAreaSeriesTheme;
+    [SeriesTypeEnum.rangeColumn]?: IRangeColumnSeriesTheme;
+    [SeriesTypeForThemeEnum.rangeColumn_vertical]?: IRangeColumnSeriesTheme;
+    [SeriesTypeForThemeEnum.rangeColumn_horizontal]?: IRangeColumnSeriesTheme;
+    [SeriesTypeEnum.rangeArea]?: IRangeAreaSeriesTheme;
+    [SeriesTypeForThemeEnum.rangeArea_vertical]?: IRangeAreaSeriesTheme;
+    [SeriesTypeForThemeEnum.rangeArea_horizontal]?: IRangeAreaSeriesTheme;
+    [SeriesTypeEnum.linearProgress]?: ILinearProgressSeriesTheme;
+    [SeriesTypeForThemeEnum.linearProgress_vertical]?: ILinearProgressSeriesTheme;
+    [SeriesTypeForThemeEnum.linearProgress_horizontal]?: ILinearProgressSeriesTheme;
+    [SeriesTypeEnum.boxPlot]?: IBoxPlotSeriesTheme;
+    [SeriesTypeForThemeEnum.boxPlot_vertical]?: IBoxPlotSeriesTheme;
+    [SeriesTypeForThemeEnum.boxPlot_horizontal]?: IBoxPlotSeriesTheme;
+    [SeriesTypeEnum.sankey]?: ISankeySeriesTheme;
+    [SeriesTypeForThemeEnum.sankey_vertical]?: ISankeySeriesTheme;
+    [SeriesTypeForThemeEnum.sankey_horizontal]?: ISankeySeriesTheme;
+    [SeriesTypeEnum.waterfall]?: IWaterfallSeriesTheme;
+    [SeriesTypeForThemeEnum.waterfall_vertical]?: IWaterfallSeriesTheme;
+    [SeriesTypeForThemeEnum.waterfall_horizontal]?: IWaterfallSeriesTheme;
+    [SeriesTypeEnum.scatter]?: IScatterSeriesTheme;
+    [SeriesTypeEnum.radar]?: IRadarSeriesTheme;
+    [SeriesTypeEnum.pie]?: IPieSeriesTheme;
+    [SeriesTypeEnum.pie3d]?: IPie3dSeriesTheme;
+    [SeriesTypeEnum.rose]?: IRoseSeriesTheme;
+    [SeriesTypeEnum.map]?: IMapSeriesTheme;
+    [SeriesTypeEnum.circularProgress]?: ICircularProgressSeriesTheme;
+    [SeriesTypeEnum.link]?: ILinkSeriesTheme;
+    [SeriesTypeEnum.dot]?: IDotSeriesTheme;
+    [SeriesTypeEnum.wordCloud]?: IWordCloudSeriesTheme;
+    [SeriesTypeEnum.wordCloud3d]?: IWordCloud3dSeriesTheme;
+    [SeriesTypeEnum.funnel]?: IFunnelSeriesTheme;
+    [SeriesTypeEnum.funnel3d]?: IFunnel3dSeriesTheme;
+    [SeriesTypeEnum.treemap]?: ITreemapSeriesTheme;
+    [SeriesTypeEnum.gauge]?: IGaugeSeriesTheme;
+    [SeriesTypeEnum.gaugePointer]?: IGaugePointerSeriesTheme;
+    [SeriesTypeEnum.sunburst]?: ISunburstSeriesTheme;
+    [SeriesTypeEnum.circlePacking]?: ICirclePackingSeriesTheme;
+    [SeriesTypeEnum.heatmap]?: IHeatmapSeriesTheme;
+    [SeriesTypeEnum.correlation]?: ICorrelationSeriesTheme;
+    [SeriesTypeEnum.liquid]?: ILiquidSeriesTheme;
+}
+export declare enum SeriesTypeForThemeEnum {
+    area_horizontal = "area_horizontal",
+    area_vertical = "area_vertical",
+    line_horizontal = "line_horizontal",
+    line_vertical = "line_vertical",
+    bar_horizontal = "bar_horizontal",
+    bar_vertical = "bar_vertical",
+    bar3d_horizontal = "bar3d_horizontal",
+    bar3d_vertical = "bar3d_vertical",
+    rangeColumn_horizontal = "rangeColumn_horizontal",
+    rangeColumn_vertical = "rangeColumn_vertical",
+    rangeColumn3d_horizontal = "rangeColumn3d_horizontal",
+    rangeColumn3d_vertical = "rangeColumn3d_vertical",
+    rangeArea_horizontal = "rangeArea_horizontal",
+    rangeArea_vertical = "rangeArea_vertical",
+    linearProgress_horizontal = "linearProgress_horizontal",
+    linearProgress_vertical = "linearProgress_vertical",
+    boxPlot_horizontal = "boxPlot_horizontal",
+    boxPlot_vertical = "boxPlot_vertical",
+    sankey_horizontal = "sankey_horizontal",
+    sankey_vertical = "sankey_vertical",
+    waterfall_horizontal = "waterfall_horizontal",
+    waterfall_vertical = "waterfall_vertical"
+}
+export declare const seriesMarkInfoMap: Record<SeriesTypeEnum, SeriesMarkMap>;

package/types/series/interface/tooltip-helper.d.ts

@@ -0,0 +1,13 @@
+import type { ITooltipPattern, ShapeType, TooltipActiveType, TooltipContentCallback } from '../../typings';
+import type { ISeries } from './series';
+import type { ITooltipHelper } from '../../model/tooltip-helper';
+import type { IDimensionInfo } from '../../event/events/dimension/interface';
+export interface ISeriesTooltipHelper extends ITooltipHelper {
+    series: ISeries;
+    getDefaultTooltipPattern: (activeType: TooltipActiveType, dimensionInfo?: IDimensionInfo[]) => ITooltipPattern | null;
+    contentKeyCallback: TooltipContentCallback<string>;
+    contentValueCallback: TooltipContentCallback<string>;
+    contentShapeTypeCallback: TooltipContentCallback<ShapeType>;
+    contentShapeColorCallback: TooltipContentCallback<string>;
+    titleValueCallback: TooltipContentCallback<string>;
+}