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

package/build/es5/series/base/base-series.d.ts

@@ -0,0 +1,177 @@
+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 } 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 { Group } from './group';
+import type { AddVChartPropertyContext } from '../../data/transforms/add-property';
+import type { ITrigger } from '../../interaction/interface';
+import type { LayoutItem } from '../../model/layout-item';
+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 implements ISeries {
+    readonly type: string;
+    layoutType: LayoutItem['layoutType'];
+    readonly modelType: string;
+    readonly name: string | undefined;
+    static readonly mark: SeriesMarkMap;
+    protected _trigger: ITrigger;
+    getTrigger(): ITrigger;
+    protected _option: ISeriesOption;
+    protected _spec: T;
+    readonly coordinate: CoordinateType;
+    protected _region: IRegion;
+    getRegion(): IRegion;
+    protected _rootMark: IGroupMark;
+    getRootMark(): IGroupMark;
+    protected _seriesMark: Maybe<IMark>;
+    protected _layoutLevel: number;
+    protected _rawData: DataView;
+    getRawData(): DataView;
+    protected _rawDataStatistics: DataView;
+    getRawDataStatistics(): DataView;
+    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?: Group;
+    getGroups(): Group;
+    protected _stackValue: string;
+    protected _stack: boolean;
+    getStack(): boolean;
+    protected _percent: boolean;
+    getPercent(): boolean;
+    protected _stackOffsetSilhouette: boolean;
+    getStackOffsetSilhouette(): boolean;
+    protected _dataSet: DataSet;
+    protected _tooltipHelper: ISeriesTooltipHelper | undefined;
+    get tooltipHelper(): ISeriesTooltipHelper;
+    protected _invalidType: IInvalidType;
+    getInvalidType(): IInvalidType;
+    setInvalidType(t: IInvalidType): void;
+    protected _markAttributeContext: ISeriesMarkAttributeContext;
+    constructor(spec: any, options: ISeriesOption);
+    created(): void;
+    protected _buildMarkAttributeContext(): void;
+    setAttrFromSpec(): void;
+    protected initData(): void;
+    protected initGroups(): void;
+    protected initStatisticalData(): void;
+    protected _statisticRawData(): void;
+    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, context: AddVChartPropertyContext): unknown | undefined;
+    protected generateDefaultDataKey(dataKey: DataKeyType, datum: Datum, index: number, context: AddVChartPropertyContext): any;
+    protected _addDataIndexAndKey(): void;
+    updateRawData(d: any): void;
+    rawDataUpdate(d: DataView): void;
+    rawDataStatisticsUpdate(d: DataView): void;
+    viewDataFilterOver(d: DataView): void;
+    viewDataUpdate(d: DataView): void;
+    viewDataStatisticsUpdate(d: DataView): void;
+    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;
+    abstract setValueFieldToStack(): void;
+    abstract setValueFieldToPercent(): void;
+    abstract setValueFieldToStackOffsetSilhouette(): void;
+    initRootMark(): void;
+    protected _initExtensionMark(): void;
+    private _createExtensionMark;
+    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;
+    updateSpec(spec: any): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    reInit(theme?: any): void;
+    onEvaluateEnd(ctx: IModelEvaluateOption): void;
+    onRender(ctx: IModelRenderOption): void;
+    release(): void;
+    onLayoutEnd(ctx: any): 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;
+    getDefaultColorDomain(): any[];
+    getColorAttribute(): {
+        scale: any;
+        field: string;
+    };
+    getDimensionField(): string[];
+    getMeasureField(): string[];
+    protected onMarkPositionUpdate(): void;
+    protected onMarkTreePositionUpdate(marks: IMark[]): void;
+    setCurrentTheme(theme: any, noRender?: boolean): Promise<void>;
+    protected _initTheme(theme?: any): void;
+    protected _mergeThemeToSpec(): void;
+    protected _getDefaultSpecFromChart(chartSpec: any): Partial<T>;
+    protected _createMark<T extends IMark>(markInfo: ISeriesMarkInfo, option?: ISeriesMarkInitOption): NonNullable<T>;
+    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[];
+}

package/build/es5/series/base/group.d.ts

@@ -0,0 +1,11 @@
+import { DataSet, DataView } from '@visactor/vdataset';
+export declare class Group {
+    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/build/es5/series/base/series-data.d.ts

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

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

@@ -0,0 +1,30 @@
+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';
+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;
+    getDefaultShapeType(): string;
+}
+export {};

package/build/es5/series/box-plot/box-plot.d.ts

@@ -0,0 +1,61 @@
+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';
+import type { IBoxPlotSeriesSpec, IBoxPlotSeriesTheme } from './interface';
+import { SeriesData } from '../base/series-data';
+export declare const DEFAULT_FILL_COLOR = "#FFF";
+export declare const DEFAULT_STROKE_COLOR = "#000";
+export declare class BoxPlotSeries extends CartesianSeries<any> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _spec: IBoxPlotSeriesSpec;
+    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;
+}

package/build/es5/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';
+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/build/es5/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;
+}

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

@@ -0,0 +1,90 @@
+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';
+export declare abstract class CartesianSeries<T extends ICartesianSeriesSpec = ICartesianSeriesSpec> extends BaseSeries<T> implements ICartesianSeries {
+    readonly coordinate: 'cartesian';
+    protected _bandPosition: number;
+    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 _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;
+    getStatisticFields(): {
+        key: string;
+        operations: StatisticOperations;
+    }[];
+    getGroupFields(): string[];
+    getStackGroupFields(): string[];
+    getStackValueField(): string;
+    setValueFieldToStack(): void;
+    setValueFieldToPercent(): void;
+    setValueFieldToStackOffsetSilhouette(): void;
+    onXAxisHelperUpdate(): void;
+    onYAxisHelperUpdate(): void;
+    onZAxisHelperUpdate(): void;
+    updateSpec(spec: any): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    setAttrFromSpec(): void;
+    dataToPosition(datum: Datum): IPoint | null;
+    protected _buildMarkAttributeContext(): void;
+    valueToPosition(xValue: StringOrNumber | StringOrNumber[], yValue: StringOrNumber | StringOrNumber[]): {
+        x: number;
+        y: number;
+    };
+    valueToPositionX(value: StringOrNumber | StringOrNumber[]): number;
+    valueToPositionY(value: StringOrNumber | StringOrNumber[]): 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[];
+}

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

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

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

@@ -0,0 +1,14 @@
+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[];
+}
+export interface ICartesianSeriesTheme {
+    label?: Partial<ILabelSpec>;
+}

package/build/es5/series/circle-packing/animation.d.ts

@@ -0,0 +1,7 @@
+import type { IAnimationTypeConfig } from '@visactor/vgrammar';
+export type CirclePackingMark = 'leaf' | 'nonLeaf' | 'label' | 'nonLeafLabel';
+export type CirclePackingAppearPreset = 'growIn' | 'fadeIn';
+export interface ICirclePackingAnimationParams {
+    [key: string]: object;
+}
+export declare const circlePackingPresetAnimation: (_params: ICirclePackingAnimationParams, preset: CirclePackingAppearPreset) => IAnimationTypeConfig;

package/build/es5/series/circle-packing/circle-packing.d.ts

@@ -0,0 +1,43 @@
+import type { ICirclePackingSeriesSpec } from './interface';
+import type { Datum } from '../../typings';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface';
+import { CartesianSeries } from '../cartesian/cartesian';
+export declare class CirclePackingSeries extends CartesianSeries<any> {
+    protected _spec: ICirclePackingSeriesSpec;
+    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;
+}

package/build/es5/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';
+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/build/es5/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/build/es5/series/dot/config.d.ts

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

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

@@ -0,0 +1,68 @@
+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 extends CartesianSeries<IDotSeriesSpec> {
+    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'>;
+    }[];
+    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>;
+    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;
+}

package/build/es5/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';
+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/build/es5/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/build/es5/series/funnel/funnel-3d.d.ts

@@ -0,0 +1,18 @@
+import type { Maybe } from '@visactor/vutils';
+import { MarkTypeEnum } from '../../mark/interface';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum, SeriesMarkNameEnum } from '../interface';
+import { FunnelSeries } from './funnel';
+import type { IFunnel3dSeriesTheme } from './interface';
+export declare class Funnel3dSeries extends FunnelSeries {
+    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;
+}