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

package/types/mark/index.d.ts

@@ -5,17 +5,20 @@ import { RuleMark, registerRuleMark } from './rule';
 import { TextMark, registerTextMark } from './text';
 import { AreaMark, registerAreaMark } from './area';
 import { RectMark, registerRectMark } from './rect';
-import { Rect3dMark, registerRect3dMark } from './rect-3d';
 import { PathMark, registerPathMark } from './path';
-import { ArcMark, registerArcMark } from './arc';
-import { Arc3dMark, registerArc3dMark } from './arc-3d';
+import { ArcMark, BaseArcMark, registerArcMark } from './arc';
 import { ComponentMark, registerComponentMark } from './component';
 import { RippleMark, registerRippleMark } from './ripple';
 import { BaseMark } from './base';
 import { PolygonMark, registerPolygonMark } from './polygon/polygon';
-import { Pyramid3dMark, registerPyramid3dMark } from './polygon/pyramid-3d';
 import { ImageMark, registerImageMark } from './image';
-export type { IBoxPlotMarkSpec, ILineMarkSpec, ISymbolMarkSpec, IGroupMarkSpec, IRuleMarkSpec, ITextMarkSpec, IAreaMarkSpec, IRect3dMarkSpec, IRectMarkSpec, IPathMarkSpec, IArcMarkSpec, IArc3dMarkSpec, ICommonSpec, IPolygonMarkSpec, IPyramid3dMarkSpec, ILinkPathMarkSpec, IRippleMarkSpec, ICellMarkSpec, ILiquidMarkSpec, ConvertToMarkStyleSpec } from '../typings/visual';
-export { LineMark, SymbolMark, GroupMark, RuleMark, TextMark, AreaMark, Rect3dMark, RectMark, PathMark, Arc3dMark, ArcMark, ComponentMark, PolygonMark, Pyramid3dMark, RippleMark, ImageMark, BaseMark };
-export { registerLineMark, registerSymbolMark, registerGroupMark, registerRuleMark, registerTextMark, registerAreaMark, registerRectMark, registerRect3dMark, registerPathMark, registerArcMark, registerArc3dMark, registerPolygonMark, registerPyramid3dMark, registerRippleMark, registerImageMark, registerComponentMark };
+import { registerMarkFilterTransform } from './transform/filter';
+import { registerMarkMapTransform } from './transform/map';
+import { BasePolygonMark } from './polygon/base-polygon';
+import { MarkTypeEnum } from './interface/type';
+export type { IBoxPlotMarkSpec, ILineMarkSpec, ISymbolMarkSpec, IGroupMarkSpec, IRuleMarkSpec, ITextMarkSpec, IAreaMarkSpec, IRectMarkSpec, IPathMarkSpec, IArcMarkSpec, ICommonSpec, IPolygonMarkSpec, ILinkPathMarkSpec, IRippleMarkSpec, ICellMarkSpec, ILiquidMarkSpec, ConvertToMarkStyleSpec } from '../typings/visual';
+export type { IMarkRaw, IMark, IMarkStyle } from './interface/common';
+export type { ITextMark, ILabelMark, IRectMark, IRuleMark, IImageMark, IGroupMark } from './interface/mark';
+export { MarkTypeEnum, LineMark, SymbolMark, GroupMark, RuleMark, TextMark, AreaMark, RectMark, PathMark, BaseArcMark, ArcMark, ComponentMark, BasePolygonMark, PolygonMark, RippleMark, ImageMark, BaseMark };
+export { registerLineMark, registerSymbolMark, registerGroupMark, registerRuleMark, registerTextMark, registerAreaMark, registerRectMark, registerPathMark, registerArcMark, registerPolygonMark, registerRippleMark, registerImageMark, registerComponentMark, registerMarkMapTransform, registerMarkFilterTransform };
 export declare const registerAllMarks: () => void;

package/types/mark/interface/common.d.ts

@@ -2,11 +2,12 @@ import type { IGlobalScale } from '../../scale/interface';
 import type { ICommonSpec, VisualType, ValueType, FunctionType } from '../../typings/visual';
 import type { IModel } from '../../model/interface';
 import type { IBaseScale } from '@visactor/vscale';
-import type { MarkType } from './type';
-import type { ICompilableMark, ICompilableMarkOption, IModelMarkAttributeContext, StateValueType } from '../../compile/mark/interface';
-import type { StringOrNumber } from '../../typings';
-import type { IMarkConfig } from '@visactor/vgrammar-core';
-import type { ICustomPath2D } from '@visactor/vrender-core';
+import type { MarkType, MarkTypeEnum } from './type';
+import type { ICompilableMark, ICompilableMarkOption, IMarkConfig, IModelMarkAttributeContext, StateValueType } from '../../compile/mark/interface';
+import type { Datum, StringOrNumber } from '../../typings';
+import type { IGraphic } from '@visactor/vrender-core';
+import type { IGroupMark } from './mark';
+import type { IAnimationConfig } from '../../animation/interface';
 export interface VisualScaleType {
     scale: IBaseScale;
     field: StringOrNumber;
@@ -33,22 +34,71 @@ export type IMarkStateStyle<T extends ICommonSpec> = Record<StateValueType, Part
 export type IMarkStyle<T extends ICommonSpec> = {
     [key in keyof T]: MarkInputStyle<T[key]>;
 };
+export type DiffStateValues = 'update' | 'enter' | 'exit';
+export type AnimationStateValues = 'appear' | 'enter' | 'update' | 'exit' | 'disappear';
+export interface IGraphicContext {
+    markType: MarkTypeEnum;
+    markId: number;
+    modelId: number;
+    markUserId?: number | string;
+    modelUserId?: number | string;
+    diffState?: DiffStateValues;
+    reusing?: boolean;
+    lastAttrs?: Record<string, any>;
+    indexKey?: string;
+    diffAttrs?: Record<string, any>;
+    finalAttrs?: Record<string, any>;
+    fieldX?: string[];
+    originalFieldX?: string[];
+    fieldY?: string[];
+    originalFieldY?: string[];
+    animationState?: AnimationStateValues;
+    data?: Datum[];
+    uniqueKey?: string;
+    key?: string;
+    groupKey?: string;
+    states?: string[];
+    graphicCount?: number;
+    graphicIndex?: number;
+    stateAnimateConfig?: IAnimationConfig | IAnimationConfig[];
+}
+export interface IMarkGraphic extends IGraphic {
+    runtimeStateCache?: Record<string, any>;
+    context?: IGraphicContext;
+    isExiting?: boolean;
+}
 export interface IMarkRaw<T extends ICommonSpec> extends ICompilableMark {
     readonly stateStyle: IMarkStateStyle<T>;
-    getAttribute: <U extends keyof T>(key: U, datum: any, state?: StateValueType, opt?: any) => unknown;
+    getAttributesOfState: (datum: Datum, state?: StateValueType) => Partial<T>;
+    getAttribute: <U extends keyof T>(key: U, datum: any, state?: StateValueType) => unknown;
     setAttribute: <U extends keyof T>(attr: U, style: StyleConvert<T[U]>, state?: StateValueType, level?: number) => void;
     setStyle: (style: Partial<IMarkStyle<T>>, state?: StateValueType, level?: number) => void;
-    setReferer: (mark: IMarkRaw<T>, styleKey?: string, state?: StateValueType, stateStyle?: IMarkStateStyle<T>) => void;
-    initStyleWithSpec: (spec: any, key?: string) => void;
+    setSimpleStyle: (s: T) => void;
+    getSimpleStyle: () => T;
+    setReferer: (mark: IMarkRaw<T>, styleKey?: string, state?: StateValueType) => void;
+    initStyleWithSpec: (spec: any) => void;
     created: () => void;
     setPostProcess: <U extends keyof T, A>(key: U, postProcessFunc: IAttrConfig<A, T>['postProcess'], state?: StateValueType) => void;
+    updateMarkState: (key: string) => void;
+    render: () => void;
+    getGraphics: () => IMarkGraphic[];
+    reuse: (mark: IMark) => void;
+    prepareMorph: (mark: IMark) => void;
+    clearExitGraphics: () => void;
+    isProgressive: () => boolean;
+    isDoingProgressive: () => boolean;
+    clearProgressive: () => void;
+    restartProgressive: () => void;
+    renderProgressive: () => void;
+    canAnimateAfterProgressive: () => boolean;
+    updateAnimationState: (callback: (graphic: IMarkGraphic) => AnimationStateValues) => void;
+    runAnimation: () => void;
 }
 export type IMark = IMarkRaw<ICommonSpec>;
 export interface ICompileMarkConfig extends IMarkConfig {
     morph?: boolean;
     morphElementKey?: string;
     support3d?: boolean;
-    setCustomizedShape?: (datum: any[], attrs: any, path: ICustomPath2D) => ICustomPath2D;
     clip?: boolean;
     skipTheme?: boolean;
 }
@@ -59,6 +109,7 @@ export interface IMarkOption extends ICompilableMarkOption {
     seriesId?: number;
     componentType?: string;
     attributeContext?: IModelMarkAttributeContext;
+    parent?: IGroupMark | false;
 }
 export interface IMarkConstructor {
     type: MarkType;
@@ -85,3 +136,24 @@ export interface IMarkOverlap {
     pointDisMul?: number;
     markOverlap?: boolean;
 }
+export type GroupedData<T> = {
+    keys: string[];
+    data: Map<string, T[]>;
+};
+export interface IProgressiveTransformResult<Output = any> {
+    unfinished: () => boolean;
+    output: () => Output;
+    progressiveOutput: () => Output;
+    progressiveRun: () => void;
+    release: () => void;
+    canAnimate?: () => boolean;
+}
+export type IMarkDataTransform<Options = any, Input = any, Output = any> = (options: Options, data: Input) => Output | IProgressiveTransformResult<Output>;
+export interface ProgressiveContext {
+    currentIndex: number;
+    totalStep: number;
+    step: number;
+    data: any[];
+    groupKeys?: string[];
+    groupedData?: Map<string, any[]>;
+}

package/types/mark/interface/enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum DiffState {
+    enter = "enter",
+    update = "update",
+    exit = "exit",
+    unChange = "unChange"
+}

package/types/mark/interface/index.d.ts

@@ -1,3 +1,4 @@
 export * from './common';
 export * from './type';
 export * from './mark';
+export * from './enum';

package/types/mark/interface/mark.d.ts

@@ -1,8 +1,23 @@
+import type { IGraphic } from '@visactor/vrender-core';
 import type { IMarkSpec } from '../../typings';
-import type { IArc3dMarkSpec, IArcMarkSpec, IAreaMarkSpec, IBoxPlotMarkSpec, ICellMarkSpec, ICommonSpec, IComposedTextMarkSpec, IGroupMarkSpec, IImageMarkSpec, ILineMarkSpec, ILinkPathMarkSpec, IPathMarkSpec, IPolygonMarkSpec, IPyramid3dMarkSpec, IRect3dMarkSpec, IRectMarkSpec, IRippleMarkSpec, IRuleMarkSpec, ISymbolMarkSpec } from '../../typings/visual';
+import type { IArcMarkSpec, IAreaMarkSpec, IBoxPlotMarkSpec, ICellMarkSpec, ICommonSpec, IComposedTextMarkSpec, IGroupMarkSpec, IImageMarkSpec, ILineMarkSpec, ILinkPathMarkSpec, IPathMarkSpec, IPolygonMarkSpec, IRectMarkSpec, IRippleMarkSpec, IRuleMarkSpec, ISymbolMarkSpec } from '../../typings/visual';
 import type { IMark, IMarkRaw } from './common';
 import type { MarkType } from './type';
-export type IComponentMark = IMarkRaw<ICommonSpec>;
+export interface IComponentMark extends IMarkRaw<ICommonSpec> {
+    renderInner: () => void;
+    getComponent: () => IGraphic;
+    clearComponent: () => void;
+    setAttributeTransform: (t: (attrs: any) => any) => any;
+}
+export interface IGlyphMark<T extends ICommonSpec = ICommonSpec, C = any> extends IMarkRaw<T> {
+    setGlyphConfig: (cfg: C) => void;
+    getGlyphConfig: () => C;
+    getSubMarks: () => Record<string, {
+        type: MarkType;
+        defaultAttributes?: any;
+    }>;
+    getPositionChannels: () => string[];
+}
 export interface ILabelMark extends ITextMark {
     skipEncode: boolean;
     getRule: () => string;
@@ -18,9 +33,7 @@ export type ITextMark = IMarkRaw<IComposedTextMarkSpec> & {
 export type ITextSpec<T> = IMarkSpec<T> & {
     textType?: 'rich' | 'text';
 };
-export type IArc3dMark = IMarkRaw<IArc3dMarkSpec>;
 export type IPolygonMark = IMarkRaw<IPolygonMarkSpec>;
-export type IPyramid3dMark = IMarkRaw<IPyramid3dMarkSpec>;
 export type IArcMark = IMarkRaw<IArcMarkSpec>;
 export type IAreaMark = IMarkRaw<IAreaMarkSpec>;
 export type IBoxPlotMark = IMarkRaw<IBoxPlotMarkSpec>;
@@ -29,7 +42,6 @@ export type IImageMark = IMarkRaw<IImageMarkSpec>;
 export type ILineMark = IMarkRaw<ILineMarkSpec>;
 export type ILinkPathMark = IMarkRaw<ILinkPathMarkSpec>;
 export type IPathMark = IMarkRaw<IPathMarkSpec>;
-export type IRect3dMark = IMarkRaw<IRect3dMarkSpec>;
 export type IRectMark = IMarkRaw<IRectMarkSpec>;
 export type IRippleMark = IMarkRaw<IRippleMarkSpec>;
 export type IRuleMark = IMarkRaw<IRuleMarkSpec>;
@@ -42,3 +54,6 @@ export interface IGroupMark extends IMarkRaw<IGroupMarkSpec> {
     getMarkInId: (id: number) => IMark | undefined;
     getMarkInName: (name: string) => IMark[] | undefined;
 }
+export interface ILinkPathConfig {
+    direction?: 'horizontal' | 'vertical' | 'LR' | 'RL' | 'TB' | 'BL' | 'radial';
+}

package/types/mark/interface/type.d.ts

@@ -6,20 +6,18 @@ export declare const enum MarkTypeEnum {
     line = "line",
     text = "text",
     rect = "rect",
-    rect3d = "rect3d",
     image = "image",
     path = "path",
     area = "area",
     arc = "arc",
-    arc3d = "arc3d",
     polygon = "polygon",
-    pyramid3d = "pyramid3d",
     boxPlot = "boxPlot",
     linkPath = "linkPath",
     cell = "cell",
     ripple = "ripple",
     liquid = "liquid",
     component = "component",
+    dataLabel = "dataLabel",
     label = "label",
     pictogram = "pictogram"
 }

package/types/mark/label.d.ts

@@ -1,7 +1,7 @@
 import type { IMark } from './interface/common';
 import { MarkTypeEnum } from './interface/type';
 import { TextMark } from './text';
-import type { ILabelMark } from './interface/mark';
+import type { IComponentMark, ILabelMark } from './interface/mark';
 export declare class LabelMark extends TextMark implements ILabelMark {
     static readonly type = MarkTypeEnum.text;
     static readonly constructorType = MarkTypeEnum.label;
@@ -13,7 +13,8 @@ export declare class LabelMark extends TextMark implements ILabelMark {
     getTarget(): IMark;
     setTarget(target: IMark): void;
     private _component;
-    getComponent(): IMark;
-    setComponent(component: IMark): void;
+    getComponent(): IComponentMark;
+    setComponent(component: IComponentMark): void;
+    render(): void;
 }
 export declare const registerLabelMark: () => void;

package/types/mark/link-path.d.ts

@@ -1,12 +1,42 @@
-import { BaseMark } from './base/base-mark';
 import type { ILinkPathMarkSpec } from '../typings/visual';
-import type { ILinkPathMark, IMarkStyle } from './interface';
+import type { ILinkPathConfig, ILinkPathMark, IMarkStyle } from './interface';
 import { MarkTypeEnum } from './interface/type';
-import type { IGroupMark } from '@visactor/vgrammar-core';
-export declare class LinkPathMark extends BaseMark<ILinkPathMarkSpec> implements ILinkPathMark {
+import { GlyphMark } from './glyph';
+import type { IGlyph } from '@visactor/vrender-core';
+import type { Datum } from '../typings/common';
+export declare const getHorizontalPath: (options: ILinkPathMarkSpec, ratio?: number) => string;
+export declare const getVerticalPath: (options: ILinkPathMarkSpec, ratio?: number) => string;
+export declare class LinkPathMark extends GlyphMark<ILinkPathMarkSpec, ILinkPathConfig> implements ILinkPathMark {
     static readonly type = MarkTypeEnum.linkPath;
     readonly type = MarkTypeEnum.linkPath;
     protected _getDefaultStyle(): IMarkStyle<ILinkPathMarkSpec>;
-    protected _initProduct(group?: string | IGroupMark): void;
+    protected _subMarks: {
+        back: {
+            type: string;
+            defaultAttributes: {
+                zIndex: number;
+            };
+        };
+        front: {
+            type: string;
+            defaultAttributes: {
+                zIndex: number;
+            };
+        };
+    };
+    protected _positionChannels: string[];
+    protected _channelEncoder: {
+        backgroundStyle: (val: any) => {
+            back: any;
+        };
+    };
+    protected _positionEncoder: (glyphAttrs: any, datum: Datum, g: IGlyph) => {
+        back: {
+            path: string;
+        };
+        front: {
+            path: string;
+        };
+    };
 }
 export declare const registerLinkPathMark: () => void;

package/types/mark/liquid.d.ts

@@ -1,13 +1,55 @@
-import type { ILiquidMarkSpec } from '../typings';
 import type { IMarkStyle } from './interface';
 import { MarkTypeEnum } from './interface/type';
-import { BaseMark } from './base';
 import type { ILiquidMark } from '../series/liquid/liquid';
-import type { IGroupMark } from '@visactor/vgrammar-core';
-export declare class LiquidMark extends BaseMark<ILiquidMarkSpec> implements ILiquidMark {
+import { GlyphMark } from './glyph';
+import { type IGlyph } from '@visactor/vrender-core';
+import type { IPointLike } from '@visactor/vutils';
+import type { ILiquidMarkSpec } from '../typings/visual';
+import type { Datum } from '../typings/common';
+export declare class LiquidMark extends GlyphMark<ILiquidMarkSpec> implements ILiquidMark {
     static readonly type = MarkTypeEnum.liquid;
     readonly type = MarkTypeEnum.liquid;
     protected _getDefaultStyle(): IMarkStyle<ILiquidMarkSpec>;
-    protected _initProduct(group?: string | IGroupMark): void;
+    protected _subMarks: {
+        wave0: {
+            type: string;
+            defaultAttributes: {
+                curveType: string;
+                fillOpacity: number;
+            };
+        };
+        wave1: {
+            type: string;
+            defaultAttributes: {
+                curveType: string;
+                fillOpacity: number;
+            };
+        };
+        wave2: {
+            type: string;
+            defaultAttributes: {
+                curveType: string;
+                fillOpacity: number;
+            };
+        };
+    };
+    protected _positionChannels: string[];
+    protected _positionEncoder: (glyphAttrs: any, datum: Datum, g: IGlyph) => {
+        wave0: {
+            x: number;
+            y: number;
+            points: IPointLike[];
+        };
+        wave1: {
+            x: number;
+            y: number;
+            points: IPointLike[];
+        };
+        wave2: {
+            x: number;
+            y: number;
+            points: IPointLike[];
+        };
+    };
 }
 export declare const registerLiquidMark: () => void;

package/types/mark/ripple.d.ts

@@ -1,12 +1,47 @@
-import { BaseMark } from './base/base-mark';
 import type { IRippleMarkSpec } from '../typings/visual';
 import type { IMarkStyle, IRippleMark } from './interface';
 import { MarkTypeEnum } from './interface/type';
-import type { IGroupMark } from '@visactor/vgrammar-core';
-export declare class RippleMark extends BaseMark<IRippleMarkSpec> implements IRippleMark {
+import { GlyphMark } from './glyph';
+import type { Datum } from '../typings/common';
+import { type IGlyph } from '@visactor/vrender-core';
+export declare class RippleMark extends GlyphMark<IRippleMarkSpec> implements IRippleMark {
     static readonly type = MarkTypeEnum.ripple;
     readonly type = MarkTypeEnum.ripple;
     protected _getDefaultStyle(): IMarkStyle<IRippleMarkSpec>;
-    protected _initProduct(group?: string | IGroupMark): void;
+    protected _subMarks: {
+        ripple0: {
+            type: string;
+            defaultAttributes: {
+                fillOpacity: number;
+            };
+        };
+        ripple1: {
+            type: string;
+            defaultAttributes: {
+                fillOpacity: number;
+            };
+        };
+        ripple2: {
+            type: string;
+            defaultAttributes: {
+                fillOpacity: number;
+            };
+        };
+    };
+    protected _positionChannels: string[];
+    protected _positionEncoder: (glyphAttrs: any, datum: Datum, g: IGlyph) => {
+        ripple0: {
+            size: any;
+            fillOpacity: number;
+        };
+        ripple1: {
+            size: any;
+            fillOpacity: number;
+        };
+        ripple2: {
+            size: any;
+            fillOpacity: number;
+        };
+    };
 }
 export declare const registerRippleMark: () => void;

package/types/mark/rule.d.ts

@@ -1,10 +1,13 @@
 import type { IRuleMarkSpec } from '../typings/visual';
 import { BaseMark } from './base/base-mark';
-import type { IMarkStyle, IRuleMark } from './interface';
+import type { IMarkGraphic, IMarkStyle, IRuleMark } from './interface';
 import { MarkTypeEnum } from './interface/type';
+import type { IGraphic, ILineGraphicAttribute } from '@visactor/vrender-core';
 export declare class RuleMark extends BaseMark<IRuleMarkSpec> implements IRuleMark {
     static readonly type = MarkTypeEnum.rule;
     readonly type = MarkTypeEnum.rule;
     protected _getDefaultStyle(): IMarkStyle<IRuleMarkSpec>;
+    protected _transformGraphicAttributes(g: IMarkGraphic, attrs: any, groupAttrs?: any): any;
+    protected _createGraphic(attrs?: ILineGraphicAttribute): IGraphic;
 }
 export declare const registerRuleMark: () => void;

package/types/mark/symbol.d.ts

@@ -1,12 +1,11 @@
 import type { ISymbolMarkSpec } from '../typings/visual';
 import { BaseMark } from './base/base-mark';
-import type { IMarkStyle, ISymbolMark } from './interface';
+import type { IMarkGraphic, IMarkStyle, ISymbolMark } from './interface';
 import { MarkTypeEnum } from './interface/type';
-export declare class BaseSymbolMark<T extends ISymbolMarkSpec> extends BaseMark<T> {
-    protected _getDefaultStyle(): IMarkStyle<T>;
-}
-export declare class SymbolMark extends BaseSymbolMark<ISymbolMarkSpec> implements ISymbolMark {
+export declare class SymbolMark extends BaseMark<ISymbolMarkSpec> implements ISymbolMark {
     static readonly type = MarkTypeEnum.symbol;
     readonly type = MarkTypeEnum.symbol;
+    protected _getDefaultStyle(): IMarkStyle<ISymbolMarkSpec>;
+    protected _transformGraphicAttributes(g: IMarkGraphic, attrs: any, groupAttrs?: any): any;
 }
 export declare const registerSymbolMark: () => void;

package/types/mark/text.d.ts

@@ -1,8 +1,9 @@
 import type { IComposedTextMarkSpec } from '../typings/visual';
 import { BaseMark } from './base/base-mark';
-import type { IMarkOption, IMarkStyle } from './interface';
+import type { IMarkGraphic, IMarkOption, IMarkStyle } from './interface';
 import { MarkTypeEnum } from './interface';
 import type { ITextMark, ITextSpec } from './interface/mark';
+import type { IGraphic, IRichTextGraphicAttribute, ITextGraphicAttribute } from '@visactor/vrender-core';
 export declare class TextMark extends BaseMark<IComposedTextMarkSpec> implements ITextMark {
     static readonly type = MarkTypeEnum.text;
     readonly type = MarkTypeEnum.text;
@@ -10,7 +11,8 @@ export declare class TextMark extends BaseMark<IComposedTextMarkSpec> implements
     getTextType(): "text" | "rich";
     constructor(name: string, option: IMarkOption);
     protected _getDefaultStyle(): IMarkStyle<IComposedTextMarkSpec>;
-    initStyleWithSpec(spec: ITextSpec<IComposedTextMarkSpec>, key?: string): void;
-    compileEncode(): void;
+    initStyleWithSpec(spec: ITextSpec<IComposedTextMarkSpec>): void;
+    protected _transformGraphicAttributes(g: IMarkGraphic, attrs: any, groupAttrs?: any): any;
+    protected _createGraphic(attrs?: ITextGraphicAttribute | IRichTextGraphicAttribute): IGraphic;
 }
 export declare const registerTextMark: () => void;

package/types/mark/transform/data-sampling.d.ts

@@ -0,0 +1,10 @@
+import type { Datum } from '../../typings/common';
+export declare const dataSampling: (options: {
+    size: number | (() => number);
+    factor?: number;
+    skipfirst?: boolean;
+    yfield?: string;
+    groupBy?: string;
+    mode?: 'lttb' | 'min' | 'max' | 'average' | 'sum';
+}, upstreamData: Datum[]) => Datum[];
+export declare const registerDataSamplingTransform: () => void;

package/types/mark/transform/filter.d.ts

@@ -0,0 +1 @@
+export declare const registerMarkFilterTransform: () => void;

package/types/mark/transform/map.d.ts

@@ -0,0 +1 @@
+export declare const registerMarkMapTransform: () => void;

package/types/mark/transform/symbol-overlap.d.ts

@@ -0,0 +1,13 @@
+import type { IMarkGraphic } from '../interface';
+export declare const OVERLAP_HIDE_KEY: string;
+export declare const transform: (options: {
+    direction: number;
+    delta?: number;
+    deltaMul?: number;
+    hideMode?: number;
+    forceUpdate?: boolean;
+    forceUpdateStamp?: number;
+    groupBy?: string;
+    sort?: boolean;
+}, upstreamData: IMarkGraphic[]) => IMarkGraphic[];
+export declare const registerSymbolOverlapTransform: () => void;

package/types/mark/utils/common.d.ts

@@ -1,5 +1,8 @@
 import { MarkTypeEnum } from '../interface/type';
+import type { Datum } from '../../typings';
+import type { GroupedData } from '../interface/common';
 export declare const MultiDatumMark: string[];
 export declare function isMultiDatumMark(type: MarkTypeEnum): boolean;
 export declare function curveTypeTransform(type: string, direction: string): string;
-export declare function is3DMark(type: MarkTypeEnum): boolean;
+export declare function groupData<T>(data: T[], groupBy: (datum: Datum, index: number) => string, sort?: (a: T, b: T) => number): GroupedData<T>;
+export declare const runEncoder: (styles: Record<string, (datum: Datum) => any>, datum: Datum, attrs?: any) => any;

package/types/mark/utils/glyph.d.ts

@@ -0,0 +1,2 @@
+import type { IMarkGraphic } from '../interface/common';
+export declare const addRuntimeState: (g: IMarkGraphic, stateName: string, attrs: any, keepCurrentStates?: boolean, hasAnimation?: boolean) => void;

package/types/mark/utils/index.d.ts

@@ -1 +1,3 @@
 export * from './common';
+export * from './line';
+export * from './glyph';

package/types/mark/utils/line.d.ts

@@ -0,0 +1,3 @@
+import type { IColorStop } from '@visactor/vrender-core';
+export declare const isStopsEqual: (prev: IColorStop[], next: IColorStop[]) => boolean;
+export declare const isSegmentAttrEqual: (prev: any, next: any, key: string) => boolean;

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

@@ -3,12 +3,12 @@ import type { IEffect, IModel, IModelInitOption, IModelOption, IModelRenderOptio
 import type { CoordinateType } from '../typings/coordinate';
 import type { ICompileMarkConfig, IMark, IMarkOption, IMarkRaw, IMarkStyle } from '../mark/interface';
 import type { Datum, StateValueType, ConvertToMarkStyleSpec, ICommonSpec, StringOrNumber, IRect, ILayoutRect } from '../typings';
-import type { CompilableData } from '../compile/data/compilable-data';
-import type { IGroupMark } from '@visactor/vgrammar-core';
 import { MarkSet } from '../mark/mark-set';
 import type { ILayoutItem } from '../layout/interface';
 import { CompilableBase } from '../compile/compilable-base';
 import { BaseModelSpecTransformer } from './base-model-transformer';
+import type { IGroup } from '@visactor/vrender-core';
+import type { ICompilableData } from '../compile/data/interface';
 export declare abstract class BaseModel<T extends IModelSpec> extends CompilableBase implements IModel {
     readonly transformerConstructor: typeof BaseModelSpecTransformer;
     protected _spec: T;
@@ -21,8 +21,8 @@ export declare abstract class BaseModel<T extends IModelSpec> extends Compilable
     userId: StringOrNumber | undefined;
     readonly event: IEvent;
     readonly effect: IEffect;
-    protected _data: CompilableData;
-    getData(): CompilableData;
+    protected _data: ICompilableData;
+    getData(): ICompilableData;
     protected _layout?: ILayoutItem;
     get layout(): ILayoutItem;
     readonly specKey: string;
@@ -32,7 +32,7 @@ export declare abstract class BaseModel<T extends IModelSpec> extends Compilable
     getMarks(): IMark[];
     getMarkNameMap(): Record<string, IMark>;
     getMarkSet(): MarkSet;
-    getChart(): import("../chart/interface").IChart;
+    getChart(): import("..").IChart;
     protected get _theme(): any;
     protected _lastLayoutRect: ILayoutRect;
     constructor(spec: T, option: IModelOption);
@@ -42,12 +42,13 @@ export declare abstract class BaseModel<T extends IModelSpec> extends Compilable
     init(option: IModelInitOption): void;
     afterInit(): void;
     getVisible(): boolean;
-    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect, ctx: any): void;
-    onLayoutEnd(ctx: any): void;
+    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect): void;
+    onLayoutEnd(): void;
     onEvaluateEnd(ctx: IModelEvaluateOption): void;
     abstract onRender(ctx: IModelRenderOption): void;
     onDataUpdate(): void;
     beforeRelease(): void;
+    clear(): void;
     release(): void;
     updateSpec(spec: T): {
         change: boolean;
@@ -68,13 +69,13 @@ export declare abstract class BaseModel<T extends IModelSpec> extends Compilable
     setAttrFromSpec(): void;
     protected _convertMarkStyle<T extends ICommonSpec = ICommonSpec>(style: Partial<IMarkStyle<T> | ConvertToMarkStyleSpec<T>>): Partial<IMarkStyle<T> | ConvertToMarkStyleSpec<T>>;
     setMarkStyle<T extends ICommonSpec>(mark: IMarkRaw<T>, style?: Partial<IMarkStyle<T> | ConvertToMarkStyleSpec<T>>, state?: StateValueType, level?: number): void;
-    initMarkStyleWithSpec(mark?: IMark, spec?: any, key?: string): void;
+    initMarkStyleWithSpec(mark?: IMark, spec?: any): void;
     protected stateKeyToSignalName(key: string, opt?: string): string;
     compileData(): void;
-    compileMarks(group?: string | IGroupMark): void;
+    compileMarks(group?: IGroup): void;
     protected _createMark<T extends IMark>(markInfo: IModelMarkInfo, option?: Partial<IMarkOption>, config?: ICompileMarkConfig): T;
     protected _getDataIdKey(): string | ((datum: Datum) => string) | undefined;
-    getColorScheme(): import("..").IThemeColorScheme;
+    getColorScheme(): any;
     getSpecInfo(): IModelSpecInfo<any>;
     getSpecIndex(): number;
 }