@visactor/vchart-types 0.16.17-alpha.2

package/types/series/cartesian/cartesian.d.ts

@@ -0,0 +1,95 @@
+import type { DataView } from '@visactor/vdataset';
+import type { ICartesianSeries } from '../interface';
+import { BaseSeries } from '../base/base-series';
+import type { IPoint } from '../../typings/coordinate';
+import type { IBaseScale } from '@visactor/vscale';
+import type { IAxisHelper } from '../../component/axis/cartesian/interface';
+import type { DirectionType } from '../../typings/space';
+import type { Datum, StringOrNumber } from '../../typings';
+import type { StatisticOperations } from '../../data/transforms/dimension-statistics';
+import type { ICartesianSeriesSpec } from './interface';
+import type { IAxisLocationCfg } from '../../component/axis';
+export declare abstract class CartesianSeries<T extends ICartesianSeriesSpec = ICartesianSeriesSpec> extends BaseSeries<T> implements ICartesianSeries {
+    readonly coordinate: 'cartesian';
+    protected _bandPosition: number;
+    protected _scaleConfig: IAxisLocationCfg;
+    protected _buildScaleConfig(): void;
+    protected _fieldX: string[];
+    get fieldX(): string[];
+    setFieldX(f: string | string[]): void;
+    protected _fieldY: string[];
+    get fieldY(): string[];
+    setFieldY(f: string | string[]): void;
+    protected _fieldZ?: string[];
+    get fieldZ(): string[] | undefined;
+    setFieldZ(f?: string | string[]): void;
+    protected _fieldX2: string;
+    get fieldX2(): string;
+    setFieldX2(f: string): void;
+    protected _fieldY2: string;
+    get fieldY2(): string;
+    setFieldY2(f: string): void;
+    protected _specXField: string[];
+    protected _specYField: string[];
+    protected _direction: DirectionType;
+    get direction(): "vertical" | "horizontal";
+    protected _scaleX: IBaseScale;
+    get scaleX(): IBaseScale;
+    setScaleX(s: IBaseScale): void;
+    protected _scaleY: IBaseScale;
+    get scaleY(): IBaseScale;
+    setScaleY(s: IBaseScale): void;
+    protected _scaleZ?: IBaseScale;
+    get scaleZ(): IBaseScale;
+    setScaleZ(s: IBaseScale): void;
+    _xAxisHelper: IAxisHelper;
+    getXAxisHelper(): IAxisHelper;
+    setXAxisHelper(h: IAxisHelper): void;
+    _yAxisHelper: IAxisHelper;
+    getYAxisHelper(): IAxisHelper;
+    setYAxisHelper(h: IAxisHelper): void;
+    _zAxisHelper?: IAxisHelper;
+    getZAxisHelper(): IAxisHelper;
+    setZAxisHelper(h: IAxisHelper): void;
+    protected _sortDataByAxis: boolean;
+    get sortDataByAxis(): boolean;
+    getStatisticFields(): {
+        key: string;
+        operations: StatisticOperations;
+    }[];
+    getGroupFields(): string[];
+    getStackGroupFields(): string[];
+    getStackValueField(): string;
+    setValueFieldToStack(): void;
+    setValueFieldToPercent(): void;
+    setValueFieldToStackOffsetSilhouette(): void;
+    onXAxisHelperUpdate(): void;
+    onYAxisHelperUpdate(): void;
+    onZAxisHelperUpdate(): void;
+    setAttrFromSpec(): void;
+    dataToPosition(datum: Datum): IPoint | null;
+    protected _buildMarkAttributeContext(): void;
+    valueToPosition(xValue: StringOrNumber | StringOrNumber[], yValue: StringOrNumber | StringOrNumber[]): {
+        x: number;
+        y: number;
+    };
+    protected _axisPosition(helper: IAxisHelper, value: StringOrNumber | StringOrNumber[], datum?: any): number;
+    valueToPositionX(value: StringOrNumber | StringOrNumber[], datum?: any): number;
+    valueToPositionY(value: StringOrNumber | StringOrNumber[], datum?: any): number;
+    dataToPositionX(datum: Datum): number;
+    dataToPositionY(datum: Datum): number;
+    dataToPositionZ(datum: Datum): number;
+    dataToPositionX1(datum: Datum): number;
+    dataToPositionY1(datum: Datum): number;
+    positionToData(p: IPoint): IPoint | null;
+    positionToDataX(xPos: number): any | null;
+    positionToDataY(yPos: number): any | null;
+    getRegionRectLeft(): number;
+    getRegionRectRight(): number;
+    afterInitMark(): void;
+    getDimensionField(): string[];
+    getMeasureField(): string[];
+    viewDataUpdate(d: DataView): void;
+    _sortDataInAxisDomain(): void;
+    protected _getInvalidDefined: (datum: Datum) => boolean;
+}

package/types/series/cartesian/index.d.ts

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

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

@@ -0,0 +1,15 @@
+import type { ISeriesSpec } from '../../typings/spec/common';
+import type { DirectionType } from '../../typings';
+import type { ILabelSpec } from '../../component/label';
+export interface ICartesianSeriesSpec extends ISeriesSpec {
+    direction?: DirectionType;
+    xField?: string | string[];
+    x2Field?: string;
+    yField?: string | string[];
+    y2Field?: string;
+    zField?: string | string[];
+    sortDataByAxis?: boolean;
+}
+export interface ICartesianSeriesTheme {
+    label?: Partial<ILabelSpec>;
+}

package/types/series/circle-packing/animation.d.ts

@@ -0,0 +1,5 @@
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+export type CirclePackingMark = 'leaf' | 'nonLeaf' | 'label' | 'nonLeafLabel';
+export type CirclePackingAppearPreset = 'growIn' | 'fadeIn';
+export declare const circlePackingPresetAnimation: (preset: CirclePackingAppearPreset) => IAnimationTypeConfig;
+export declare const registerCirclePackingAnimation: () => void;

package/types/series/circle-packing/circle-packing.d.ts

@@ -0,0 +1,45 @@
+import type { ICirclePackingSeriesSpec } from './interface';
+import type { Datum } from '../../typings';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import { CartesianSeries } from '../cartesian/cartesian';
+import type { IMark } from '../../mark/interface';
+export declare class CirclePackingSeries<T extends ICirclePackingSeriesSpec = ICirclePackingSeriesSpec> extends CartesianSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _categoryField: string;
+    protected _valueField: string;
+    private _layoutPadding;
+    private _circlePacking;
+    private _label;
+    private _circlePackingMark;
+    private _labelMark;
+    private _drill?;
+    setCategoryField(f: string): string;
+    getCategoryField(): string;
+    setValueField(f: string): string;
+    getValueField(): string;
+    getDimensionField(): string[];
+    getMeasureField(): string[];
+    setAttrFromSpec(): void;
+    protected initData(): void;
+    protected _addDataIndexAndKey(): void;
+    initMark(): void;
+    initMarkStyle(): void;
+    private _initCirclePackingMark;
+    private _initCirclePackingMarkStyle;
+    private _initLabelMark;
+    private _initLabelMarkStyle;
+    getStatisticFields(): {
+        key: string;
+        operations: import("../../data/transforms/dimension-statistics").StatisticOperations;
+    }[];
+    protected initTooltip(): void;
+    initAnimation(): void;
+    initEvent(): void;
+    onLayoutEnd(ctx: any): void;
+    protected _noAnimationDataKey(datum: Datum, index: number): unknown | undefined;
+    getActiveMarks(): IMark[];
+}
+export declare const registerCirclePackingSeries: () => void;

package/types/series/circle-packing/constant.d.ts

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

package/types/series/circle-packing/interface.d.ts

@@ -0,0 +1,21 @@
+import type { IMarkSpec, IMarkTheme, ISeriesSpec } from '../..';
+import type { IAnimationSpec } from '../../animation/spec';
+import type { IArcMarkSpec, ITextMarkSpec } from '../../typings';
+import type { SeriesMarkNameEnum } from '../interface/type';
+import type { IPolarSeriesTheme } from '../polar/interface';
+import type { CirclePackingAppearPreset, CirclePackingMark } from './animation';
+export interface ICirclePackingSeriesSpec extends ISeriesSpec, IAnimationSpec<CirclePackingMark, CirclePackingAppearPreset> {
+    type: 'circlePacking';
+    categoryField: string;
+    valueField: string;
+    layoutPadding?: number | number[];
+    [SeriesMarkNameEnum.label]?: IMarkSpec<ITextMarkSpec>;
+    [SeriesMarkNameEnum.circlePacking]?: IMarkSpec<IArcMarkSpec>;
+    drill?: boolean;
+    drillField?: string;
+}
+export interface ICirclePackingSeriesTheme extends Omit<IPolarSeriesTheme, 'label'> {
+    layoutPadding?: number | number[];
+    [SeriesMarkNameEnum.label]?: IMarkTheme<ITextMarkSpec>;
+    [SeriesMarkNameEnum.circlePacking]?: IMarkTheme<IArcMarkSpec>;
+}

package/types/series/circle-packing/tooltip-helper.d.ts

@@ -0,0 +1,5 @@
+import type { Datum } from '../../typings';
+import { BaseSeriesTooltipHelper } from '../base/tooltip-helper';
+export declare class CirclePackingTooltipHelper extends BaseSeriesTooltipHelper {
+    contentKeyCallback: (datum: Datum) => any;
+}

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

@@ -0,0 +1,8 @@
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+export type CorrelationMarks = 'point' | 'label';
+export type CorrelationAppearPreset = 'scaleIn' | 'fadeIn';
+export interface ICorrelationAnimationParams {
+    [key: string]: object;
+}
+export declare const correlationPresetAnimation: (_params: ICorrelationAnimationParams, preset: CorrelationAppearPreset) => IAnimationTypeConfig;
+export declare const registerCorrelationAnimation: () => void;

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

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

package/types/series/correlation/correlation.d.ts

@@ -0,0 +1,55 @@
+import { PolarSeries } from '../polar/polar';
+import type { ICorrelationSeriesSpec } from './interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesData } from '../base/series-data';
+import type { Maybe } from '../../typings';
+import type { ICorrelationSeriesTheme } from './interface';
+import type { ILabelMark } from '../../mark/label';
+import type { IMark } from '../../mark/interface';
+export declare class CorrelationSeries extends PolarSeries<any> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _theme: Maybe<ICorrelationSeriesTheme>;
+    protected _centerSeriesData: SeriesData;
+    private _nodePointMark;
+    private _ripplePointMark;
+    private _centerPointMark;
+    private _viewBox;
+    protected _categoryField: string;
+    getCategoryField(): string;
+    setCategoryField(f: string): string;
+    protected _valueField: string;
+    getValueField(): string;
+    setValueField(f: string): string;
+    protected _seriesField?: string;
+    getSeriesField(): string;
+    setSeriesField(field: string): void;
+    protected _sizeField?: ICorrelationSeriesSpec['sizeField'];
+    getSizeField(): string;
+    setSizeField(field: string): void;
+    protected _sizeRange?: ICorrelationSeriesSpec['sizeRange'];
+    getSizeRange(): number[];
+    setSizeRange(range: number[]): void;
+    protected _viewDataTransform: SeriesData;
+    setAttrFromSpec(): void;
+    protected initData(): void;
+    protected _statisticViewData(): void;
+    initMark(): void;
+    initMarkStyle(): void;
+    protected _initNodePointMarkStyle(): void;
+    protected _initRipplePointMarkStyle(): void;
+    protected _initCenterPointMarkStyle(): void;
+    protected initTooltip(): void;
+    initLabelMarkStyle(labelMark?: ILabelMark): void;
+    initAnimation(): void;
+    getGroupFields(): string[];
+    getStackGroupFields(): string[];
+    getStackValueField(): string;
+    getActiveMarks(): IMark[];
+    getDimensionField(): string[];
+    getMeasureField(): string[];
+    onLayoutEnd(ctx: any): void;
+}
+export declare const registerCorrelationSeries: () => void;

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

@@ -0,0 +1,37 @@
+import type { IMarkTheme, IMarkSpec } from '../../typings';
+import type { ILabelSpec } from '../../component/label';
+import type { ISymbolMarkSpec, IRippleMarkSpec } from '../../typings';
+import type { SeriesMarkNameEnum } from '../interface/type';
+import type { IPolarSeriesSpec } from '../polar/interface';
+import type { IAnimationSpec } from '../../animation/spec';
+import type { CorrelationAppearPreset, CorrelationMarks } from './animation';
+export interface ICorrelationSeriesSpec extends Omit<IPolarSeriesSpec, 'innerRadius' | 'outerRadius'>, IAnimationSpec<CorrelationMarks, CorrelationAppearPreset> {
+    type: 'correlation';
+    categoryField: string;
+    valueField: string;
+    seriesField?: string;
+    sizeField?: string;
+    sizeRange?: number[];
+    centerX?: number;
+    centerY?: number;
+    innerRadius?: string | number;
+    outerRadius?: string | number;
+    startAngle?: number;
+    endAngle?: number;
+    [SeriesMarkNameEnum.centerPoint]?: IMarkSpec<ISymbolMarkSpec>;
+    [SeriesMarkNameEnum.ripplePoint]?: IMarkSpec<IRippleMarkSpec>;
+    [SeriesMarkNameEnum.centerLabel]?: ILabelSpec & {
+        position?: 'top' | 'bottom' | 'left' | 'right' | 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'center';
+    };
+    [SeriesMarkNameEnum.nodePoint]?: IMarkSpec<ISymbolMarkSpec>;
+    [SeriesMarkNameEnum.label]?: ILabelSpec & {
+        position?: 'top' | 'bottom' | 'left' | 'right' | 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'center';
+    };
+}
+export interface ICorrelationSeriesTheme {
+    [SeriesMarkNameEnum.nodePoint]?: IMarkTheme<ISymbolMarkSpec>;
+    [SeriesMarkNameEnum.ripplePoint]?: IMarkTheme<IRippleMarkSpec>;
+    [SeriesMarkNameEnum.centerPoint]?: IMarkTheme<ISymbolMarkSpec>;
+    [SeriesMarkNameEnum.centerLabel]?: ILabelSpec;
+    [SeriesMarkNameEnum.label]?: ILabelSpec;
+}

package/types/series/dot/config.d.ts

@@ -0,0 +1,4 @@
+export declare const DEFAULT_GRID_BACKGROUND: {
+    fill: string;
+    fillOpacity: number;
+};

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

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

package/types/series/dot/dot.d.ts

@@ -0,0 +1,73 @@
+import { CartesianSeries } from '../cartesian/cartesian';
+import type { Maybe, Datum } from '../../typings';
+import type { IMark } from '../../mark/interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { IModelEvaluateOption } from '../../model/interface';
+import type { IFillMarkSpec, VisualType } from '../../typings/visual';
+import type { IDotSeriesSpec, IDotSeriesTheme } from './interface';
+import type { SeriesMarkMap } from '../interface';
+export declare class DotSeries<T extends IDotSeriesSpec = IDotSeriesSpec> extends CartesianSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _theme: Maybe<IDotSeriesTheme>;
+    private _xDimensionStatisticsDomain;
+    protected _seriesGroupField?: string;
+    getSeriesGroupField(): string;
+    setSeriesGroupField(field: string): void;
+    protected _titleField?: string;
+    getTitleField(): string;
+    setTitleField(field: string): void;
+    protected _subTitleField?: string;
+    getSubTitleField(): string;
+    setSubTitleField(field: string): void;
+    protected _dotTypeField?: string;
+    getDotTypeField(): string;
+    setDotTypeField(field: string): void;
+    protected _highLightSeriesGroup?: string;
+    getHighLightSeriesGroup(): string;
+    setHighLightSeriesGroup(field: string): void;
+    protected _gridBackground?: IFillMarkSpec;
+    setGridBackground(gridBackground: IFillMarkSpec): void;
+    initData(): void;
+    setSeriesField(field: string): void;
+    getStatisticFields(): {
+        key: string;
+        operations: Array<'max' | 'min' | 'values'>;
+        customize: any[];
+    }[];
+    setAttrFromSpec(): void;
+    private _clipMark;
+    private _containerMark;
+    private _gridBackgroundMark;
+    private _gridMark;
+    private _dotMark;
+    private _titleMark;
+    private _subTitleMark;
+    private _symbolMark;
+    initMark(): void;
+    initMarkStyle(): void;
+    dataToGridBackgroundPositionY(datum: Datum): number;
+    dataToGridBackgroundPositionY1(datum: Datum): number;
+    dataToOpacity(datum: Datum): number;
+    dataToGridBackgroundOpacity(datum: Datum): VisualType<number>;
+    onLayoutEnd(ctx: any): void;
+    getDefaultColorDomain(): any;
+    getColorAttribute(): {
+        scale: any;
+        field: string;
+    };
+    protected getDotColorScale(): any;
+    getDotColorAttribute(): {
+        scale: any;
+        field: string;
+    };
+    protected initTooltip(): void;
+    onEvaluateEnd(ctx: IModelEvaluateOption): void;
+    protected onMarkTreePositionUpdate(marks: IMark[]): void;
+    getDotData(): import("../../compile/mark/mark-data").MarkData;
+    protected _getDataIdKey(): any;
+    getStackValueField(): string;
+    getActiveMarks(): IMark[];
+}
+export declare const registerDotSeries: () => void;

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

@@ -0,0 +1,40 @@
+import type { ICartesianSeriesSpec, ICartesianSeriesTheme } from '../cartesian/interface';
+import type { IMarkSpec, IMarkTheme } from '../../typings/spec/common';
+import type { ISymbolMarkSpec, IRuleMarkSpec, ITextMarkSpec, ConvertToMarkStyleSpec } from '../../typings/visual';
+import type { SeriesMarkNameEnum } from '../interface/type';
+interface ISequenceLabel {
+    visible?: boolean;
+    formatMethod?: (text: string | string[], datum?: any) => string | string[];
+    style?: Omit<ConvertToMarkStyleSpec<ITextMarkSpec>, 'visible'>;
+}
+interface ISequenceGrid {
+    visible?: boolean;
+    background?: {
+        fill?: string;
+        fillOpacity?: number;
+    };
+    style?: Omit<ConvertToMarkStyleSpec<IRuleMarkSpec>, 'visible'>;
+}
+export interface IDotSeriesSpec extends ICartesianSeriesSpec {
+    type: 'dot';
+    seriesGroupField?: string;
+    dotTypeField?: string;
+    titleField?: string;
+    subTitleField?: string;
+    highLightSeriesGroup?: string;
+    name: string;
+    [SeriesMarkNameEnum.dot]?: IMarkSpec<ISymbolMarkSpec>;
+    [SeriesMarkNameEnum.title]?: ISequenceLabel;
+    [SeriesMarkNameEnum.symbol]?: IMarkSpec<ISymbolMarkSpec>;
+    [SeriesMarkNameEnum.subTitle]?: ISequenceLabel;
+    [SeriesMarkNameEnum.grid]?: ISequenceGrid;
+    leftAppendPadding?: number;
+    clipHeight?: number;
+}
+export interface IDotSeriesTheme extends ICartesianSeriesTheme {
+    [SeriesMarkNameEnum.dot]?: Partial<IMarkTheme<ISymbolMarkSpec>>;
+    [SeriesMarkNameEnum.symbol]?: Partial<IMarkTheme<ISymbolMarkSpec>>;
+    [SeriesMarkNameEnum.title]?: ISequenceLabel;
+    [SeriesMarkNameEnum.subTitle]?: ISequenceLabel;
+}
+export {};

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

@@ -0,0 +1,7 @@
+import type { ISeriesTooltipHelper } from '../interface';
+import { BaseSeriesTooltipHelper } from '../base/tooltip-helper';
+import type { ITooltipPattern, TooltipActiveType } from '../../typings';
+export declare class DotSeriesTooltipHelper extends BaseSeriesTooltipHelper implements ISeriesTooltipHelper {
+    updateTooltipSpec(): void;
+    getDefaultTooltipPattern(activeType: TooltipActiveType): ITooltipPattern | null;
+}

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

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

package/types/series/funnel/funnel-3d.d.ts

@@ -0,0 +1,22 @@
+import type { Maybe } from '@visactor/vutils';
+import { MarkTypeEnum } from '../../mark/interface/type';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum, SeriesMarkNameEnum } from '../interface/type';
+import { FunnelSeries } from './funnel';
+import type { IFunnel3dSeriesSpec, IFunnel3dSeriesTheme } from './interface';
+import type { AdaptiveSpec } from '../../typings';
+import type { ILabelMark } from '../../mark/label';
+export declare class Funnel3dSeries<T extends IFunnel3dSeriesSpec = IFunnel3dSeriesSpec> extends FunnelSeries<AdaptiveSpec<T, 'type'>> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    protected _funnelMarkName: SeriesMarkNameEnum;
+    protected _funnelMarkType: MarkTypeEnum;
+    protected _transformMarkName: SeriesMarkNameEnum;
+    protected _transformMarkType: MarkTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _theme: Maybe<IFunnel3dSeriesTheme>;
+    initMark(): void;
+    initMarkStyle(): void;
+    initLabelMarkStyle(labelMark?: ILabelMark): void;
+}
+export declare const registerFunnel3dSeries: () => void;

package/types/series/funnel/funnel.d.ts

@@ -0,0 +1,95 @@
+import type { IFunnelSeries, SeriesMarkMap } from '../interface';
+import { SeriesMarkNameEnum } from '../interface/type';
+import type { IOrientType, Maybe, Datum, StringOrNumber } from '../../typings';
+import { SeriesTypeEnum } from '../interface/type';
+import type { IPolygonMark } from '../../mark/polygon/polygon';
+import { BaseSeries } from '../base/base-series';
+import type { IMark } from '../../mark/interface';
+import { MarkTypeEnum } from '../../mark/interface/type';
+import type { ITextMark } from '../../mark/text';
+import type { IFunnelSeriesSpec, IFunnelSeriesTheme } from './interface';
+import type { IRuleMark } from '../../mark/rule';
+import { SeriesData } from '../base/series-data';
+import type { ILabelMark } from '../../mark/label';
+export declare class FunnelSeries<T extends IFunnelSeriesSpec = IFunnelSeriesSpec> extends BaseSeries<T> 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: ILabelMark | null;
+    protected _transformLabelMark: ILabelMark | 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;
+    initLabelMarkStyle(labelMark?: ILabelMark): void;
+    initAnimation(): void;
+    initGroups(): void;
+    getStackGroupFields(): string[];
+    getStackValueField(): string;
+    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;
+    getDefaultShapeType(): string;
+    getActiveMarks(): IMark[];
+}
+export declare const registerFunnelSeries: () => void;

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

@@ -0,0 +1,60 @@
+import type { Datum, IMarkSpec, IMarkTheme, ISeriesSpec, IOrientType, IPathMarkSpec, IPolygonMarkSpec, IRuleMarkSpec, ITextMarkSpec, IPyramid3dMarkSpec, IPercent } from '../../typings';
+import type { IAnimationSpec } from '../../animation/spec';
+import type { SeriesMarkNameEnum } from '../interface/type';
+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/types/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-core';
+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/types/series/gauge/constant.d.ts

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