@visactor/vchart-types 0.16.17-alpha.2

package/types/scale/global-scale.d.ts

@@ -0,0 +1,37 @@
+import type { IGlobalScale } from './interface';
+import type { IBaseScale } from '@visactor/vscale';
+import type { IChart } from '../chart/interface';
+import type { IChartSpec } from '../typings/spec';
+import type { IVisualScale, IVisualSpecScale } from '../typings';
+import type { StatisticOperations } from '../data/transforms/dimension-statistics';
+export declare class GlobalScale implements IGlobalScale {
+    private _scaleSpecMap;
+    private _scaleMap;
+    private _modelScaleSpecMap;
+    private _markAttributeScaleMap;
+    private _spec;
+    private readonly _chart;
+    constructor(spec: IChartSpec['scales'], chart: IChart);
+    private _createFromSpec;
+    private _setAttrFromSpec;
+    updateSpec(spec: IChartSpec['scales']): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    registerModelScale(spec: IVisualSpecScale<unknown, unknown>): void;
+    removeModelScale(filter: (spec: IVisualSpecScale<unknown, unknown>) => boolean): void;
+    getScale(user_id: string): IBaseScale | null;
+    getScaleSpec(user_id: string): IVisualSpecScale<unknown, unknown> | null;
+    getStatisticalFields: (dataId: string) => {
+        key: string;
+        operations: StatisticOperations;
+    }[];
+    private _getSeriesByRawDataId;
+    private _getSeriesBySeriesId;
+    updateScaleDomain(defaultDomain: unknown[]): void;
+    private _updateMarkScale;
+    registerMarkAttributeScale(spec: IVisualScale, seriesId: number): IBaseScale;
+}

package/types/scale/interface.d.ts

@@ -0,0 +1,18 @@
+import type { IBaseScale } from '@visactor/vscale';
+import type { StatisticOperations } from '../data/transforms/dimension-statistics';
+import type { IChartSpec, IVisualScale, IVisualSpecScale } from '../typings';
+import type { IUpdateSpecResult } from '../model/interface';
+export interface IGlobalScale {
+    color?: any;
+    getScale: (user_id: string) => IBaseScale | null;
+    getScaleSpec: (user_id: string) => IVisualSpecScale<unknown, unknown> | null;
+    getStatisticalFields: (dataId: string) => {
+        key: string;
+        operations: StatisticOperations;
+    }[];
+    updateScaleDomain: (string: unknown[]) => void;
+    registerMarkAttributeScale: (spec: IVisualScale, seriesId: number) => IBaseScale;
+    registerModelScale: (spec: IVisualSpecScale<unknown, unknown>) => void;
+    removeModelScale: (filter: (spec: IVisualSpecScale<unknown, unknown>) => boolean) => void;
+    updateSpec: (spec: IChartSpec['scales']) => IUpdateSpecResult;
+}

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

@@ -0,0 +1,8 @@
+import type { DirectionType } from '../../typings';
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+export interface IAreaAnimationParams {
+    direction: DirectionType;
+}
+export type AreaAppearPreset = 'clipIn' | 'fadeIn' | 'grow';
+export declare function areaPresetAnimation(params: IAreaAnimationParams, preset: AreaAppearPreset | boolean): IAnimationTypeConfig;
+export declare const registerAreaAnimation: () => void;

package/types/series/area/area.d.ts

@@ -0,0 +1,32 @@
+import type { DataView } from '@visactor/vdataset';
+import { LineLikeSeriesMixin } from '../mixin/line-mixin';
+import type { IAreaMark } from '../../mark/area';
+import { CartesianSeries } from '../cartesian/cartesian';
+import type { Maybe, Datum } from '../../typings';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { IAreaSeriesSpec, IAreaSeriesTheme } from './interface';
+import type { IMark } from '../../mark/interface';
+export interface AreaSeries<T extends IAreaSeriesSpec = IAreaSeriesSpec> extends Pick<LineLikeSeriesMixin, 'initLineMark' | 'initSymbolMark' | 'initLabelMarkStyle' | 'initLineMarkStyle' | 'initSymbolMarkStyle' | 'encodeDefined' | '_lineMark' | '_symbolMark' | 'addSamplingCompile' | 'addOverlapCompile' | 'reCompileSampling'>, CartesianSeries<T> {
+}
+export declare class AreaSeries<T extends IAreaSeriesSpec = IAreaSeriesSpec> extends CartesianSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _theme: Maybe<IAreaSeriesTheme>;
+    protected _areaMark: IAreaMark;
+    protected _supportStack: boolean;
+    protected _sortDataByAxis: boolean;
+    setAttrFromSpec(): void;
+    initMark(): void;
+    initMarkStyle(): void;
+    initAnimation(): void;
+    protected initTooltip(): void;
+    viewDataStatisticsUpdate(d: DataView): void;
+    compile(): void;
+    getDefaultShapeType(): string;
+    getActiveMarks(): IMark[];
+    onLayoutEnd(ctx: any): void;
+    getSeriesStyle(datum: Datum): (attribute: string) => any;
+}
+export declare const registerAreaSeries: () => void;

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

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

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

@@ -0,0 +1,22 @@
+import type { ICartesianSeriesSpec } from '../cartesian/interface';
+import type { IMarkSpec, IMarkTheme } from '../../typings/spec/common';
+import type { ISymbolMarkSpec, ILineMarkSpec, IAreaMarkSpec } from '../../typings/visual';
+import type { SeriesMarkNameEnum } from '../interface/type';
+import type { ILineLikeLabelSpec, ILineLikeSeriesTheme } from '../mixin/line-mixin';
+import type { IAnimationSpec } from '../../animation/spec';
+import type { AreaAppearPreset } from './animation';
+import type { IDataSamping, IMarkOverlap, IMarkProgressiveConfig } from '../../mark/interface';
+export interface IAreaSeriesSpec extends ICartesianSeriesSpec, IAnimationSpec<string, AreaAppearPreset>, IMarkProgressiveConfig, IDataSamping, IMarkOverlap {
+    type: 'area';
+    xField: string | string[];
+    yField: string | string[];
+    [SeriesMarkNameEnum.point]?: IMarkSpec<ISymbolMarkSpec>;
+    [SeriesMarkNameEnum.line]?: IMarkSpec<ILineMarkSpec>;
+    [SeriesMarkNameEnum.area]?: IMarkSpec<IAreaMarkSpec>;
+    [SeriesMarkNameEnum.label]?: ILineLikeLabelSpec;
+    seriesMark?: 'point' | 'line' | 'area';
+    activePoint?: boolean;
+}
+export interface IAreaSeriesTheme extends ILineLikeSeriesTheme {
+    [SeriesMarkNameEnum.area]?: Partial<IMarkTheme<IAreaMarkSpec>>;
+}

package/types/series/area/tooltip-helpter.d.ts

@@ -0,0 +1,5 @@
+import type { ISeriesTooltipHelper } from '../interface';
+import { BaseSeriesTooltipHelper } from '../base/tooltip-helper';
+export declare class AreaSeriesTooltipHelper extends BaseSeriesTooltipHelper implements ISeriesTooltipHelper {
+    protected _getSeriesStyle: (datum: any, styleKey: string | string[], defaultValue?: any) => any;
+}

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

@@ -0,0 +1,14 @@
+import type { DirectionType } from '../../typings';
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+export interface IBarAnimationParams {
+    xField: string;
+    yField: string;
+    direction: DirectionType;
+    growFrom: () => number;
+}
+export type BarAppearPreset = 'grow' | 'fadeIn' | 'scaleIn';
+export declare const barGrowIn: (params: IBarAnimationParams, isOverall?: boolean) => IAnimationTypeConfig;
+export declare const barGrowOut: (params: IBarAnimationParams, isOverall?: boolean) => IAnimationTypeConfig;
+export declare function barPresetAnimation(params: IBarAnimationParams, preset: BarAppearPreset | boolean): IAnimationTypeConfig;
+export declare const registerBarAnimation: () => void;
+export declare const registerBar3dAnimation: () => void;

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

@@ -0,0 +1,14 @@
+import { MarkTypeEnum } from '../../mark/interface/type';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum, SeriesMarkNameEnum } from '../interface/type';
+import { BarSeries } from './bar';
+import type { IBar3dSeriesSpec } from './interface';
+import type { AdaptiveSpec } from '../../typings';
+export declare class Bar3dSeries<T extends IBar3dSeriesSpec = IBar3dSeriesSpec> extends BarSeries<AdaptiveSpec<T, 'type'>> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _barMarkName: SeriesMarkNameEnum;
+    protected _barMarkType: MarkTypeEnum;
+}
+export declare const registerBar3dSeries: () => void;

package/types/series/bar/bar.d.ts

@@ -0,0 +1,52 @@
+import { CartesianSeries } from '../cartesian/cartesian';
+import type { IMark, IMarkProgressiveConfig } from '../../mark/interface';
+import { MarkTypeEnum } from '../../mark/interface/type';
+import type { Maybe, Datum, DirectionType } from '../../typings';
+import type { IBarSeriesSpec, IBarSeriesTheme } from './interface';
+import type { IAxisHelper } from '../../component/axis/cartesian/interface';
+import type { IRectMark } from '../../mark/rect';
+import type { IModelInitOption } from '../../model/interface';
+import type { ITextMark } from '../../mark/text';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesMarkNameEnum, SeriesTypeEnum } from '../interface/type';
+import { SeriesData } from '../base/series-data';
+import { DataView } from '@visactor/vdataset';
+export declare const DefaultBandWidth = 6;
+export declare class BarSeries<T extends IBarSeriesSpec = IBarSeriesSpec> extends CartesianSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    protected _barMarkName: SeriesMarkNameEnum;
+    protected _barMarkType: MarkTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _theme: Maybe<IBarSeriesTheme>;
+    protected _supportStack: boolean;
+    protected _bandPosition: number;
+    protected _barMark: IRectMark;
+    protected _barBackgroundMark: IRectMark;
+    protected _barBackgroundViewData: SeriesData;
+    initMark(): void;
+    protected _initBarBackgroundMark(progressive?: IMarkProgressiveConfig): void;
+    initMarkStyle(): void;
+    initLabelMarkStyle(textMark: ITextMark): void;
+    protected initTooltip(): void;
+    protected _statisticViewData(): void;
+    init(option: IModelInitOption): void;
+    private _shouldDoPreCalculate;
+    private _calculateStackRectPosition;
+    private _calculateRectPosition;
+    initBandRectMarkStyle(): void;
+    protected _initBarBackgroundMarkStyle(): void;
+    initLinearRectMarkStyle(): void;
+    initAnimation(): void;
+    protected _getBarWidth(axisHelper: IAxisHelper): number;
+    protected _getPosition(direction: DirectionType, datum: Datum): number;
+    onLayoutEnd(ctx: any): void;
+    compile(): void;
+    getDefaultShapeType(): string;
+    getActiveMarks(): IMark[];
+    compileData(): void;
+    fillData(): void;
+    viewDataUpdate(d: DataView): void;
+    release(): void;
+}
+export declare const registerBarSeries: () => void;

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

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

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

@@ -0,0 +1,39 @@
+import type { ICartesianSeriesSpec, ICartesianSeriesTheme } from '../cartesian/interface';
+import type { IMarkSpec, IMarkTheme } from '../../typings/spec/common';
+import type { IRect3dMarkSpec, IRectMarkSpec } from '../../typings/visual';
+import type { IAnimationSpec } from '../../animation/spec';
+import type { BarAppearPreset } from './animation';
+import type { ILabelSpec } from '../../component/label';
+import type { IDataSamping, IMarkProgressiveConfig } from '../../mark/interface';
+import type { SeriesMarkNameEnum } from '../interface/type';
+import type { Functional } from '@visactor/vrender-components';
+type BarMarks = 'bar';
+export interface IBarSeriesSpec extends ICartesianSeriesSpec, IAnimationSpec<BarMarks, BarAppearPreset>, IMarkProgressiveConfig, IDataSamping {
+    type: 'bar';
+    xField: string | string[];
+    yField: string | string[];
+    [SeriesMarkNameEnum.bar]?: IMarkSpec<IRectMarkSpec>;
+    [SeriesMarkNameEnum.barBackground]?: IMarkSpec<IRectMarkSpec>;
+    [SeriesMarkNameEnum.label]?: Omit<ILabelSpec, 'position'> & {
+        position?: Functional<'outside' | 'top' | 'bottom' | 'left' | 'right' | 'inside' | 'inside-top' | 'inside-bottom' | 'inside-right' | 'inside-left' | 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left'>;
+    };
+    barWidth?: number | string;
+    barMinWidth?: number | string;
+    barMaxWidth?: number | string;
+    barGapInGroup?: number | string | (number | string)[];
+    barMinHeight?: number;
+}
+export interface IBarSeriesTheme extends ICartesianSeriesTheme {
+    [SeriesMarkNameEnum.bar]?: Partial<IMarkTheme<IRectMarkSpec>>;
+    [SeriesMarkNameEnum.barBackground]?: IMarkSpec<IRectMarkSpec>;
+    barWidth?: number;
+    barMinWidth?: number;
+    barMaxWidth?: number;
+}
+export type IBar3dSeriesSpec = {
+    type: 'bar3d';
+} & Omit<IBarSeriesSpec, 'type'> & ICartesianSeriesSpec & IAnimationSpec<BarMarks, BarAppearPreset>;
+export interface IBar3dSeriesTheme extends ICartesianSeriesTheme {
+    [SeriesMarkNameEnum.bar3d]?: Partial<IMarkTheme<IRect3dMarkSpec>>;
+}
+export {};

package/types/series/base/base-series.d.ts

@@ -0,0 +1,195 @@
+import { DataView } from '@visactor/vdataset';
+import type { DataSet, ITransformOptions } from '@visactor/vdataset';
+import type { IRegion } from '../../region/interface';
+import type { IMark } from '../../mark/interface';
+import type { CoordinateType, IInvalidType, IPoint, DataKeyType, Datum, Maybe, ISeriesSpec, IGroup, ILayoutType, ILayoutPoint, ILayoutRect } from '../../typings';
+import { BaseModel } from '../../model/base-model';
+import type { ISeriesOption, ISeries, ISeriesMarkInitOption, ISeriesStackData, ISeriesTooltipHelper, SeriesMarkMap, ISeriesMarkInfo } from '../interface';
+import type { IModelEvaluateOption, IModelRenderOption } from '../../model/interface';
+import type { AddVChartPropertyContext } from '../../data/transforms/add-property';
+import type { ITrigger } from '../../interaction/interface';
+import type { StatisticOperations } from '../../data/transforms/dimension-statistics';
+import { SeriesData } from './series-data';
+import type { IGroupMark } from '../../mark/group';
+import type { ISeriesMarkAttributeContext } from '../../compile/mark';
+export declare abstract class BaseSeries<T extends ISeriesSpec> extends BaseModel<T> implements ISeries {
+    readonly specKey: string;
+    readonly type: string;
+    layoutType: ILayoutType;
+    readonly modelType: string;
+    readonly name: string | undefined;
+    static readonly mark: SeriesMarkMap;
+    protected _trigger: ITrigger;
+    getTrigger(): ITrigger;
+    protected _option: ISeriesOption;
+    readonly coordinate: CoordinateType;
+    protected _region: IRegion;
+    getRegion(): IRegion;
+    private _layoutStartPoint;
+    getLayoutStartPoint(): ILayoutPoint;
+    private _layoutRect;
+    getLayoutRect: () => ILayoutRect;
+    protected _rootMark: IGroupMark;
+    getRootMark(): IGroupMark;
+    protected _seriesMark: Maybe<IMark>;
+    protected _layoutLevel: number;
+    protected _rawData: DataView;
+    getRawData(): DataView;
+    protected _rawDataStatistics?: DataView;
+    protected _rawStatisticsCache: Record<string, {
+        values?: any[];
+        min?: number;
+        max?: number;
+    }>;
+    protected _viewDataMap: Map<number, DataView>;
+    protected _viewDataFilter: DataView;
+    getViewDataFilter(): DataView;
+    protected _data: SeriesData;
+    getViewData(): DataView;
+    getViewDataProductId(): string;
+    protected _viewDataStatistics: DataView;
+    getViewDataStatistics(): DataView;
+    protected _viewStackData: DataView;
+    getViewStackData(): DataView;
+    protected _seriesField?: string;
+    getSeriesField(): string;
+    setSeriesField(field: string): void;
+    protected _groups?: IGroup;
+    getGroups(): IGroup;
+    protected _stack: boolean;
+    protected _supportStack: boolean;
+    getStack(): boolean;
+    getStackValue(): import("../../typings").StringOrNumber;
+    protected _percent: boolean;
+    getPercent(): boolean;
+    protected _stackOffsetSilhouette: boolean;
+    getStackOffsetSilhouette(): boolean;
+    protected _dataSet: DataSet;
+    protected _tooltipHelper: ISeriesTooltipHelper | undefined;
+    get tooltipHelper(): ISeriesTooltipHelper;
+    layoutZIndex: number;
+    protected _invalidType: IInvalidType;
+    getInvalidType(): IInvalidType;
+    setInvalidType(t: IInvalidType): void;
+    protected _markAttributeContext: ISeriesMarkAttributeContext;
+    constructor(spec: T, options: ISeriesOption);
+    created(): void;
+    protected _buildMarkAttributeContext(): void;
+    setAttrFromSpec(): void;
+    protected initData(): void;
+    protected initGroups(): void;
+    protected initStatisticalData(): void;
+    getRawDataStatisticsByField(field: string, isNumeric?: boolean): {
+        values?: any[];
+        min?: number;
+        max?: number;
+    };
+    protected _statisticViewData(): void;
+    protected createStatisticalData(dataName: string, rawData: DataView, staticFields?: (dataId: string) => {
+        key: string;
+        operations: StatisticOperations;
+    }[]): DataView;
+    private createdStackData;
+    protected _noAnimationDataKey(datum: Datum, index: number): unknown | undefined;
+    protected generateDefaultDataKey(dataKey: DataKeyType): (datum: Datum, index: number, context: AddVChartPropertyContext) => unknown;
+    protected _addDataIndexAndKey(): void;
+    updateRawData(d: any): void;
+    rawDataUpdate(d: DataView): void;
+    viewDataFilterOver(d: DataView): void;
+    viewDataUpdate(d: DataView): void;
+    viewDataStatisticsUpdate(d: DataView): void;
+    getDatumPositionValue(datum: Datum, field: string): any;
+    getDatumPositionValues(datum: Datum, fields: string | string[]): any[];
+    abstract getStatisticFields(): {
+        key: string;
+        operations: StatisticOperations;
+    }[];
+    abstract getGroupFields(): string[];
+    abstract dataToPosition(data: Datum): IPoint;
+    abstract dataToPositionX(data: Datum): number;
+    abstract dataToPositionY(data: Datum): number;
+    abstract valueToPosition(value1: any, value2?: any): IPoint;
+    abstract initMark(): void;
+    abstract initMarkStyle(): void;
+    abstract getStackGroupFields(): string[];
+    abstract getStackValueField(): string | undefined;
+    setValueFieldToStack(): void;
+    setValueFieldToPercent(): void;
+    setValueFieldToStackOffsetSilhouette(): void;
+    abstract getActiveMarks(): IMark[];
+    initRootMark(): void;
+    protected _initExtensionMark(): void;
+    private _createExtensionMark;
+    protected _updateExtensionMarkSpec(lastSpec?: any): void;
+    getStackData(): ISeriesStackData;
+    initTrigger(): void;
+    initAnimation(): void;
+    initMarkState(): void;
+    initSeriesStyleState(): void;
+    afterInitMark(): void;
+    getMarksWithoutRoot(): IMark[];
+    getMarksInType(type: string | string[]): IMark[];
+    getMarkInName(name: string): IMark | undefined;
+    getMarkInId(markId: number): IMark | undefined;
+    protected initEvent(): void;
+    protected _releaseEvent(): void;
+    protected initTooltip(): void;
+    _compareSpec(ignoreCheckKeys?: {
+        [key: string]: true;
+    }): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    _updateSpecData(): void;
+    reInit(theme?: any, lastSpec?: any): void;
+    onEvaluateEnd(ctx: IModelEvaluateOption): void;
+    onRender(ctx: IModelRenderOption): void;
+    release(): void;
+    setLayoutStartPosition(pos: Partial<IPoint>): void;
+    setLayoutRect({ width, height }: Partial<ILayoutRect>, levelMap?: Partial<ILayoutRect>): void;
+    getSeriesKeys(): string[];
+    getSeriesStyle(datum: Datum): (attribute: string) => unknown;
+    protected _getSeriesInfo(field: string, keys: string[]): {
+        key: string;
+        style: (attribute: string) => unknown;
+        shapeType: string;
+    }[];
+    getSeriesInfoInField(field: string): {
+        key: string;
+        style: (attribute: string) => unknown;
+        shapeType: string;
+    }[];
+    getSeriesInfoList(): {
+        key: string;
+        style: (attribute: string) => unknown;
+        shapeType: string;
+    }[];
+    protected _getDefaultColorScale(): any;
+    protected _getDataScheme(): import("../..").ColorSchemeItem[] | import("../..").ProgressiveDataScheme<import("../..").ColorSchemeItem>;
+    getDefaultColorDomain(): any[];
+    getColorAttribute(): {
+        scale: any;
+        field: string;
+    };
+    getDimensionField(): string[];
+    getMeasureField(): string[];
+    protected onMarkPositionUpdate(): void;
+    protected onMarkTreePositionUpdate(marks: IMark[]): void;
+    protected _getTheme(): any;
+    protected _createMark<M extends IMark>(markInfo: ISeriesMarkInfo, option?: ISeriesMarkInitOption): NonNullable<M>;
+    protected _getDataIdKey(): string | ((datum: Datum) => string);
+    protected _getSeriesDataKey(datum: Datum): string;
+    addViewDataFilter(option: ITransformOptions): void;
+    reFilterViewData(): void;
+    reTransformViewData(): void;
+    fillData(): void;
+    compile(): void;
+    getDefaultShapeType(): string;
+    getFieldAlias(field: string): any;
+    getMarkInfoList(): import("../../model/interface").IModelMarkInfo[];
+    protected _getInvalidConnectType(): "none" | "zero" | "connect";
+    protected _getInvalidDefined: (datum: Datum) => boolean;
+}

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

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

package/types/series/base/group.d.ts

@@ -0,0 +1,12 @@
+import { DataSet, DataView } from '@visactor/vdataset';
+import type { IGroup } from '../../typings';
+export declare class Group implements IGroup {
+    protected _fields: string[];
+    get fields(): string[];
+    protected _groupData?: DataView;
+    get groupData(): DataView;
+    constructor(fields: string[]);
+    initData(viewData: DataView, dataSet: DataSet): void;
+    groupDataUpdate(): void;
+    getGroupValueInField(field: string): unknown[];
+}

package/types/series/base/series-data.d.ts

@@ -0,0 +1,5 @@
+import { CompilableData } from '../../compile/data/compilable-data';
+export declare class SeriesData extends CompilableData {
+    protected _compileProduct(): void;
+    generateProductId(): string;
+}

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

@@ -0,0 +1,29 @@
+import type { TooltipHandlerParams } from '../../component/tooltip/interface';
+import type { ITooltipPattern, ShapeType, TooltipActiveType } from '../../typings';
+import type { ISeries, ISeriesTooltipHelper } from '../interface';
+import { BaseTooltipHelper } from '../../model/tooltip-helper';
+import type { IDimensionInfo } from '../../event/events/dimension/interface';
+import type { Datum } from '@visactor/vgrammar-core';
+interface ISeriesCacheInfo {
+    seriesFields: string[];
+    dimensionFields: string[];
+    measureFields: string[];
+    type: string;
+}
+export declare class BaseSeriesTooltipHelper extends BaseTooltipHelper implements ISeriesTooltipHelper {
+    series: ISeries;
+    protected _seriesCacheInfo: ISeriesCacheInfo;
+    constructor(series: ISeries);
+    updateTooltipSpec(): void;
+    protected _getSeriesCacheInfo: () => ISeriesCacheInfo;
+    protected _getDimensionData: (datum: any) => any;
+    protected _getMeasureData: (datum: any) => any;
+    protected _getSeriesStyle: (datum: any, styleKey: string | string[], defaultValue?: any) => any;
+    contentKeyCallback: (datum: Datum, params?: TooltipHandlerParams) => string | undefined;
+    contentValueCallback: (datum: Datum, params?: TooltipHandlerParams) => string | undefined;
+    contentShapeTypeCallback: (datum: Datum, params?: TooltipHandlerParams) => ShapeType | undefined;
+    contentShapeColorCallback: (datum: Datum, params?: TooltipHandlerParams) => string | undefined;
+    titleValueCallback: (datum: Datum, params?: TooltipHandlerParams) => string | undefined;
+    getDefaultTooltipPattern(activeType: TooltipActiveType, dimensionInfo?: IDimensionInfo[]): ITooltipPattern | null;
+}
+export {};

package/types/series/box-plot/box-plot.d.ts

@@ -0,0 +1,63 @@
+import type { IModelEvaluateOption, IModelInitOption } from '../../model/interface';
+import type { BoxPlotShaftShape, IOutlierMarkSpec, Maybe } from '../../typings';
+import { CartesianSeries } from '../cartesian/cartesian';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { IBoxPlotSeriesSpec, IBoxPlotSeriesTheme } from './interface';
+import { SeriesData } from '../base/series-data';
+import type { IMark } from '../../mark/interface';
+export declare const DEFAULT_FILL_COLOR = "#FFF";
+export declare const DEFAULT_STROKE_COLOR = "#000";
+export declare class BoxPlotSeries<T extends IBoxPlotSeriesSpec = IBoxPlotSeriesSpec> extends CartesianSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _theme: Maybe<IBoxPlotSeriesTheme>;
+    protected _minField: string;
+    getMinField(): string;
+    protected _maxField: string;
+    getMaxField(): string;
+    protected _q1Field: string;
+    getQ1Field(): string;
+    protected _medianField: string;
+    getMedianField(): string;
+    protected _q3Field: string;
+    getQ3Field(): string;
+    protected _outliersField: string;
+    getOutliersField(): string;
+    protected _lineWidth: number;
+    protected _boxWidth: number;
+    protected _shaftShape: BoxPlotShaftShape;
+    getShaftShape(): BoxPlotShaftShape;
+    protected _shaftWidth: number;
+    protected _boxFillColor: string;
+    getBoxFillColor(): string;
+    protected _strokeColor: string;
+    getStrokeColor(): string;
+    protected _shaftFillOpacity: number;
+    protected _outliersStyle: IOutlierMarkSpec;
+    getOutliersStyle(): IOutlierMarkSpec;
+    protected _outlierDataView: SeriesData;
+    private _autoBoxWidth;
+    setAttrFromSpec(): void;
+    private _boxPlotMark?;
+    private _outlierMark?;
+    initMark(): void;
+    initMarkStyle(): void;
+    initBoxPlotMarkStyle(): void;
+    initData(): void;
+    init(option: IModelInitOption): void;
+    private _getMarkWidth;
+    onLayoutEnd(ctx: any): void;
+    private _initAnimationSpec;
+    initAnimation(): void;
+    protected initTooltip(): void;
+    getStatisticFields(): {
+        key: string;
+        operations: import("../../data/transforms/dimension-statistics").StatisticOperations;
+    }[];
+    onEvaluateEnd(ctx: IModelEvaluateOption): void;
+    getDefaultShapeType(): string;
+    getActiveMarks(): IMark[];
+}
+export declare const registerBoxplotSeries: () => void;

package/types/series/box-plot/constant.d.ts

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

package/types/series/box-plot/interface.d.ts

@@ -0,0 +1,23 @@
+import type { IMarkSpec, IMarkTheme } from '../..';
+import type { IAnimationSpec } from '../../animation/spec';
+import type { IMarkProgressiveConfig } from '../../mark/interface';
+import type { DirectionType, IBoxPlotMarkSpec, IOutlierMarkSpec } from '../../typings';
+import type { ICartesianSeriesSpec, ICartesianSeriesTheme } from '../cartesian/interface';
+import type { SeriesMarkNameEnum } from '../interface/type';
+export interface IBoxPlotSeriesSpec extends Omit<ICartesianSeriesSpec, 'xField' | 'yField' | 'direction'>, IAnimationSpec<string, string>, IMarkProgressiveConfig {
+    type: 'boxPlot';
+    direction?: DirectionType;
+    xField?: string | string[];
+    yField?: string | string[];
+    minField?: string;
+    maxField?: string;
+    q1Field?: string;
+    medianField?: string;
+    q3Field?: string;
+    [SeriesMarkNameEnum.boxPlot]?: IMarkSpec<IBoxPlotMarkSpec>;
+    outliersField?: string;
+    outliersStyle?: IOutlierMarkSpec;
+}
+export interface IBoxPlotSeriesTheme extends ICartesianSeriesTheme {
+    [SeriesMarkNameEnum.boxPlot]?: Partial<IMarkTheme<IBoxPlotMarkSpec>>;
+}

package/types/series/box-plot/tooltip-helper.d.ts

@@ -0,0 +1,12 @@
+import type { ISeriesTooltipHelper } from '../interface';
+import { BaseSeriesTooltipHelper } from '../base/tooltip-helper';
+import type { Datum, ITooltipPattern, TooltipActiveType } from '../../typings';
+import { BOX_PLOT_TOOLTIP_KEYS } from '../../constant/box-plot';
+export declare class BoxPlotSeriesTooltipHelper extends BaseSeriesTooltipHelper implements ISeriesTooltipHelper {
+    getDefaultTooltipPattern(activeType: TooltipActiveType): ITooltipPattern | null;
+    getContentKey: (contentType: BOX_PLOT_TOOLTIP_KEYS) => (datum: any) => string;
+    getContentValue: (contentType: BOX_PLOT_TOOLTIP_KEYS) => (datum: any) => any;
+    contentShapeColorCallback: (datum: Datum) => any;
+    getOutlierFillColor: (datum: Datum) => any;
+    isOutlierMark: (datum: Datum) => boolean;
+}