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

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 { 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;
     static readonly mark: SeriesMarkMap;
-    protected _viewDataLabel: SeriesData;
+    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/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/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

@@ -19,7 +19,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,5 +1,5 @@
-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;

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

@@ -16,7 +16,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,5 +1,7 @@
-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;
 };
@@ -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';
@@ -20,7 +20,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/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/sankey/animation.d.ts

@@ -1,5 +1,5 @@
-import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
 import type { ISankeyAnimationParams, SankeyAppearPreset } from './interface';
+import type { IAnimationTypeConfig } from '../../animation/interface';
 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;

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> {
@@ -19,14 +18,14 @@ export declare class SankeySeries<T extends ISankeySeriesSpec = ISankeySeriesSpe
     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 +53,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 +72,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/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;

package/types/series/sunburst/animation/exit.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 sunburstExit: (params: ISunburstAnimationParams) => IAnimationTypeConfig;

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

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

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

@@ -1,3 +1,3 @@
-import type { IElement } from '@visactor/vgrammar-core';
+import type { IMarkGraphic } from '../../../mark/interface/common';
 export declare const computeRatio: (angle: number, range: [number, number]) => number;
-export declare const getInnerMostElements: (element: IElement) => IElement[];
+export declare const getInnerMostElements: (graphics: IMarkGraphic[]) => IMarkGraphic[];

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

@@ -48,7 +48,7 @@ export declare class SunburstSeries extends PolarSeries<any> {
     protected initTooltip(): void;
     initAnimation(): void;
     initEvent(): void;
-    onLayoutEnd(ctx: any): void;
+    onLayoutEnd(): void;
     private _computeRadius;
     private _computeLevel;
     getGroupFields(): string[];

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

@@ -1,4 +1,4 @@
-import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+import type { IAnimationTypeConfig } from '../../animation/interface';
 import type { TreemapAppearPreset } from './interface';
 export declare const treemapPresetAnimation: (preset: TreemapAppearPreset) => IAnimationTypeConfig;
 export declare const registerTreemapAnimation: () => void;

package/types/series/treemap/treemap.d.ts

@@ -30,7 +30,6 @@ export declare class TreemapSeries extends CartesianSeries<any> {
     private _enableAnimationHook;
     setAttrFromSpec(): void;
     initData(): void;
-    compile(): void;
     protected _runTreemapTransform(render?: boolean): void;
     protected _addDataIndexAndKey(): void;
     getRawDataStatisticsByField(field: string, isNumeric?: boolean): {
@@ -59,7 +58,7 @@ export declare class TreemapSeries extends CartesianSeries<any> {
     handleZoom(event: ZoomEventParam): void;
     getDimensionField(): string[];
     getMeasureField(): string[];
-    onLayoutEnd(ctx: any): void;
+    onLayoutEnd(): void;
     protected enableMarkAnimation(): void;
     protected disableMarkAnimation(): void;
     getDefaultShapeType(): string;

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

@@ -1,5 +1,5 @@
-import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
 import type { VennAppearPreset } from './interface';
+import type { IAnimationTypeConfig } from '../../animation/interface';
 export declare const vennCirclePresetAnimation: (preset: VennAppearPreset) => IAnimationTypeConfig;
 export declare const vennOverlapPresetAnimation: (preset: VennAppearPreset) => IAnimationTypeConfig;
 export declare const registerVennAnimation: () => void;

package/types/series/venn/venn.d.ts

@@ -24,6 +24,7 @@ export declare class VennSeries<T extends IVennSeriesSpec = IVennSeriesSpec> ext
     getValueField(): string;
     setValueField(f: string): string;
     setAttrFromSpec(): void;
+    initData(): void;
     compile(): void;
     protected _runVennTransform(render?: boolean): void;
     initMark(): void;
@@ -35,7 +36,7 @@ export declare class VennSeries<T extends IVennSeriesSpec = IVennSeriesSpec> ext
     protected initTooltip(): void;
     getDimensionField(): string[];
     getMeasureField(): string[];
-    onLayoutEnd(ctx: any): void;
+    onLayoutEnd(): void;
     getDefaultShapeType(): string;
     getActiveMarks(): IMark[];
     getStatisticFields(): {

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

@@ -1,5 +1,5 @@
-import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
 import type { IBarAnimationParams } from '../bar/interface';
 import type { WaterfallAppearPreset } from './interface';
+import type { IAnimationTypeConfig } from '../../animation/interface';
 export declare function waterfallPresetAnimation(params: IBarAnimationParams, preset: WaterfallAppearPreset): IAnimationTypeConfig;
 export declare const registerWaterfallAnimation: () => void;

package/types/series/waterfall/waterfall.d.ts

@@ -3,11 +3,11 @@ import type { IWaterfallSeriesSpec } from './interface';
 import type { SeriesMarkMap } from '../interface';
 import { SeriesTypeEnum } from '../interface/type';
 import type { ITransformOptions, DataView } from '@visactor/vdataset';
-import { SeriesData } from '../base/series-data';
 import type { IModelEvaluateOption } from '../../model/interface';
 import type { Datum } from '../../typings';
 import type { ILabelMark, IRuleMark, ITextMark } from '../../mark/interface';
 import type { ILabelInfo } from '../../component/label/interface';
+import { type ICompilableData } from '../../compile/data';
 export declare const DefaultBandWidth = 6;
 export declare class WaterfallSeries<T extends IWaterfallSeriesSpec = IWaterfallSeriesSpec> extends BarSeries<any> {
     static readonly type: string;
@@ -15,7 +15,7 @@ export declare class WaterfallSeries<T extends IWaterfallSeriesSpec = IWaterfall
     static readonly mark: SeriesMarkMap;
     static readonly transformerConstructor: any;
     readonly transformerConstructor: any;
-    protected _totalData?: SeriesData;
+    protected _totalData?: ICompilableData;
     getTotalData(): any;
     protected _spec: T;
     protected _leaderLineMark: IRuleMark;

package/types/series/word-cloud/animation.d.ts

@@ -1,5 +1,5 @@
-import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
 import type { IWordcloud3dAnimationParams, IWordcloudAnimationParams, WordcloudAppearPreset } from './interface';
+import type { IAnimationTypeConfig } from '../../animation/interface';
 export declare const WordCloud3dAnimation: (params: IWordcloud3dAnimationParams | (() => any)) => IAnimationTypeConfig;
 export declare const WordCloudScaleInAnimation: (params: IWordcloudAnimationParams) => IAnimationTypeConfig;
 export declare function wordcloudPresetAnimation(params: IWordcloudAnimationParams, preset: WordcloudAppearPreset | boolean): IAnimationTypeConfig;

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

@@ -60,7 +60,7 @@ export declare class BaseWordCloudSeries<T extends IBaseWordCloudSeriesSpec = IB
     getGroupFields(): string[];
     getStackGroupFields(): string[];
     getStackValueField(): string;
-    onLayoutEnd(ctx: any): void;
+    onLayoutEnd(): void;
     getActiveMarks(): IMark[];
     reInit(): void;
 }

package/types/series/word-cloud/interface.d.ts

@@ -3,7 +3,7 @@ import type { IAnimationSpec, IMarkAnimateSpec, IStateAnimateSpec } from '../../
 import type { SeriesMarkNameEnum } from '../interface/type';
 import type { shapes } from '@visactor/vgrammar-wordcloud';
 import type { GeometricMaskShape, TextShapeMask } from '@visactor/vgrammar-util';
-import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+import type { IAnimationTypeConfig } from '../../animation/interface';
 export interface IWordcloud3dAnimationParams {
     radius: number;
     depth_3d: number;

package/types/typings/common.d.ts

@@ -5,3 +5,16 @@ export type StringOrNumber = string | number;
 export type MaybeArray<T> = T | Array<T>;
 export type Maybe<T> = T | undefined | null;
 export type Quadrant = 1 | 2 | 3 | 4;
+export type ValueOf<T, K extends keyof T = keyof T> = T[K];
+export type DiffResult<Prev, Next> = {
+    enter: {
+        next: Next;
+    }[];
+    update: {
+        prev: Prev;
+        next: Next;
+    }[];
+    exit: {
+        prev: Prev;
+    }[];
+};

package/types/typings/spec/common.d.ts

@@ -1,10 +1,9 @@
 import type { IVChart } from './../../core/interface';
 import type { IImageMarkSpec } from '../visual';
 import type { LayoutCallBack } from '../../layout/interface';
-import type { IElement, srIOption3DType } from '@visactor/vgrammar-core';
 import type { DataSet, DataView, ISimplifyOptions, IFieldsOptions, IFilterOptions, IFoldOptions, IDsvParserOptions } from '@visactor/vdataset';
 import type { RegionSpec } from '../../region/interface';
-import type { IHoverSpec, ISelectSpec, IInteractionSpec } from '../../interaction/interface';
+import type { IHoverSpec, ISelectSpec, IInteractionSpec } from '../../interaction/interface/spec';
 import type { IRenderOption } from '../../compile/interface';
 import type { ISeriesTooltipSpec, ITooltipSpec } from '../../component/tooltip/interface';
 import type { ILayoutSpec } from '../../layout/interface';
@@ -14,7 +13,7 @@ import type { Datum, StringOrNumber } from '../common';
 import type { IInvalidType } from '../data';
 import type { IAnimationSpec, IMorphSeriesSpec } from '../../animation/spec';
 import type { IPlayer } from '../../component/player/interface';
-import type { IMarkProgressiveConfig, MarkTypeEnum } from '../../mark/interface';
+import type { IMark, IMarkProgressiveConfig, MarkTypeEnum } from '../../mark/interface';
 import type { IDataZoomSpec } from '../../component/data-zoom/data-zoom/interface';
 import type { IScrollBarSpec } from '../../component/data-zoom/scroll-bar/interface';
 import type { ICrosshairSpec } from '../../component/crosshair/interface';
@@ -24,7 +23,7 @@ import type { IBrushSpec } from '../../component/brush/interface';
 import type { ITotalLabelSpec } from '../../component/label/interface';
 import type { ILegendSpec } from '../../component/legend/interface';
 import type { ILayoutOrientPadding, ILayoutPaddingSpec } from '../layout';
-import type { IColor, ICustomPath2D, IRichTextCharacter } from '@visactor/vrender-core';
+import type { IColor, ICustomPath2D, IGraphic, IRichTextCharacter } from '@visactor/vrender-core';
 import type { ICommonAxisSpec } from '../../component/axis/interface';
 import type { IMediaQuerySpec } from './media-query';
 import type { IModelSpec } from '../../model/interface';
@@ -34,9 +33,7 @@ export interface IInitOption extends Omit<IRenderOption, 'pluginList'> {
     renderCanvas?: string | HTMLCanvasElement;
     dataSet?: DataSet;
     autoFit?: boolean;
-    performanceHook?: IPerformanceHook;
     animation?: boolean;
-    options3d?: srIOption3DType;
     layout?: LayoutCallBack;
     poptip?: boolean;
     onError?: (...args: any[]) => void;
@@ -199,8 +196,12 @@ export type IMarkStateFilter = {
     datums: Datum[];
     datumKeys: string[];
 } | {
-    items: IElement[];
-} | ((datum: Datum, options: Record<string, any>) => boolean);
+    items: IGraphic[];
+} | ((datum: Datum, options: {
+    mark?: IMark;
+    type?: string;
+    renderNode?: IGraphic;
+}) => boolean);
 export interface IMarkStateSpec<T> {
     filter?: IMarkStateFilter;
     level?: number | undefined;
@@ -224,35 +225,35 @@ export interface IPerformanceHook {
     afterCreateVChart?: (vchart?: IVChart) => void;
     beforeInitializeChart?: (vchart?: IVChart) => void;
     afterInitializeChart?: (vchart?: IVChart) => void;
-    beforeCompileToVGrammar?: () => void;
-    afterCompileToVGrammar?: () => void;
-    beforeRegionCompile?: () => void;
-    afterRegionCompile?: () => void;
-    beforeSeriesCompile?: () => void;
-    afterSeriesCompile?: () => void;
-    beforeComponentCompile?: () => void;
-    afterComponentCompile?: () => void;
-    beforeResizeWithUpdate?: () => void;
-    afterResizeWithUpdate?: () => void;
-    beforeLayoutWithSceneGraph?: () => void;
-    afterLayoutWithSceneGraph?: () => void;
-    beforeParseView?: () => void;
-    afterParseView?: () => void;
-    beforeCreateRuntime?: () => void;
-    afterCreateRuntime?: () => void;
-    beforeSrViewEvaluateAsync?: () => void;
-    afterSrViewEvaluateAsync?: () => void;
-    beforeSrViewRunAsync?: () => void;
-    afterSrViewRunAsync?: () => void;
-    beforeTransform?: (name: string) => void;
-    afterTransform?: (name: string) => void;
-    beforeCreateVRenderStage?: () => void;
-    afterCreateVRenderStage?: () => void;
-    beforeCreateVRenderMark?: () => void;
-    afterCreateVRenderMark?: () => void;
+    beforeCompileToVGrammar?: (vchart?: IVChart) => void;
+    afterCompileToVGrammar?: (vchart?: IVChart) => void;
+    beforeRegionCompile?: (vchart?: IVChart) => void;
+    afterRegionCompile?: (vchart?: IVChart) => void;
+    beforeSeriesCompile?: (vchart?: IVChart) => void;
+    afterSeriesCompile?: (vchart?: IVChart) => void;
+    beforeComponentCompile?: (vchart?: IVChart) => void;
+    afterComponentCompile?: (vchart?: IVChart) => void;
+    beforeResizeWithUpdate?: (vchart?: IVChart) => void;
+    afterResizeWithUpdate?: (vchart?: IVChart) => void;
+    beforeLayoutWithSceneGraph?: (vchart?: IVChart) => void;
+    afterLayoutWithSceneGraph?: (vchart?: IVChart) => void;
+    beforeParseView?: (vchart?: IVChart) => void;
+    afterParseView?: (vchart?: IVChart) => void;
+    beforeCreateRuntime?: (vchart?: IVChart) => void;
+    afterCreateRuntime?: (vchart?: IVChart) => void;
+    beforeSrViewEvaluateAsync?: (vchart?: IVChart) => void;
+    afterSrViewEvaluateAsync?: (vchart?: IVChart) => void;
+    beforeSrViewRunAsync?: (vchart?: IVChart) => void;
+    afterSrViewRunAsync?: (vchart?: IVChart) => void;
+    beforeTransform?: (name: string, vchart?: IVChart) => void;
+    afterTransform?: (name: string, vchart?: IVChart) => void;
+    beforeCreateVRenderStage?: (vchart?: IVChart) => void;
+    afterCreateVRenderStage?: (vchart?: IVChart) => void;
+    beforeCreateVRenderMark?: (vchart?: IVChart) => void;
+    afterCreateVRenderMark?: (vchart?: IVChart) => void;
     beforeDoRender?: (vchart?: IVChart) => void;
-    beforeVRenderDraw?: () => void;
-    afterVRenderDraw?: () => void;
+    beforeVRenderDraw?: (vchart?: IVChart) => void;
+    afterVRenderDraw?: (vchart?: IVChart) => void;
 }
 export type IBuildinMarkSpec = {
     group: IGroupMarkSpec;

package/types/typings/visual.d.ts

@@ -5,7 +5,7 @@ import type { InterpolateType } from './interpolate';
 import type { ScaleType } from './scale';
 import type { ShapeType } from './shape';
 import type { IPoint } from './coordinate';
-import type { IAttributeOpt, IModelMarkAttributeContext } from '../compile/mark/interface';
+import type { IModelMarkAttributeContext } from '../compile/mark/interface';
 import type { Datum } from './common';
 import type { IPadding } from '@visactor/vutils';
 import type { IColorKey } from '../theme/color-scheme/interface';
@@ -18,6 +18,7 @@ export interface IVisualSpecBase<D, T> {
     specified?: {
         [key: string]: unknown;
     };
+    clamp?: boolean;
 }
 export interface IVisualSpecStyle<D, T> extends IVisualSpecBase<D, T> {
     field?: string;
@@ -36,7 +37,7 @@ export interface IVisualScale {
     field?: string;
     changeDomain?: 'none' | 'replace' | 'expand';
 }
-export type FunctionType<T> = (datum: Datum, context: IModelMarkAttributeContext, opt?: IAttributeOpt, source?: DataView) => T;
+export type FunctionType<T> = (datum: Datum, context: IModelMarkAttributeContext, source?: DataView) => T;
 export type ValueType<T> = T;
 export type VisualType<T> = ValueType<T> | FunctionType<T> | IVisual<unknown, T>;
 export type TextureType = 'circle' | 'dimond' | 'rect' | 'vertical-line' | 'horizontal-line' | 'bias-lr' | 'bias-rl' | 'grid';
@@ -132,10 +133,16 @@ export interface ITextMarkSpec extends IFillMarkSpec {
     ellipsis?: string;
     suffixPosition?: 'start' | 'end' | 'middle';
     underline?: boolean;
+    underlineDash?: number[];
+    underlineOffset?: number;
     lineThrough?: boolean;
     lineHeight?: number | string | ITokenKey;
     poptip?: PopTipAttributes;
     direction?: 'horizontal' | 'vertical';
+    wordBreak?: 'break-word' | 'break-all' | 'keep-all';
+    heightLimit?: number;
+    lineClamp?: number;
+    whiteSpace?: 'normal' | 'no-wrap';
 }
 export type IRichTextMarkSpec = IRichTextAttribute & IFillMarkSpec & {
     type: 'rich';

package/types/util/array.d.ts

@@ -1,4 +1,5 @@
 import { array, last as peek, maxInArray as maxInArr, minInArray as minInArr } from '@visactor/vutils';
 export declare function shallowCompare<T, U>(arrA: T | T[], arrB: U | U[]): boolean;
 export declare function combineDomains(domains: number[][]): number[];
+export declare function moveAfterInArray<T>(array: T[], target: T, ref: T): void;
 export { array, peek, maxInArr, minInArr };

package/types/util/index.d.ts

@@ -17,6 +17,7 @@ export * from './text';
 export * from './data';
 export * from './hierarchy';
 export * from './style';
+export * from './mark';
 export declare const Utils: {
     TimeUtil: typeof TimeUtil;
 };

package/types/util/mark.d.ts

@@ -0,0 +1,5 @@
+import type { IGraphic } from '@visactor/vrender-core';
+import type { IMarkGraphic } from '../mark/interface/common';
+export declare const isCollectionMark: (type: string) => boolean;
+export declare const getDatumOfGraphic: (g: IMarkGraphic) => import("../typings").Datum;
+export declare const findMarkGraphic: (rootGroup: IGraphic, target: IGraphic) => IGraphic<Partial<import("@visactor/vrender-core").IGraphicAttribute>>;

package/types/util/math.d.ts

@@ -23,5 +23,5 @@ export declare function radiusLabelOrientAttribute(angle: number): {
 };
 export declare function vectorAngle(v1: IPoint, v2: IPoint): number;
 export declare function distance(p1: IPoint, p2?: IPoint): number;
-export declare function getPercentValue(valueList: number[], precision?: number): number[] | 0;
+export declare function getPercentValue(valueList: number[], precision?: number): 0 | number[];
 export declare function isValidPoint(p: IPoint): boolean;