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

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

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

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

@@ -0,0 +1,55 @@
+import type { IWaterfallSeriesTheme } from '../waterfall/interface';
+import type { IBoxPlotSeriesTheme } from '../box-plot/interface';
+import type { IBar3dSeriesTheme, IBarSeriesTheme } from '../bar/interface';
+import type { ILineSeriesTheme } from '../line/interface';
+import type { IScatterSeriesTheme } from '../scatter/interface';
+import type { IAreaSeriesTheme } from '../area/interface';
+import type { IRadarSeriesTheme } from '../radar/interface';
+import type { IPie3dSeriesTheme, IPieSeriesTheme } from '../pie/interface';
+import type { IRoseSeriesTheme } from '../rose/interface';
+import type { IMapSeriesTheme } from '../map/interface';
+import type { ICircularProgressSeriesTheme } from '../progress/circular/interface';
+import type { ILinkSeriesTheme } from '../link/interface';
+import type { IDotSeriesTheme } from '../dot/interface';
+import type { IWordCloud3dSeriesTheme, IWordCloudSeriesTheme } from '../word-cloud/interface';
+import type { SeriesTypeEnum } from './type';
+import type { IFunnel3dSeriesTheme, IFunnelSeriesTheme } from '../funnel/interface';
+import type { ILinearProgressSeriesTheme } from '../progress/linear/interface';
+import type { IGaugePointerSeriesTheme, IGaugeSeriesTheme } from '../gauge';
+import type { ISankeySeriesTheme } from '../sankey/interface';
+import type { ITreemapSeriesTheme } from '../treemap/interface';
+import type { ISunburstSeriesTheme } from '../sunburst/interface';
+import type { IRangeColumnSeriesTheme } from '../range-column/interface';
+import type { ICirclePackingSeriesTheme } from '../circle-packing/interface';
+import type { IHeatmapSeriesTheme } from '../heatmap/interface';
+export interface ISeriesTheme {
+    [SeriesTypeEnum.bar]?: IBarSeriesTheme;
+    [SeriesTypeEnum.bar3d]?: IBar3dSeriesTheme;
+    [SeriesTypeEnum.line]?: ILineSeriesTheme;
+    [SeriesTypeEnum.scatter]?: IScatterSeriesTheme;
+    [SeriesTypeEnum.area]?: IAreaSeriesTheme;
+    [SeriesTypeEnum.radar]?: IRadarSeriesTheme;
+    [SeriesTypeEnum.pie]?: IPieSeriesTheme;
+    [SeriesTypeEnum.pie3d]?: IPie3dSeriesTheme;
+    [SeriesTypeEnum.rose]?: IRoseSeriesTheme;
+    [SeriesTypeEnum.map]?: IMapSeriesTheme;
+    [SeriesTypeEnum.circularProgress]?: ICircularProgressSeriesTheme;
+    [SeriesTypeEnum.link]?: ILinkSeriesTheme;
+    [SeriesTypeEnum.dot]?: IDotSeriesTheme;
+    [SeriesTypeEnum.wordCloud]?: IWordCloudSeriesTheme;
+    [SeriesTypeEnum.wordCloud3d]?: IWordCloud3dSeriesTheme;
+    [SeriesTypeEnum.funnel]?: IFunnelSeriesTheme;
+    [SeriesTypeEnum.funnel3d]?: IFunnel3dSeriesTheme;
+    [SeriesTypeEnum.wordCloud]?: IWordCloudSeriesTheme;
+    [SeriesTypeEnum.linearProgress]?: ILinearProgressSeriesTheme;
+    [SeriesTypeEnum.waterfall]?: IWaterfallSeriesTheme;
+    [SeriesTypeEnum.boxPlot]?: IBoxPlotSeriesTheme;
+    [SeriesTypeEnum.treemap]?: ITreemapSeriesTheme;
+    [SeriesTypeEnum.sankey]?: ISankeySeriesTheme;
+    [SeriesTypeEnum.gauge]?: IGaugeSeriesTheme;
+    [SeriesTypeEnum.gaugePointer]?: IGaugePointerSeriesTheme;
+    [SeriesTypeEnum.sunburst]?: ISunburstSeriesTheme;
+    [SeriesTypeEnum.rangeColumn]?: IRangeColumnSeriesTheme;
+    [SeriesTypeEnum.circlePacking]?: ICirclePackingSeriesTheme;
+    [SeriesTypeEnum.heatmap]?: IHeatmapSeriesTheme;
+}

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

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

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

@@ -0,0 +1,34 @@
+export type SeriesType = keyof typeof SeriesTypeEnum | string;
+export declare enum SeriesTypeEnum {
+    area = "area",
+    line = "line",
+    bar = "bar",
+    bar3d = "bar3d",
+    rangeColumn = "rangeColumn",
+    rangeColumn3d = "rangeColumn3d",
+    rangeArea = "rangeArea",
+    dot = "dot",
+    geo = "geo",
+    link = "link",
+    map = "map",
+    pie = "pie",
+    pie3d = "pie3d",
+    radar = "radar",
+    rose = "rose",
+    scatter = "scatter",
+    circularProgress = "circularProgress",
+    wordCloud = "wordCloud",
+    wordCloud3d = "wordCloud3d",
+    funnel = "funnel",
+    funnel3d = "funnel3d",
+    linearProgress = "linearProgress",
+    boxPlot = "boxPlot",
+    sankey = "sankey",
+    gaugePointer = "gaugePointer",
+    gauge = "gauge",
+    treemap = "treemap",
+    sunburst = "sunburst",
+    circlePacking = "circlePacking",
+    waterfall = "waterfall",
+    heatmap = "heatmap"
+}

package/build/es5/series/line/animation.d.ts

@@ -0,0 +1,7 @@
+import type { DirectionType } from '../../typings';
+import type { IAnimationTypeConfig } from '@visactor/vgrammar';
+export interface ILineAnimationParams {
+    direction: DirectionType;
+}
+export type LineAppearPreset = 'clipIn' | 'fadeIn' | 'grow';
+export declare function linePresetAnimation(params: ILineAnimationParams, preset: LineAppearPreset): IAnimationTypeConfig;

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

@@ -0,0 +1,25 @@
+import type { IMarkSpec } from '../../typings/spec/common';
+import type { ICartesianSeriesSpec, ICartesianSeriesTheme } from '../cartesian/interface';
+import type { ISymbolMarkSpec, ILineMarkSpec } from '../../typings/visual';
+import type { IInvalidType } from '../../typings';
+import type { IAnimationSpec } from '../../animation/spec';
+import type { LineAppearPreset } from './animation';
+import type { ILineLikeSeriesTheme } from '../mixin/line-mixin';
+import type { ILabelSpec } from '../../component/label';
+import type { IMarkProgressiveConfig } from '../../mark/interface';
+import type { SeriesMarkNameEnum } from '../interface';
+type LineMarks = 'point' | 'line';
+export interface ILineSeriesSpec extends ICartesianSeriesSpec, IAnimationSpec<LineMarks, LineAppearPreset>, IMarkProgressiveConfig {
+    type: 'line';
+    invalidType?: IInvalidType;
+    [SeriesMarkNameEnum.point]?: IMarkSpec<ISymbolMarkSpec>;
+    [SeriesMarkNameEnum.line]?: IMarkSpec<ILineMarkSpec>;
+    label?: ILabelSpec & {
+        position?: 'top' | 'bottom' | 'left' | 'right' | 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'center';
+    };
+    seriesMark?: 'line' | 'point';
+}
+export interface ILineSeriesTheme extends Omit<ICartesianSeriesTheme, 'label'>, ILineLikeSeriesTheme {
+    label?: Partial<ILineSeriesSpec['label']>;
+}
+export {};

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

@@ -0,0 +1,19 @@
+import { CartesianSeries } from '../cartesian/cartesian';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface';
+import { LineLikeSeriesMixin } from '../mixin/line-mixin';
+import type { Datum, IInvalidType, Maybe } from '../../typings';
+import type { ILineSeriesSpec, ILineSeriesTheme } from './interface';
+export interface LineSeries extends Pick<LineLikeSeriesMixin, 'initLineMark' | 'initSymbolMark' | 'initLabelMarkStyle' | 'initLineMarkStyle' | 'initSymbolMarkStyle' | '_lineMark' | '_symbolMark'>, CartesianSeries<ILineSeriesSpec> {
+}
+export declare class LineSeries extends CartesianSeries<ILineSeriesSpec> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    protected _invalidType: IInvalidType;
+    static readonly mark: SeriesMarkMap;
+    protected _theme: Maybe<ILineSeriesTheme>;
+    initMark(): void;
+    initMarkStyle(): void;
+    initAnimation(): void;
+    getSeriesStyle(datum: Datum): (attribute: string) => unknown;
+}

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

@@ -0,0 +1,25 @@
+import type { ICartesianSeriesSpec, ICartesianSeriesTheme } from '../cartesian/interface';
+import type { IMarkSpec, IMarkTheme } from '../../typings/spec/common';
+import type { ILineMarkSpec, ISymbolMarkSpec } from '../../typings/visual';
+import type { SeriesMarkNameEnum } from '../interface';
+import type { DataView } from '@visactor/vdataset';
+import type { IDotSeriesSpec } from '../dot/interface';
+export interface ILinkSeriesSpec extends ICartesianSeriesSpec, ILinkSeriesSpecFromDot {
+    type: 'link';
+    fromField: string;
+    toField: string;
+    dotSeriesIndex: number;
+    dotTypeField?: string;
+    [SeriesMarkNameEnum.link]?: IMarkSpec<ILineMarkSpec>;
+}
+type ILinkSeriesSpecFromDot = {
+    dataDot?: DataView;
+    dotSeriesSpec?: IDotSeriesSpec;
+    leftAppendPadding?: number;
+    clipHeight?: number;
+};
+export interface ILinkSeriesTheme extends ICartesianSeriesTheme {
+    [SeriesMarkNameEnum.link]?: Partial<IMarkTheme<ILineMarkSpec>>;
+    [SeriesMarkNameEnum.arrow]?: Partial<IMarkTheme<ISymbolMarkSpec>>;
+}
+export {};

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

@@ -0,0 +1,50 @@
+import { CartesianSeries } from '../cartesian/cartesian';
+import type { Maybe, Datum } from '../../typings';
+import type { IMark } from '../../mark/interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { IDotSeriesSpec } from '../dot/interface';
+import type { ILinkSeriesSpec, ILinkSeriesTheme } from './interface';
+import type { SeriesMarkMap } from '../interface';
+export declare class LinkSeries extends CartesianSeries<ILinkSeriesSpec> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _theme: Maybe<ILinkSeriesTheme>;
+    protected _fromField?: string;
+    getFromField(): string;
+    setFromField(field: string): void;
+    protected _toField?: string;
+    getToField(): string;
+    setToField(field: string): void;
+    protected _dotTypeField?: string;
+    getDotTypeField(): string;
+    setDotTypeField(field: string): void;
+    protected _dotSeriesSpec?: IDotSeriesSpec;
+    getDotSeriesSpec(): IDotSeriesSpec;
+    setDotSeriesSpec(spec: IDotSeriesSpec): void;
+    initData(): void;
+    setAttrFromSpec(): void;
+    private _clipMark;
+    private _containerMark;
+    private _linkMark;
+    private _arrowMark;
+    initMark(): void;
+    initMarkStyle(): void;
+    afterInitMark(): void;
+    dataToPositionXFrom(datum: Datum): number;
+    dataToPositionYFrom(datum: Datum): number;
+    dataToPositionXTo(datum: Datum): number;
+    dataToPositionYTo(datum: Datum): number;
+    dataToPositionArrowYTo(datum: Datum, arrowSize: number): number;
+    dataToOpacity(datum: Datum): number;
+    isPositionYFromHigher(datum: Datum): boolean;
+    isPositionXOuterRange(datum: Datum, field: string): boolean;
+    getDefaultColorDomain(): any;
+    getColorAttribute(): {
+        scale: any;
+        field: string;
+    };
+    protected initTooltip(): void;
+    protected onMarkTreePositionUpdate(marks: IMark[]): void;
+    getDotInfoData(): import("../../compile/mark/mark-data").MarkData;
+}

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

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

package/build/es5/series/map/geo-source.d.ts

@@ -0,0 +1,20 @@
+import { DataView } from '@visactor/vdataset';
+import type { GeoSourceType } from '../../typings/geo';
+export interface IGeoJsonOption {
+    type: 'geojson';
+    centroid?: boolean;
+    simplify?: boolean;
+    rewind?: boolean | {
+        reverse?: boolean;
+    };
+}
+export interface ITopoJsonOption extends Omit<IGeoJsonOption, 'type'> {
+    type: 'topojson';
+    object: string;
+}
+export type GeoSourceOption = IGeoJsonOption | ITopoJsonOption;
+export declare const geoSourceMap: Map<string, DataView>;
+export declare function registerMapSource(key: string, source: GeoSourceType, option?: GeoSourceOption): void;
+export declare function unregisterMapSource(key: string): void;
+export declare function getMapSource(type: string): DataView;
+export declare function clearMapSource(): void;

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

@@ -0,0 +1,29 @@
+import type { IPathMarkSpec, ITextMarkSpec } from '../../typings/visual';
+import type { IMarkSpec, IMarkTheme, ISeriesSpec } from '../../typings/spec/common';
+import type { IAnimationSpec } from '../../animation/spec';
+type LineMarks = 'area';
+export interface IMapSeriesSpec extends ISeriesSpec, IAnimationSpec<LineMarks, 'fadeIn'> {
+    type: 'map';
+    map: string;
+    nameField?: string;
+    valueField?: string;
+    nameProperty?: string;
+    nameMap?: {
+        [key: string]: string;
+    };
+    area?: IMarkSpec<Omit<IPathMarkSpec, 'smoothScale'>>;
+    defaultFillColor?: string;
+    label?: IMarkSpec<ITextMarkSpec> & {
+        offset?: number;
+        position?: string;
+    };
+}
+export interface IMapSeriesTheme {
+    defaultFillColor?: string;
+    label?: Partial<IMarkTheme<ITextMarkSpec> & {
+        offset?: number;
+        position?: string;
+    }>;
+    area?: Partial<IMarkTheme<Omit<IPathMarkSpec, 'smoothScale'>>>;
+}
+export {};

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

@@ -0,0 +1,52 @@
+import { DataView } from '@visactor/vdataset';
+import type { Maybe, StringOrNumber } from '../../typings';
+import { GeoSeries } from '../geo/geo';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface';
+import type { IMapSeriesSpec, IMapSeriesTheme } from './interface';
+import type { PanEventParam, ZoomEventParam } from '../../event/interface';
+export declare class MapSeries extends GeoSeries<IMapSeriesSpec> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    map: string;
+    protected _nameMap: {
+        [key: StringOrNumber]: StringOrNumber;
+    };
+    getNameMap(): {
+        [key: string]: StringOrNumber;
+        [key: number]: StringOrNumber;
+    };
+    protected _nameProperty: string;
+    getNameProperty(): string;
+    protected _theme: Maybe<IMapSeriesTheme>;
+    private _areaCache;
+    private _pathMark;
+    private _labelMark;
+    setAttrFromSpec(): void;
+    initData(): void;
+    initMark(): void;
+    initMarkStyle(): void;
+    initAnimation(): void;
+    protected initTooltip(): void;
+    protected getPath(datum: any): string;
+    onEvaluateEnd(): void;
+    getDimensionField(): string[];
+    getMeasureField(): string[];
+    release(): void;
+    updateSpec(spec: any): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    handleZoom(e: ZoomEventParam): void;
+    handlePan(e: PanEventParam): void;
+    protected _getDatumCenter(datum: any): [number, number];
+    protected _getDatumName(datum: any): string;
+    dataToPositionX(data: any): number;
+    dataToPositionY(data: any): number;
+    viewDataUpdate(d: DataView): void;
+    protected _getDataIdKey(): string;
+}

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

@@ -0,0 +1,5 @@
+import type { ISeriesTooltipHelper } from '../interface';
+import { BaseSeriesTooltipHelper } from '../base/tooltip-helper';
+export declare class MapSeriesTooltipHelper extends BaseSeriesTooltipHelper implements ISeriesTooltipHelper {
+    titleValueCallback: (datum: any) => any;
+}

package/build/es5/series/mixin/line-mixin.d.ts

@@ -0,0 +1,35 @@
+import type { ITrigger } from '../../interaction/interface';
+import type { ISeries } from '../interface/series';
+import type { IMark, IMarkProgressiveConfig } from '../../mark/interface';
+import type { ILineMark } from '../../mark/line';
+import type { ISymbolMark } from '../../mark/symbol';
+import type { ITextMark } from '../../mark/text';
+import type { DirectionType, IInvalidType, InterpolateType, ILineMarkSpec, ISymbolMarkSpec, Maybe, IMarkTheme } from '../../typings';
+import type { ISeriesMarkInfo, ISeriesMarkInitOption, ISeriesTooltipHelper, SeriesMarkMap } from '../interface';
+import type { ILabelSpec } from '../../component/label';
+export interface ILineLikeSeriesTheme {
+    line?: Partial<IMarkTheme<ILineMarkSpec>>;
+    point?: Partial<IMarkTheme<ISymbolMarkSpec>>;
+    label?: Partial<ILabelSpec>;
+}
+export interface LineLikeSeriesMixin extends ISeries {
+    _spec: any;
+    _seriesField: string;
+    _theme: Maybe<ILineLikeSeriesTheme>;
+    _trigger: ITrigger;
+    _tooltipHelper: ISeriesTooltipHelper;
+    _invalidType: IInvalidType;
+    _lineMark: ILineMark;
+    _symbolMark: ISymbolMark;
+    _labelMark: ITextMark;
+    _createMark: (markInfo: ISeriesMarkInfo, option?: ISeriesMarkInitOption) => IMark;
+}
+export declare class LineLikeSeriesMixin {
+    setSeriesField(field: string): void;
+    initLineMark(progressive?: IMarkProgressiveConfig, isSeriesMark?: boolean): ILineMark;
+    initLineMarkStyle(direction?: DirectionType, areaCurveType?: InterpolateType): ILineMark;
+    initSymbolMark(progressive?: IMarkProgressiveConfig, isSeriesMark?: boolean): ISymbolMark;
+    initSymbolMarkStyle(): ISymbolMark;
+    initLabelMarkStyle(labelMark?: ITextMark): void;
+}
+export declare const lineLikeSeriesMarkMap: SeriesMarkMap;

package/build/es5/series/pie/animation/animation.d.ts

@@ -0,0 +1,23 @@
+import type { IElement, IAnimationTypeConfig } from '@visactor/vgrammar';
+import { AnimationStateEnum } from '../../../animation/interface';
+import type { Datum } from '../../../typings';
+export interface IPieAnimationParams {
+    growField?: 'angle' | 'radius';
+    growFrom: (datum: Datum, element: IElement, state: AnimationStateEnum) => number;
+}
+export type PieAppearPreset = 'growAngle' | 'growRadius' | 'fadeIn';
+export declare function pieGrowOption(pieParams: IPieAnimationParams, isOverall: boolean, state: AnimationStateEnum): (datum: Datum, element: IElement, params: AnimationStateEnum) => {
+    overall: number;
+} | {
+    overall: boolean;
+};
+export declare const Appear_Grow: (params: IPieAnimationParams) => IAnimationTypeConfig;
+export declare const Appear_FadeIn: {
+    type: string;
+};
+export declare const pieEnter: (params: IPieAnimationParams) => IAnimationTypeConfig;
+export declare const pieExit: (params: IPieAnimationParams) => IAnimationTypeConfig;
+export declare const pieDisappear: (params: IPieAnimationParams) => IAnimationTypeConfig;
+export declare function piePresetAnimation(params: IPieAnimationParams, preset: PieAppearPreset | boolean): IAnimationTypeConfig | {
+    type: string;
+};

package/build/es5/series/pie/animation/centerOffset.d.ts

@@ -0,0 +1,6 @@
+import type { IAnimationTimeline, IAnimationTypeConfig } from '@visactor/vgrammar';
+import type { IArcMark } from '../../../mark/arc';
+export type ICenterOffsetAnimationOptions = {
+    distance?: number;
+};
+export declare function centerOffsetConfig(mark: IArcMark, originalConfig: IAnimationTypeConfig): IAnimationTimeline;

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

@@ -0,0 +1,64 @@
+import type { IAnimationSpec } from '../../animation/spec';
+import type { IMarkSpec, IMarkTheme } from '../../typings/spec/common';
+import type { IArcMarkSpec, ITextMarkSpec, TextAlign, IPathMarkSpec, IArc3dMarkSpec } from '../../typings/visual';
+import type { SeriesMarkNameEnum } from '../interface';
+import type { IPolarSeriesSpec, IPolarSeriesTheme } from '../polar/interface';
+import type { PieAppearPreset } from './animation/animation';
+export type PieMarks = 'pie' | 'label' | 'labelLine';
+export interface IPieSeriesSpec extends IPolarSeriesSpec, IAnimationSpec<PieMarks, PieAppearPreset> {
+    type: 'pie';
+    categoryField: string;
+    valueField: string;
+    centerX?: number;
+    centerY?: number;
+    centerOffset?: number;
+    radius?: number;
+    outerRadius?: number;
+    innerRadius?: number;
+    cornerRadius?: number;
+    startAngle?: number;
+    endAngle?: number;
+    padAngle?: number;
+    [SeriesMarkNameEnum.pie]?: IMarkSpec<IArcMarkSpec>;
+    [SeriesMarkNameEnum.label]?: IArcLabelSpec;
+}
+export interface IPieSeriesTheme extends IPolarSeriesTheme {
+    [SeriesMarkNameEnum.pie]?: Partial<IMarkTheme<IArcMarkSpec>>;
+    [SeriesMarkNameEnum.label]?: IArcLabelSpec;
+}
+export type IPie3dSeriesSpec = {
+    type: 'pie3d';
+    angle3d?: number;
+} & Omit<IPieSeriesSpec, 'type'>;
+export interface IPie3dSeriesTheme extends IPolarSeriesTheme {
+    [SeriesMarkNameEnum.pie3d]?: Partial<IMarkTheme<IArc3dMarkSpec>>;
+    [SeriesMarkNameEnum.label]?: IArcLabelSpec;
+}
+export interface IArcLabelLineSpec extends IMarkSpec<IPathMarkSpec> {
+    visible?: boolean;
+    line1MinLength?: number;
+    line2MinLength?: number;
+}
+export type ArcLabelAlignType = 'arc' | 'labelLine' | 'edge';
+export type ArcLabelStrategyType = 'priority' | 'vertical' | 'none';
+export interface IArcLabelLayoutSpec {
+    textAlign?: ArcLabelAlignType;
+    align?: ArcLabelAlignType;
+    strategy?: ArcLabelStrategyType;
+    tangentConstraint?: boolean;
+}
+export interface ILabelTextMarkSpec extends Omit<ITextMarkSpec, 'align' | 'textAlign'> {
+    textAlign?: TextAlign | 'auto';
+    align?: TextAlign | 'auto';
+}
+export interface IArcLabelSpec extends Omit<IMarkSpec<ITextMarkSpec>, 'style'> {
+    position?: 'outside' | 'inside';
+    showRule?: 'all' | 'max' | 'min' | 'minAndMax' | 'headAndTail';
+    coverEnable?: boolean;
+    rotate?: boolean;
+    spaceWidth?: number;
+    layoutArcGap?: number;
+    style?: ILabelTextMarkSpec;
+    line?: IArcLabelLineSpec;
+    layout?: IArcLabelLayoutSpec;
+}