@visactor/vchart-types 1.15.5-alpha.8 → 2.0.0-alpha.1

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

@@ -26,4 +26,14 @@ export interface IMapSeriesTheme {
     }>;
     area?: Partial<IMarkTheme<Omit<IPathMarkSpec, 'smoothScale'>>>;
 }
+export interface GeometryData {
+    type: 'Point' | 'MultiPoint' | 'LineString' | 'MultiLineString' | 'Polygon' | 'MultiPolygon' | 'GeometryCollection';
+    coordinates?: [number, number] | [number, number][] | [number, number][][] | [number, number][][][];
+    arcs?: number[][];
+}
+export interface FeatureData {
+    type: 'Feature';
+    geometry: GeometryData;
+    properties?: Record<string, any>;
+}
 export {};

package/types/series/map/map.d.ts

@@ -11,6 +11,9 @@ export declare class MapSeries<T extends IMapSeriesSpec = IMapSeriesSpec> extend
     static readonly type: string;
     type: SeriesTypeEnum;
     static readonly mark: SeriesMarkMap;
+    static readonly builtInTheme: {
+        map: import("./interface").IMapSeriesTheme;
+    };
     static readonly transformerConstructor: any;
     readonly transformerConstructor: typeof MapSeriesSpecTransformer;
     map: string;

package/types/series/mixin/line-mixin.d.ts

@@ -1,12 +1,12 @@
 import type { ISeriesOption } from '../interface/common';
 import type { ISeries } from '../interface/series';
-import type { ICompileMarkConfig, IMark, IMarkProgressiveConfig, ILabelMark, ILineMark, ISymbolMark, ITextMark } from '../../mark/interface';
+import type { ICompileMarkConfig, IMark, ILabelMark, ILineMark, ISymbolMark, ITextMark } from '../../mark/interface';
 import type { DirectionType, IInvalidType, InterpolateType, Maybe, Datum, ILayoutRect } from '../../typings';
 import type { ISeriesMarkInfo, ISeriesMarkInitOption, ISeriesTooltipHelper } from '../interface';
 import type { DimensionEventParams } from '../../event/events/dimension';
 import type { IRegion } from '../../region/interface';
-import type { SeriesData } from '../base/series-data';
 import type { ILineLikeSeriesTheme } from './interface';
+import type { ICompilableData } from '../../compile/data';
 export interface LineLikeSeriesMixin extends ISeries {
     _spec: any;
     _option: ISeriesOption;
@@ -16,7 +16,7 @@ export interface LineLikeSeriesMixin extends ISeries {
     _invalidType: IInvalidType;
     _region: IRegion;
     _direction: DirectionType;
-    _data: SeriesData;
+    _data: ICompilableData;
     _lineMark: ILineMark;
     _symbolMark: ISymbolMark;
     _symbolActiveMark: ISymbolMark;
@@ -33,11 +33,11 @@ export declare class LineLikeSeriesMixin {
     addSamplingCompile(): void;
     addOverlapCompile(): void;
     reCompileSampling(): void;
-    initLineMark(progressive?: IMarkProgressiveConfig, isSeriesMark?: boolean): ILineMark;
+    initLineMark(isSeriesMark?: boolean): ILineMark;
     initLineMarkStyle(direction?: DirectionType, areaCurveType?: InterpolateType): ILineMark;
     protected _getEventElement(params: DimensionEventParams, reverse?: boolean): Datum[];
     protected _dimensionTrigger(params: DimensionEventParams): void;
-    initSymbolMark(progressive?: IMarkProgressiveConfig, isSeriesMark?: boolean): ISymbolMark;
+    initSymbolMark(isSeriesMark?: boolean): ISymbolMark;
     initSymbolMarkStyle(): ISymbolMark;
     private _initSymbolMark;
     private _initSymbolActiveMarkAlone;

package/types/series/mosaic/mosaic.d.ts

@@ -1,10 +1,12 @@
 import { BarSeries } from '../bar/bar';
 import { SeriesTypeEnum } from '../interface/type';
 import type { IMosaicSeriesSpec } from './interface';
+import type { IBarSeriesTheme } from '../bar/interface';
 export declare class MosaicSeries<T extends IMosaicSeriesSpec = IMosaicSeriesSpec> extends BarSeries<any> {
     static readonly type: string;
     type: SeriesTypeEnum;
     protected _spec: T;
+    static readonly builtInTheme: Record<string, IBarSeriesTheme>;
     static readonly transformerConstructor: any;
     readonly transformerConstructor: any;
     getStack(): boolean;

package/types/series/pictogram/pictogram.d.ts

@@ -27,6 +27,7 @@ export declare class PictogramSeries<T extends IPictogramSeriesSpec = IPictogram
     protected _pictogramMark: GroupMark;
     protected _parsedSvgResult: SVGParserResult;
     private _labelMark;
+    private _idToMark;
     setAttrFromSpec(): void;
     getDatumCenter(datum: SVGParsedElementExtend): [number, number];
     getDatumName(datum: SVGParsedElementExtend): string;
@@ -74,5 +75,6 @@ export declare class PictogramSeries<T extends IPictogramSeriesSpec = IPictogram
     getMeasureField(): string[];
     getDimensionField(): string[];
     protected _getSeriesInfo(field: string, keys: string[]): ISeriesSeriesInfo[];
+    release(): void;
 }
 export declare const registerPictogramSeries: () => void;

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

@@ -1,7 +1,7 @@
 import type { ISeriesTooltipHelper } from '../interface';
 import { BaseSeriesTooltipHelper } from '../base/tooltip-helper';
-import { TooltipHandlerParams } from '../../component';
-import { Datum } from '../../typings';
+import type { TooltipHandlerParams } from '../../component';
+import type { Datum } from '../../typings';
 export declare class PictogramSeriesTooltipHelper extends BaseSeriesTooltipHelper implements ISeriesTooltipHelper {
     dimensionTooltipTitleCallback: (datum: any) => any;
     markTooltipValueCallback: (datum: Datum, params?: TooltipHandlerParams) => any;

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

@@ -1,8 +1,9 @@
-import type { IElement, IAnimationTypeConfig } from '@visactor/vgrammar-core';
+import type { IAnimationTypeConfig } from '../../../animation/interface';
 import { AnimationStateEnum } from '../../../animation/interface';
 import type { Datum } from '../../../typings';
 import type { IPieAnimationParams, PieAppearPreset } from '../interface';
-export declare function pieGrowOption(pieParams: IPieAnimationParams, isOverall: boolean, state: AnimationStateEnum): (datum: Datum, element: IElement, params: AnimationStateEnum) => {
+import type { IMarkGraphic } from '../../../core';
+export declare function pieGrowOption(pieParams: IPieAnimationParams, isOverall: boolean, state: AnimationStateEnum): (datum: Datum, graphic: IMarkGraphic, params: AnimationStateEnum) => {
     overall: number;
 } | {
     overall: boolean;
@@ -14,9 +15,8 @@ export declare const Appear_FadeIn: {
 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 | {
+export declare function piePresetAnimation(params: IPieAnimationParams, preset: PieAppearPreset | boolean): import("../../../animation/interface").CommonAnimationConfigItem | {
     type: string;
 };
 export declare const registerPieAnimation: () => void;
 export declare const registerEmptyCircleAnimation: () => void;
-export declare const registerPie3dAnimation: () => void;

package/types/series/pie/animation/centerOffset.d.ts

@@ -1,3 +1,3 @@
-import type { IAnimationTimeline, IAnimationTypeConfig } from '@visactor/vgrammar-core';
 import type { IArcMark } from '../../../mark/interface';
+import type { IAnimationTimeline, IAnimationTypeConfig } from '../../../animation/interface';
 export declare function centerOffsetConfig(mark: IArcMark, originalConfig: IAnimationTypeConfig): IAnimationTimeline;

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

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

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

@@ -1,6 +1,6 @@
 import type { IAnimationSpec } from '../../animation/spec';
 import type { IMarkSpec, IMarkTheme } from '../../typings/spec/common';
-import type { IArcMarkSpec, ITextMarkSpec, IArc3dMarkSpec, ILineMarkSpec } from '../../typings/visual';
+import type { IArcMarkSpec, ITextMarkSpec, ILineMarkSpec } from '../../typings/visual';
 import type { SeriesMarkNameEnum } from '../interface/type';
 import type { IPolarSeriesSpec, IPolarSeriesTheme } from '../polar/interface';
 import type { ILabelSpec, IMultiLabelSpec } from '../../component/label/interface';
@@ -8,11 +8,11 @@ import type { ICustomPath2D, ILineGraphicAttribute, ITextGraphicAttribute } from
 import type { ILayoutRect, IPercent } from '../../typings/layout';
 import type { IPointLike } from '@visactor/vutils';
 import type { AnimationStateEnum } from '../../animation/interface';
-import type { IElement } from '@visactor/vgrammar-core';
 import type { Datum } from '../../typings/common';
+import type { IMarkGraphic } from '../../mark/interface';
 export interface IPieAnimationParams {
     growField?: 'angle' | 'radius';
-    growFrom: (datum: Datum, element: IElement, state: AnimationStateEnum) => number;
+    growFrom: (datum: Datum, g: IMarkGraphic, state: AnimationStateEnum) => number;
 }
 export type PieAppearPreset = 'growAngle' | 'growRadius' | 'fadeIn';
 export type PieMarks = 'pie' | 'label' | 'labelLine';
@@ -51,16 +51,6 @@ export interface IPieSeriesTheme extends IPolarSeriesTheme {
     outerLabel?: IArcLabelSpec;
     emptyCircle?: Partial<IMarkTheme<IArcMarkSpec>>;
 }
-export type IPie3dSeriesSpec = {
-    type: 'pie3d';
-    angle3d?: number;
-} & Omit<IPieSeriesSpec, 'type'>;
-export interface IPie3dSeriesTheme extends IPolarSeriesTheme {
-    [SeriesMarkNameEnum.pie3d]?: Partial<IMarkTheme<IArc3dMarkSpec>>;
-    [SeriesMarkNameEnum.label]?: IArcLabelSpec;
-    innerLabel?: IArcLabelSpec;
-    outerLabel?: IArcLabelSpec;
-}
 export interface IArcLabelLineSpec extends Omit<IMarkSpec<ILineMarkSpec>, 'customShape'> {
     visible?: boolean;
     line1MinLength?: number;

package/types/series/pie/pie.d.ts

@@ -1,20 +1,19 @@
 import type { IPoint, Datum, StateValueType } from '../../typings';
-import type { IModelLayoutOption } from '../../model/interface';
 import { PolarSeries } from '../polar/polar';
 import type { IArcMark, IMark, IPathMark, ITextMark } from '../../mark/interface';
-import { MarkTypeEnum } from '../../mark/interface/type';
 import type { IArcSeries, SeriesMarkMap } from '../interface';
-import { SeriesMarkNameEnum, SeriesTypeEnum } from '../interface/type';
-import type { IBasePieSeriesSpec, IPieSeriesSpec } from './interface';
-import { SeriesData } from '../base/series-data';
+import { SeriesTypeEnum } from '../interface/type';
+import type { IBasePieSeriesSpec, IPieSeriesSpec, IPieSeriesTheme } from './interface';
 import { PieSeriesSpecTransformer } from './pie-transformer';
+import type { ICompilableData } from '../../compile/data';
 export declare class BasePieSeries<T extends IBasePieSeriesSpec> extends PolarSeries<T> implements IArcSeries {
     static readonly transformerConstructor: any;
     readonly transformerConstructor: typeof PieSeriesSpecTransformer;
-    protected _pieMarkName: SeriesMarkNameEnum;
-    protected _pieMarkType: MarkTypeEnum;
+    protected _pieMarkName: string;
+    protected _pieMarkType: string;
     static readonly mark: SeriesMarkMap;
-    protected _viewDataLabel: SeriesData;
+    static readonly builtInTheme: Record<string, IPieSeriesTheme>;
+    protected _viewDataLabel: ICompilableData;
     getCenter: () => IPoint;
     protected _centerOffset: number;
     protected _cornerRadius: number;
@@ -37,14 +36,17 @@ export declare class BasePieSeries<T extends IBasePieSeriesSpec> extends PolarSe
     private endAngleScale;
     protected _computeLayoutRadius(): number;
     initMarkStyle(): void;
-    initInteraction(): void;
+    getInteractionTriggers(): {
+        trigger: Partial<import("../../interaction/interface/trigger").IBaseTriggerOptions>;
+        marks: IMark[];
+    }[];
     protected initTooltip(): void;
-    initMarkStyleWithSpec(mark?: IMark, spec?: any, key?: string): void;
+    initMarkStyleWithSpec(mark?: IMark, spec?: any): void;
     initLabelMarkStyle(textMark: ITextMark): void;
     afterInitMark(): void;
     initEvent(): void;
     initGroups(): void;
-    onLayoutEnd(ctx: IModelLayoutOption): void;
+    onLayoutEnd(): void;
     getDimensionField(): string[];
     getMeasureField(): string[];
     private viewDataLabelUpdate;

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

@@ -1,6 +1,6 @@
 import type { EasingType } from '@visactor/vrender-core';
 import type { IPointLike } from '@visactor/vutils';
-import { ACustomAnimate, TagPointsUpdate } from '@visactor/vrender-core';
+import { ACustomAnimate, TagPointsUpdate } from '@visactor/vrender-animate';
 export declare class PolarPointUpdate extends ACustomAnimate<{
     x: number;
     y: number;
@@ -30,9 +30,7 @@ export declare class PolarTagPointsUpdate extends TagPointsUpdate {
     private interpolatePoints;
     private _center;
     private _prevCenter;
-    constructor(from: any, to: any, duration: number, easing: EasingType, params?: {
-        newPointAnimateType?: 'grow' | 'appear';
-    });
+    onBind(): void;
     onUpdate(end: boolean, ratio: number, out: Record<string, any>): void;
     private _interpolationSinglePoint;
     private polarPointInterpolation;

package/types/series/polar/progress-like/animation.d.ts

@@ -1,4 +1,4 @@
-import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+import type { IAnimationTypeConfig } from '../../../animation/interface';
 import type { IProgressLikeAnimationParams, ProgressLikeAppearPreset } from './interface';
 export declare function progressLikePresetAnimation(params: IProgressLikeAnimationParams, preset: ProgressLikeAppearPreset): IAnimationTypeConfig;
 export declare const registerProgressLikeAnimation: () => void;

package/types/series/polar/progress-like/interface.d.ts

@@ -17,6 +17,7 @@ export interface IProgressLikeSeriesSpec extends IPolarSeriesSpec {
     roundCap?: boolean | [boolean, boolean];
     cornerRadius?: number;
     tickMask?: Omit<IMarkSpec<IArcMarkSpec>, 'state'> & ITickMaskSpec;
+    clamp?: boolean;
 }
 export interface IProgressLikeSeriesTheme extends IPolarSeriesTheme {
     roundCap?: boolean | [boolean, boolean];

package/types/series/polar/progress-like/progress-like.d.ts

@@ -1,6 +1,5 @@
-import type { Datum } from '@visactor/vgrammar-core';
 import type { IGroupMark, IMarkStyle } from '../../../mark/interface';
-import type { ConvertToMarkStyleSpec, ICommonSpec } from '../../../typings';
+import type { ConvertToMarkStyleSpec, Datum, ICommonSpec } from '../../../typings';
 import { PolarSeries } from '../polar';
 import type { IContinuousTickData, IProgressLikeSeriesSpec } from './interface';
 import type { IPolarAxis } from '../../../component/axis';

package/types/series/progress/circular/circular.d.ts

@@ -9,6 +9,9 @@ export declare class CircularProgressSeries<T extends ICircularProgressSeriesSpe
     static readonly type: string;
     type: SeriesTypeEnum;
     static readonly mark: SeriesMarkMap;
+    static readonly builtInTheme: {
+        circularProgress: import("./interface").ICircularProgressSeriesTheme;
+    };
     static readonly transformerConstructor: any;
     readonly transformerConstructor: typeof CircularProgressSeriesSpecTransformer;
     private _progressMark;
@@ -19,7 +22,10 @@ export declare class CircularProgressSeries<T extends ICircularProgressSeriesSpe
     initMarkStyle(): void;
     private _initProgressMark;
     private _initProgressMarkStyle;
-    initInteraction(): void;
+    getInteractionTriggers(): {
+        trigger: Partial<import("../../../interaction/interface/trigger").IBaseTriggerOptions>;
+        marks: IMark[];
+    }[];
     protected initTooltip(): void;
     private _initTrackMark;
     private _initTrackMarkStyle;

package/types/series/progress/linear/animation.d.ts

@@ -1,6 +1,6 @@
-import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
 import type { ILinearProgressAnimationParams, LinearProgressAppearPreset } from './interface';
+import type { IAnimationTypeConfig } from '../../../animation/interface';
 export declare const linearProgressDisappear: (params: ILinearProgressAnimationParams) => IAnimationTypeConfig;
 export declare const Appear_FadeIn: IAnimationTypeConfig;
-export declare function linearProgressPresetAnimation(params: ILinearProgressAnimationParams, preset: LinearProgressAppearPreset | boolean): IAnimationTypeConfig;
+export declare function linearProgressPresetAnimation(params: ILinearProgressAnimationParams, preset?: LinearProgressAppearPreset | boolean): IAnimationTypeConfig;
 export declare const registerLinearProgressAnimation: () => void;

package/types/series/progress/linear/interface.d.ts

@@ -14,6 +14,7 @@ export interface ILinearProgressSeriesSpec extends IProgressSeriesSpec, IAnimati
     yField: string | string[];
     direction?: DirectionType;
     bandWidth?: number;
+    clamp?: boolean;
     [SeriesMarkNameEnum.progress]?: IMarkSpec<IRectMarkSpec> & {
         topPadding?: number;
         bottomPadding?: number;

package/types/series/progress/linear/linear.d.ts

@@ -7,6 +7,9 @@ export declare class LinearProgressSeries<T extends ILinearProgressSeriesSpec =
     static readonly type: string;
     type: SeriesTypeEnum;
     static readonly mark: SeriesMarkMap;
+    static readonly builtInTheme: {
+        linearProgress: import("./interface").ILinearProgressSeriesTheme;
+    };
     private _progressMark;
     private _trackMark;
     initMark(): void;
@@ -16,7 +19,10 @@ export declare class LinearProgressSeries<T extends ILinearProgressSeriesSpec =
     private _defaultProgressCustomShape;
     private _initTrackMark;
     private _initTrackMarkStyle;
-    initInteraction(): void;
+    getInteractionTriggers(): {
+        trigger: Partial<import("../../../interaction/interface/trigger").IBaseTriggerOptions>;
+        marks: IMark[];
+    }[];
     initAnimation(): void;
     protected initTooltip(): void;
     getActiveMarks(): IMark[];

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

@@ -1,12 +1,14 @@
-import type { Datum, IAnimationTypeConfig, IElement } from '@visactor/vgrammar-core';
+import type { IGraphic } from '@visactor/vrender-core';
 import type { IRadarAnimationParams, RadarAppearPreset } from './interface';
+import type { IAnimationTypeConfig } from '../../animation/interface';
+import type { Datum } from '../../typings/common';
 export declare const radarFadeAnimation: (animationType: 'in' | 'out') => {
     type: string;
 };
 export declare const radarGrowAnimation: (params: IRadarAnimationParams, animationType: 'in' | 'out') => {
     type: string;
     options: () => {
-        center: import("../../typings").IPoint;
+        center: import("../..").IPoint;
     };
 };
 export declare function radarPresetAnimation(params: IRadarAnimationParams, preset: RadarAppearPreset, animationType: 'in' | 'out'): {
@@ -16,21 +18,21 @@ export declare const radarSymbolMoveAnimation: (params: IRadarAnimationParams, a
     channel: {
         x: {
             from: () => number;
-            to: (datum: Datum, element: IElement) => any;
+            to: (datum: Datum, element: IGraphic) => any;
         };
         y: {
             from: () => number;
-            to: (datum: Datum, element: IElement) => any;
+            to: (datum: Datum, element: IGraphic) => any;
         };
     };
 } | {
     channel: {
         x: {
-            from: (datum: Datum, element: IElement) => any;
+            from: (datum: Datum, element: IGraphic) => any;
             to: () => number;
         };
         y: {
-            from: (datum: Datum, element: IElement) => any;
+            from: (datum: Datum, element: IGraphic) => any;
             to: () => number;
         };
     };
@@ -41,21 +43,21 @@ export declare function radarSymbolPresetAnimation(params: IRadarAnimationParams
     channel: {
         x: {
             from: () => number;
-            to: (datum: any, element: IElement) => any;
+            to: (datum: Datum, element: IGraphic<Partial<import("@visactor/vrender-core").IGraphicAttribute>>) => any;
         };
         y: {
             from: () => number;
-            to: (datum: any, element: IElement) => any;
+            to: (datum: Datum, element: IGraphic<Partial<import("@visactor/vrender-core").IGraphicAttribute>>) => any;
         };
     };
 } | {
     channel: {
         x: {
-            from: (datum: any, element: IElement) => any;
+            from: (datum: Datum, element: IGraphic<Partial<import("@visactor/vrender-core").IGraphicAttribute>>) => any;
             to: () => number;
         };
         y: {
-            from: (datum: any, element: IElement) => any;
+            from: (datum: Datum, element: IGraphic<Partial<import("@visactor/vrender-core").IGraphicAttribute>>) => any;
             to: () => number;
         };
     };

package/types/series/radar/radar.d.ts

@@ -1,5 +1,5 @@
 import { LineLikeSeriesMixin } from '../mixin/line-mixin';
-import type { IMark, IMarkProgressiveConfig } from '../../mark/interface';
+import type { IMark } from '../../mark/interface';
 import type { Datum } from '../../typings';
 import type { SeriesMarkMap } from '../interface';
 import { SeriesTypeEnum } from '../interface/type';
@@ -12,6 +12,9 @@ export declare class RadarSeries<T extends IRadarSeriesSpec = IRadarSeriesSpec>
     static readonly type: string;
     type: SeriesTypeEnum;
     static readonly mark: SeriesMarkMap;
+    static readonly builtInTheme: {
+        radar: import("./interface").IRadarSeriesTheme;
+    };
     static readonly transformerConstructor: any;
     readonly transformerConstructor: typeof LineLikeSeriesSpecTransformer;
     private _areaMark;
@@ -20,7 +23,7 @@ export declare class RadarSeries<T extends IRadarSeriesSpec = IRadarSeriesSpec>
     compile(): void;
     initMark(): void;
     initMarkStyle(): void;
-    initAreaMark(progressive: IMarkProgressiveConfig, isSeriesMark: boolean): void;
+    initAreaMark(isSeriesMark: boolean): void;
     initAreaMarkStyle(): void;
     protected initTooltip(): void;
     initAnimation(): void;

package/types/series/range-column/animation.d.ts

@@ -1,4 +1,4 @@
-import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+import type { IAnimationTypeConfig } from '../../animation/interface';
 import type { IRangeColumnAnimationParams, RangeColumnAppearPreset } from './interface';
 export declare const rangeColumnGrowIn: (params: IRangeColumnAnimationParams) => IAnimationTypeConfig;
 export declare const rangeColumnGrowOut: (params: IRangeColumnAnimationParams) => IAnimationTypeConfig;

package/types/series/range-column/constant.d.ts

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

package/types/series/range-column/interface.d.ts

@@ -54,7 +54,4 @@ export interface IRangeColumnSeriesTheme extends ICartesianSeriesTheme {
         }>;
     };
 }
-export interface IRangeColumn3dSeriesSpec extends Omit<IRangeColumnSeriesSpec, 'type'> {
-    type: 'rangeColumn3d';
-}
 export {};

package/types/series/range-column/range-column.d.ts

@@ -1,18 +1,19 @@
 import { BarSeries } from '../bar/bar';
-import { MarkTypeEnum } from '../../mark/interface/type';
 import type { SeriesMarkMap } from '../interface';
-import { SeriesTypeEnum } from '../interface/type';
 import type { Datum } from '../../typings';
 import type { IRangeColumnSeriesSpec } from './interface';
 import type { ITextMark } from '../../mark/interface';
 export declare const DefaultBandWidth = 6;
 export declare class RangeColumnSeries<T extends IRangeColumnSeriesSpec = IRangeColumnSeriesSpec> extends BarSeries<any> {
     static readonly type: string;
-    type: SeriesTypeEnum;
-    protected _barMarkType: MarkTypeEnum;
+    type: string;
+    protected _barMarkType: string;
     protected _barName: string;
     protected _spec: T;
     static readonly mark: SeriesMarkMap;
+    static readonly builtInTheme: {
+        rangeColumn: import("./interface").IRangeColumnSeriesTheme;
+    };
     static readonly transformerConstructor: any;
     readonly transformerConstructor: any;
     private _minLabelMark?;

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

@@ -1,5 +1,5 @@
-import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
 import type { IRoseAnimationParams, RoseAppearPreset } from './interface';
+import type { IAnimationTypeConfig } from '../../animation/interface';
 export declare const Appear_Grow: (params: IRoseAnimationParams) => IAnimationTypeConfig;
 export declare const Appear_FadeIn: IAnimationTypeConfig;
 export declare const roseEnter: (params: IRoseAnimationParams) => IAnimationTypeConfig;

package/types/series/rose/rose.d.ts

@@ -9,6 +9,9 @@ export declare class RoseSeries<T extends IRoseSeriesSpec = IRoseSeriesSpec> ext
     static readonly type: string;
     type: SeriesTypeEnum;
     static readonly mark: SeriesMarkMap;
+    static readonly builtInTheme: {
+        rose: import("./interface").IRoseSeriesTheme;
+    };
     static readonly transformerConstructor: any;
     readonly transformerConstructor: typeof RoseSeriesSpecTransformer;
     private _roseMark;

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

@@ -1,7 +1,20 @@
-import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
 import type { ISankeyAnimationParams, SankeyAppearPreset } from './interface';
+import type { IAnimationTypeConfig } from '../../animation/interface';
+import { ACustomAnimate } from '@visactor/vrender-animate';
 export declare const sankeyGrowIn: (params: ISankeyAnimationParams, isOverall?: boolean) => IAnimationTypeConfig;
 export declare const sankeyGrowOut: (params: ISankeyAnimationParams, isOverall?: boolean) => IAnimationTypeConfig;
 export declare const sankeyNodePresetAnimation: (params: ISankeyAnimationParams, preset: SankeyAppearPreset) => IAnimationTypeConfig;
 export declare const sankeyLinkPresetAnimation: (preset: SankeyAppearPreset) => IAnimationTypeConfig;
+export declare class LinkPathGrowIn extends ACustomAnimate<Record<string, number>> {
+    onBind(): void;
+    onUpdate(end: boolean, ratio: number, out: Record<string, any>): void;
+}
+export declare class LinkPathGrowOut extends ACustomAnimate<Record<string, number>> {
+    onBind(): void;
+    onUpdate(end: boolean, ratio: number, out: Record<string, any>): void;
+}
+export declare class LinkPathUpdate extends ACustomAnimate<Record<string, number>> {
+    onBind(): void;
+    onUpdate(end: boolean, ratio: number, out: Record<string, any>): void;
+}
 export declare const registerSankeyAnimation: () => void;

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

@@ -15,7 +15,6 @@ export type ISankeyLabelSpec = ILabelSpec & {
     limit?: number;
 };
 export interface ISankeySeriesSpec extends Omit<ISeriesSpec, 'data'>, IAnimationSpec<SankeyMark, SankeyAppearPreset> {
-    nameKey: any;
     type: 'sankey';
     categoryField: string;
     valueField: string;

package/types/series/sankey/sankey.d.ts

@@ -2,11 +2,10 @@ import { CartesianSeries } from '../cartesian/cartesian';
 import type { SeriesMarkMap } from '../interface';
 import { SeriesTypeEnum } from '../interface/type';
 import type { Datum, StringOrNumber } from '../../typings';
-import { SeriesData } from '../base/series-data';
+import { DataView } from '@visactor/vdataset';
 import type { ISankeySeriesSpec } from './interface';
 import type { ExtendEventParam } from '../../event/interface';
-import type { IElement, IGlyphElement, IMark as IVgrammarMark } from '@visactor/vgrammar-core';
-import type { IMark, ITextMark } from '../../mark/interface';
+import type { IMark, IMarkGraphic, ITextMark } from '../../mark/interface';
 import { SankeySeriesSpecTransformer } from './sankey-transformer';
 import type { ILabelSpec } from '../../component';
 export declare class SankeySeries<T extends ISankeySeriesSpec = ISankeySeriesSpec> extends CartesianSeries<T> {
@@ -15,18 +14,21 @@ export declare class SankeySeries<T extends ISankeySeriesSpec = ISankeySeriesSpe
     static readonly transformerConstructor: any;
     readonly transformerConstructor: typeof SankeySeriesSpecTransformer;
     static readonly mark: SeriesMarkMap;
+    static readonly builtInTheme: {
+        sankey: import("./interface").ISankeySeriesTheme;
+    };
     private _nodeMark;
     private _linkMark;
     private _nodeLayoutZIndex;
     private _labelLayoutZIndex;
-    protected _nodesSeriesData?: SeriesData;
-    protected _linksSeriesData?: SeriesData;
+    protected _nodesSeriesData?: DataView;
+    protected _linksSeriesData?: DataView;
     private _viewBox;
     protected _categoryField: string;
     private _colorScale;
     private _nodeList;
     private _needClear;
-    get direction(): "vertical" | "horizontal";
+    get direction(): "horizontal" | "vertical";
     getCategoryField(): string;
     setCategoryField(f: string): string;
     protected _valueField: string;
@@ -54,11 +56,11 @@ export declare class SankeySeries<T extends ISankeySeriesSpec = ISankeySeriesSpe
     private linksSeriesDataUpdate;
     protected _handleEmphasisElement: (params: ExtendEventParam) => void;
     protected _handleClearEmpty: () => void;
-    protected _handleNodeAdjacencyClick: (element: IElement) => void;
-    protected _handleLinkAdjacencyClick: (element: IGlyphElement) => void;
-    protected _handleNodeRelatedClick: (element: IElement) => void;
-    protected _handleLinkRelatedClick: (element: IGlyphElement) => void;
-    protected _highLightElements(vGrammarElements: IVgrammarMark['elements'], highlightNodes: string[]): void;
+    protected _handleNodeAdjacencyClick: (graphic: IMarkGraphic) => void;
+    protected _handleLinkAdjacencyClick: (graphic: IMarkGraphic) => void;
+    protected _handleNodeRelatedClick: (graphic: IMarkGraphic) => void;
+    protected _handleLinkRelatedClick: (graphic: IMarkGraphic) => void;
+    protected _highLightElements(graphics: IMarkGraphic[], highlightNodes: string[]): void;
     protected initTooltip(): void;
     _setNodeOrdinalColorScale(): void;
     getNodeList(): any;
@@ -73,7 +75,7 @@ export declare class SankeySeries<T extends ISankeySeriesSpec = ISankeySeriesSpe
         max?: number;
     };
     private _collectByField;
-    onLayoutEnd(ctx: any): void;
+    onLayoutEnd(): void;
     getDefaultShapeType(): string;
     protected _noAnimationDataKey(datum: Datum, index: number): unknown | undefined;
     getActiveMarks(): IMark[];

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

@@ -1,6 +1,6 @@
 import type { ISeriesTooltipHelper } from '../interface';
 import { BaseSeriesTooltipHelper } from '../base/tooltip-helper';
-import type { Datum } from '@visactor/vgrammar-core';
+import type { Datum } from '../../typings/common';
 export declare class SankeySeriesTooltipHelper extends BaseSeriesTooltipHelper implements ISeriesTooltipHelper {
     protected _getDimensionData: (datum: any) => any;
     markTooltipValueCallback: (datum: Datum) => string | undefined;

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

@@ -1,4 +1,4 @@
-import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
 import type { IScatterAnimationParams, ScatterAppearPreset } from './interface';
+import type { IAnimationTypeConfig } from '../../animation/interface';
 export declare const scatterPresetAnimation: (_params: IScatterAnimationParams, preset: ScatterAppearPreset) => IAnimationTypeConfig;
 export declare const registerScatterAnimation: () => void;

package/types/series/scatter/scatter.d.ts

@@ -10,6 +10,9 @@ export declare class ScatterSeries<T extends IScatterSeriesSpec = IScatterSeries
     static readonly type: string;
     type: SeriesTypeEnum;
     static readonly mark: SeriesMarkMap;
+    static readonly builtInTheme: {
+        scatter: import("./interface").IScatterSeriesTheme;
+    };
     static readonly transformerConstructor: any;
     readonly transformerConstructor: typeof ScatterSeriesSpecTransformer;
     private _symbolMark;

package/types/series/sunburst/animation/enter.d.ts

@@ -1,3 +1,3 @@
-import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
 import type { ISunburstAnimationParams } from './interface';
+import type { IAnimationTypeConfig } from '../../../animation/interface';
 export declare const sunburstEnter: (params: ISunburstAnimationParams) => IAnimationTypeConfig;