@visactor/vchart-types 0.10.0-alpha.2

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

@@ -0,0 +1,56 @@
+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 { AdaptiveSpec } from '../../typings';
+import type { ILabelMark } from '../../mark/label';
+import type { IMark } from '../../mark/interface';
+import { CorrelationSeriesSpecTransformer } from './correlation-transformer';
+export declare class CorrelationSeries<T extends ICorrelationSeriesSpec = ICorrelationSeriesSpec> extends PolarSeries<AdaptiveSpec<T, 'outerRadius' | 'innerRadius'>> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    static readonly transformerConstructor: any;
+    readonly transformerConstructor: typeof CorrelationSeriesSpecTransformer;
+    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,72 @@
+import { CartesianSeries } from '../cartesian/cartesian';
+import type { 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 } 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;
+    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/3d/funnel-3d-transformer.d.ts

@@ -0,0 +1,6 @@
+import type { AdaptiveSpec } from '../../../typings';
+import type { IFunnel3dSeriesSpec, IFunnel3dSeriesTheme } from '../interface';
+import { FunnelSeriesSpecTransformer } from '../funnel-transformer';
+export declare class Funnel3dSeriesSpecTransformer<T extends IFunnel3dSeriesSpec = IFunnel3dSeriesSpec, K extends IFunnel3dSeriesTheme = IFunnel3dSeriesTheme> extends FunnelSeriesSpecTransformer<AdaptiveSpec<T, 'type'>, K> {
+    protected _transformLabelSpec(spec: AdaptiveSpec<T, 'type'>): void;
+}

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

@@ -0,0 +1,22 @@
+import { MarkTypeEnum } from '../../../mark/interface/type';
+import type { SeriesMarkMap } from '../../interface';
+import { SeriesTypeEnum, SeriesMarkNameEnum } from '../../interface/type';
+import { FunnelSeries } from '../funnel';
+import type { IFunnel3dSeriesSpec } 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;
+    static readonly transformerConstructor: any;
+    readonly transformerConstructor: any;
+    initMark(): void;
+    initMarkStyle(): void;
+    initLabelMarkStyle(labelMark?: ILabelMark): void;
+}
+export declare const registerFunnel3dSeries: () => void;

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

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

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

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

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

@@ -0,0 +1,97 @@
+import type { IFunnelSeries, SeriesMarkMap } from '../interface';
+import { SeriesMarkNameEnum } from '../interface/type';
+import type { IOrientType, 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 } from './interface';
+import type { IRuleMark } from '../../mark/rule';
+import { SeriesData } from '../base/series-data';
+import type { ILabelMark } from '../../mark/label';
+import { FunnelSeriesSpecTransformer } from './funnel-transformer';
+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;
+    static readonly transformerConstructor: any;
+    readonly transformerConstructor: typeof FunnelSeriesSpecTransformer;
+    protected _categoryField: string;
+    getCategoryField(): string;
+    setCategoryField(f: string): string;
+    protected _valueField: string;
+    getValueField(): string;
+    setValueField(f: string): string;
+    protected _viewDataTransform: SeriesData;
+    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/animation.d.ts

@@ -0,0 +1,7 @@
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+export type ProgressLikeAppearPreset = 'grow' | 'fadeIn';
+export interface IProgressLikeAnimationParams {
+    startAngle?: number;
+}
+export declare function gaugePointerPresetAnimation(params: IProgressLikeAnimationParams, preset: ProgressLikeAppearPreset): IAnimationTypeConfig;
+export declare const registerGaugePointerAnimation: () => void;

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;

package/types/series/gauge/gauge-pointer.d.ts

@@ -0,0 +1,38 @@
+import type { IMark } from '../../mark/interface';
+import { MarkTypeEnum } from '../../mark/interface/type';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { IGaugePointerSeriesSpec, PinMarkSpec, PointerMarkSpec } from './interface';
+import type { Datum } from '../../typings';
+import { ProgressLikeSeries } from '../polar/progress-like';
+export declare class GaugePointerSeries<T extends IGaugePointerSeriesSpec = IGaugePointerSeriesSpec> extends ProgressLikeSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    private _pinMark;
+    private _pointerMark;
+    private _pinBackgroundMark;
+    protected _stack: boolean;
+    protected _pointerType: MarkTypeEnum;
+    setAttrFromSpec(): void;
+    initMark(): void;
+    initMarkStyle(): void;
+    initGroups(): void;
+    private initPointerMarkStyle;
+    protected initTooltip(): void;
+    protected _getPointerAnchor(datum: Datum, markSpec: PinMarkSpec | PointerMarkSpec): import("../../typings").IPoint;
+    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;
+    initInteraction(): void;
+    initAnimation(): void;
+    getDefaultShapeType(): string;
+    getActiveMarks(): IMark[];
+}
+export declare const registerGaugePointerSeries: () => void;

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

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

package/types/series/gauge/gauge.d.ts

@@ -0,0 +1,33 @@
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { IGaugeSeriesSpec } from './interface';
+import { ProgressLikeSeries } from '../polar/progress-like/progress-like';
+import type { Datum } from '@visactor/vgrammar-core';
+import type { IMark } from '../../mark/interface';
+import { GaugeSeriesSpecTransformer } from './gauge-transformer';
+export declare class GaugeSeries<T extends IGaugeSeriesSpec = IGaugeSeriesSpec> extends ProgressLikeSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    static readonly transformerConstructor: any;
+    readonly transformerConstructor: typeof GaugeSeriesSpecTransformer;
+    private _segmentMark;
+    private _trackMark;
+    protected _stack: boolean;
+    protected _padAngle: number;
+    setAttrFromSpec(): void;
+    initData(): void;
+    initMark(): void;
+    initMarkStyle(): void;
+    private initSegmentMarkStyle;
+    protected initTooltip(): void;
+    private initTrackMarkStyle;
+    protected _getAngleValueStartWithoutMask(datum: Datum): number;
+    protected _getAngleValueEndWithoutMask(datum: Datum): number;
+    protected _getAngleValueStartWithoutPadAngle(datum: Datum): number;
+    protected _getAngleValueEndWithoutPadAngle(datum: Datum): number;
+    initAnimation(): void;
+    getDefaultShapeType(): string;
+    getActiveMarks(): IMark[];
+}
+export declare const registerGaugeSeries: () => void;

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

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

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

@@ -0,0 +1,50 @@
+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/type';
+import type { ILabelSpec } from '../../component/label/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];
+    isOnCenter?: boolean;
+};
+export type PinMarkSpec = {
+    width?: number;
+    height?: number;
+    isOnCenter?: boolean;
+};
+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>;
+    [SeriesMarkNameEnum.label]?: IGaugeLabelSpec;
+}
+export interface IGaugeSeriesTheme extends IProgressLikeSeriesTheme {
+    padAngle?: number;
+    [SeriesMarkNameEnum.segment]?: Partial<IMarkTheme<IProgressArcMarkSpec>>;
+    [SeriesMarkNameEnum.track]?: Partial<IMarkTheme<IArcMarkSpec>>;
+    [SeriesMarkNameEnum.label]?: IGaugeLabelSpec;
+}
+export type IGaugeLabelSpec = ILabelSpec;