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

package/types/interaction/triggers/element-select.d.ts

@@ -0,0 +1,24 @@
+import type { IElementSelectOptions, ITrigger } from '../interface/trigger';
+import type { IMarkGraphic } from '../../mark/interface/common';
+import { BaseTrigger } from './base';
+import type { BaseEventParams } from '../../event/interface';
+export declare class ElementSelect extends BaseTrigger<IElementSelectOptions> implements ITrigger<IElementSelectOptions> {
+    static type: string;
+    type: string;
+    static defaultOptions: Partial<IElementSelectOptions>;
+    protected _resetType: ('view' | 'self' | 'timeout')[];
+    private _timer?;
+    constructor(options?: IElementSelectOptions);
+    getStartState(): string;
+    getResetState(): string;
+    protected getEvents(): {
+        type: import("@visactor/vrender-core").GraphicEventType | import("@visactor/vrender-core").GraphicEventType[];
+        handler: (e: BaseEventParams) => void;
+    }[];
+    resetAll: () => void;
+    handleStart: (e: BaseEventParams) => void;
+    handleReset: (e: BaseEventParams) => void;
+    start(markGraphic: IMarkGraphic): void;
+    reset(markGraphic: IMarkGraphic): void;
+}
+export declare const registerElementSelect: () => void;

package/types/interaction/triggers/enum.d.ts

@@ -0,0 +1,6 @@
+export declare const enum TRIGGER_TYPE_ENUM {
+    DIMENSION_HOVER = "dimension-hover",
+    ELEMENT_HIGHLIGHT = "element-highlight",
+    ELEMENT_SELECT = "element-select",
+    ELEMENT_ACTIVE = "element-active"
+}

package/types/interaction/triggers/util.d.ts

@@ -0,0 +1,12 @@
+import type { IMark, IMarkGraphic } from '../../mark/interface/common';
+import type { IElementFilterOptions, IElementHighlightOptions, IElementSelectTriggerOff } from '../interface/trigger';
+import type { GraphicEventType } from '@visactor/vrender-core';
+import type { IBaseInteractionSpec } from '../interface/spec';
+export declare const parseTriggerOffOfSelect: (triggerOff: IElementSelectTriggerOff | IElementSelectTriggerOff[]) => {
+    eventNames: GraphicEventType[];
+    resetType: ("self" | "view" | "timeout")[];
+};
+export declare const groupMarksByState: (marks: IMark[], states: string[]) => Record<string, number[]>;
+export declare const filterMarksOfInteraction: (interactionSpec: IBaseInteractionSpec, marks: IMark[]) => IMark[];
+export declare const generateFilterValue: (options: IElementFilterOptions) => (g: IMarkGraphic) => any;
+export declare const highlightDefaultOptions: Partial<IElementHighlightOptions>;

package/types/interaction/zoom/zoomable.d.ts

@@ -7,6 +7,7 @@ export interface ITriggerOption {
     delayType: IDelayType;
     delayTime: number;
     realTime: boolean;
+    allowComponentZoom?: boolean;
 }
 export type ZoomEventParams = {
     zoomDelta: number;
@@ -57,5 +58,9 @@ export declare class Zoomable implements IZoomable {
     private _bindDragEventAsRegion;
     initDragEventOfSeries(s: ISeries, callback?: (delta: [number, number], e: BaseEventParams['event']) => void, option?: ITriggerOption): void;
     initDragEventOfRegions(regions: IRegion[], filter?: (s: ISeries) => boolean, callback?: (delta: [number, number], e: BaseEventParams['event']) => void, option?: ITriggerOption): void;
+    private _handleDragMouseUp?;
+    private _handleDragMouseMove?;
+    protected _clearDragEvent(): void;
+    private isDragEnable;
     protected _handleDrag(params: ExtendEventParam, callback?: (delta: [number, number], e: BaseEventParams['event']) => void, option?: ITriggerOption): void;
 }

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

@@ -1,8 +1,9 @@
 import type { utilFunctionCtx } from '../typings/params';
 import type { IChart } from '../chart/interface/chart';
-import type { IBoundsLike } from '@visactor/vutils';
+import { type IBoundsLike } from '@visactor/vutils';
 import type { IBaseLayout, ILayoutItem } from './interface';
 import type { IOrientType, IPadding, IRect } from '../typings/space';
+import type { IRecompute } from './util';
 import type { ILayoutRect } from '../typings/layout';
 export type LayoutSideType = {
     top: number;
@@ -28,10 +29,12 @@ export declare class Layout implements IBaseLayout {
     bottomCurrent: number;
     _chartLayoutRect: IRect;
     _chartViewBox: IBoundsLike;
+    recomputeWidth: boolean;
+    recomputeHeight: boolean;
     protected _onError: (msg: string) => void;
     constructor(_spec?: unknown, ctx?: utilFunctionCtx);
     protected _layoutInit(_chart: IChart, items: ILayoutItem[], chartLayoutRect: IRect, chartViewBox: IBoundsLike): void;
-    protected _layoutNormalItems(items: ILayoutItem[]): void;
+    protected _layoutNormalItems(items: ILayoutItem[], recompute: IRecompute): void;
     protected _groupItems(items: ILayoutItem[]): {
         regionItems: ILayoutItem[];
         relativeItems: ILayoutItem[];
@@ -48,18 +51,18 @@ export declare class Layout implements IBaseLayout {
     layoutItems(_chart: IChart, items: ILayoutItem[], chartLayoutRect: IRect, chartViewBox: IBoundsLike): void;
     protected _processAutoIndent(regionItems: ILayoutItem[], relativeItems: ILayoutItem[], relativeOverlapItems: ILayoutItem[], overlapItems: {
         [key in IOrientType]: overlapInfo;
-    }, allRelatives: ILayoutItem[], layoutTemp: LayoutSideType): void;
-    protected layoutNormalItems(normalItems: ILayoutItem[]): void;
-    protected layoutNormalInlineItems(normalItems: ILayoutItem[]): void;
-    protected _layoutRelativeOverlap(orient: IOrientType, info: overlapInfo): void;
-    protected _layoutRelativeItem(item: ILayoutItem, layoutRect: ILayoutRect): void;
+    }, allRelatives: ILayoutItem[], layoutTemp: LayoutSideType, recompute: IRecompute): void;
+    protected layoutNormalItems(normalItems: ILayoutItem[], recompute: IRecompute): void;
+    protected layoutNormalInlineItems(normalItems: ILayoutItem[], recompute: IRecompute): boolean;
+    protected _layoutRelativeOverlap(orient: IOrientType, info: overlapInfo, recompute: IRecompute): void;
+    protected _layoutRelativeItem(item: ILayoutItem, recompute: IRecompute): void;
     protected _layoutRegionItem(regionItems: ILayoutItem[], regionRelativeTotalWidth: number, regionRelativeTotalHeight: number): {
         regionHeight: number;
         regionWidth: number;
     };
-    protected layoutRegionItems(regionItems: ILayoutItem[], regionRelativeItems: ILayoutItem[], regionRelativeOverlapItems: ILayoutItem[], overlapItems?: {
+    protected layoutRegionItems(regionItems: ILayoutItem[], regionRelativeItems: ILayoutItem[], regionRelativeOverlapItems: ILayoutItem[], overlapItems: {
         [key in IOrientType]: overlapInfo;
-    }): void;
+    }, recompute: IRecompute): void;
     protected layoutAbsoluteItems(absoluteItems: ILayoutItem[]): void;
     filterRegionsWithID(items: ILayoutItem[], id: number): ILayoutItem;
     getItemComputeLayoutRect(item: ILayoutItem): {

package/types/layout/index.d.ts

@@ -1,6 +1,6 @@
+import type { IOffset, LayoutSideType } from './base-layout';
 import { Layout } from './base-layout';
 import { GridLayout, registerGridLayout } from './grid-layout/grid-layout';
-import { Layout3d, registerLayout3d } from './layout3d';
-import type { ILayoutSpec, IGridLayoutSpec } from './interface';
-export { Layout, GridLayout, Layout3d, registerGridLayout, registerLayout3d };
-export type { ILayoutSpec, IGridLayoutSpec };
+import type { ILayoutSpec, IGridLayoutSpec, IBaseLayout, ILayoutItem } from './interface';
+export { Layout, GridLayout, registerGridLayout };
+export type { ILayoutSpec, IGridLayoutSpec, IBaseLayout, IOffset, ILayoutItem, LayoutSideType };

package/types/layout/interface.d.ts

@@ -1,6 +1,6 @@
 import type { IBoundsLike } from '@visactor/vutils';
 import type { StringOrNumber } from '../typings/common';
-import type { IOrientType, IRect } from '../typings/space';
+import type { IOrientType, IPadding, IRect } from '../typings/space';
 import type { IPoint } from '../typings/coordinate';
 import type { ILayoutNumber, ILayoutPaddingSpec, ILayoutPoint, ILayoutRect, ILayoutType } from '../typings/layout';
 import type { ILayoutModel } from '../model/interface';
@@ -46,6 +46,8 @@ export interface ILayoutConstructor {
 }
 export interface ILayoutItem {
     readonly type: string;
+    readonly willLayoutTag: boolean;
+    readonly lastComputeRect: ILayoutRect;
     directionStr?: 'l2r' | 'r2l' | 't2b' | 'b2t';
     layoutClip: boolean;
     layoutType: ILayoutType;
@@ -76,12 +78,14 @@ export interface ILayoutItem {
     getLayoutRect: () => ILayoutRect;
     getLayout: () => IRect;
     getLastComputeOutBounds: () => IBoundsLike;
-    onLayoutStart: (layoutRect: IRect, viewRect: ILayoutRect, ctx: any) => void;
-    onLayoutEnd: (option: any) => void;
+    onLayoutStart: (layoutRect: IRect, viewRect: ILayoutRect) => void;
+    onLayoutEnd: () => void;
     setLayoutRect: (rect: Partial<ILayoutRect>, levelMap?: Partial<ILayoutRect>) => void;
     computeBoundsInRect: (rect: ILayoutRect) => ILayoutRect;
     setLayoutStartPosition: (pos: Partial<IPoint>) => void;
     absoluteLayoutInRect: (rect: IRect) => void;
+    clearWillLayoutTag: () => void;
+    setWillLayoutTag: () => void;
 }
 export interface ILayoutItemSpec {
     layoutType?: ILayoutType;
@@ -112,4 +116,5 @@ export interface ILayoutItemInitOption {
     layoutOrient?: IOrientType;
     transformLayoutRect?: (rect: ILayoutRect) => ILayoutRect;
     transformLayoutPosition?: (pos: Partial<IPoint>) => Partial<IPoint>;
+    transformLayoutPadding?: (padding: IPadding) => IPadding;
 }

package/types/layout/layout-item.d.ts

@@ -2,7 +2,6 @@ import type { ILayoutModel } from './../model/interface';
 import type { IRect, IPoint } from '../typings';
 import type { IBoundsLike } from '@visactor/vutils';
 import type { ILayoutItem, ILayoutItemInitOption, ILayoutItemSpec } from './interface';
-import type { IChartLayoutOption } from '../chart/interface/common';
 import type { ILayoutAlignSelf, ILayoutPoint, ILayoutRect } from '../typings/layout';
 export declare class LayoutItem implements ILayoutItem {
     protected _spec: ILayoutItemSpec;
@@ -27,6 +26,7 @@ export declare class LayoutItem implements ILayoutItem {
     get maxHeight(): number;
     set maxHeight(v: number);
     protected _lastComputeRect: ILayoutRect;
+    get lastComputeRect(): ILayoutRect;
     protected _lastComputeOutBounds: IBoundsLike;
     getLastComputeOutBounds(): IBoundsLike;
     getLayoutRect: () => ILayoutRect;
@@ -48,11 +48,13 @@ export declare class LayoutItem implements ILayoutItem {
     get model(): ILayoutModel;
     get type(): string;
     protected _option: ILayoutItemInitOption;
+    protected _willLayoutTag: boolean;
+    get willLayoutTag(): boolean;
     constructor(model: ILayoutModel, option: ILayoutItemInitOption);
     private _setLayoutAttributeFromSpec;
     setAttrFromSpec(spec: ILayoutItemSpec, chartViewRect: ILayoutRect): void;
-    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect, ctx: any): void;
-    onLayoutEnd(option: IChartLayoutOption): void;
+    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect): void;
+    onLayoutEnd(): void;
     private _getAbsoluteSpecValue;
     absoluteLayoutInRect(layoutRect: IRect): void;
     setLayoutStartPosition(pos: Partial<IPoint>): void;
@@ -69,4 +71,6 @@ export declare class LayoutItem implements ILayoutItem {
     computeBoundsInRect(rect: ILayoutRect): ILayoutRect;
     getModelId(): number;
     getModelVisible(): boolean;
+    setWillLayoutTag(): void;
+    clearWillLayoutTag(): void;
 }

package/types/layout/util.d.ts

@@ -1,6 +1,19 @@
 import type { Layout } from './base-layout';
 import type { ILayoutItem } from './interface';
-export declare function layoutLeftInlineItems(items: ILayoutItem[], layout: Layout, limitHeight: number): void;
-export declare function layoutRightInlineItems(items: ILayoutItem[], layout: Layout, limitHeight: number): void;
-export declare function layoutTopInlineItems(items: ILayoutItem[], layout: Layout, limitWidth: number): void;
-export declare function layoutBottomInlineItems(items: ILayoutItem[], layout: Layout, limitWidth: number): void;
+import type { ILayoutRect } from '../typings';
+export type IRecompute = {
+    recomputeWidth: boolean;
+    recomputeHeight: boolean;
+};
+export declare function layoutLeftInlineItems(items: ILayoutItem[], layout: Layout, limitHeight: number, recompute: IRecompute): void;
+export declare function layoutRightInlineItems(items: ILayoutItem[], layout: Layout, limitHeight: number, recompute: IRecompute): void;
+export declare function layoutTopInlineItems(items: ILayoutItem[], layout: Layout, limitWidth: number, recompute: IRecompute): void;
+export declare function layoutBottomInlineItems(items: ILayoutItem[], layout: Layout, limitWidth: number, recompute: IRecompute): void;
+export declare function getItemLayoutWithTag(item: ILayoutItem, layout: Layout, recompute: IRecompute, setRectToItem?: boolean): {
+    layoutRect: import("@visactor/vutils").IBoundsLike | {
+        width: number;
+        height: number;
+    };
+    rect: ILayoutRect;
+    layoutTag: boolean;
+};

package/types/mark/arc.d.ts

@@ -3,15 +3,15 @@ import { BaseMark } from './base/base-mark';
 import type { IArcMark, IMarkOption, IMarkRaw, IMarkStyle } from './interface';
 import { MarkTypeEnum } from './interface/type';
 export declare class BaseArcMark<T extends IArcMarkSpec> extends BaseMark<T> implements IMarkRaw<T> {
-    readonly type: MarkTypeEnum;
+    readonly type: string;
     _unCompileChannel: {
         centerOffset: boolean;
         radiusOffset: boolean;
     };
     constructor(name: string, option: IMarkOption);
     protected _getDefaultStyle(): IMarkStyle<T>;
-    protected computeOuterRadius: (key: string, datum: Datum, states: StateValueType, opt: any, superValue: number) => number;
-    protected computeCenter: (key: 'x' | 'y', datum: Datum, states: StateValueType, opt: any, center: number) => number;
+    protected computeOuterRadius: (key: string, datum: Datum, states: StateValueType, superValue: number) => number;
+    protected computeCenter: (key: 'x' | 'y', datum: Datum, states: StateValueType, center: number) => number;
 }
 export declare class ArcMark extends BaseArcMark<IArcMarkSpec> implements IArcMark {
     static readonly type = MarkTypeEnum.arc;

package/types/mark/area.d.ts

@@ -6,6 +6,8 @@ export declare class AreaMark extends BaseLineMark<IAreaMarkSpec> implements IAr
     static readonly type = MarkTypeEnum.area;
     readonly type = MarkTypeEnum.area;
     protected _getDefaultStyle(): IMarkStyle<IAreaMarkSpec>;
+    protected _getSegmentAttributes(): string[];
     protected _getIgnoreAttributes(): string[];
+    _isValidPointChannel: (channel: string) => boolean;
 }
 export declare const registerAreaMark: () => void;

package/types/mark/base/base-line.d.ts

@@ -1,8 +1,31 @@
 import type { StateValueType } from '../../compile/mark';
 import type { ConvertToMarkStyleSpec, ILineLikeMarkSpec } from '../../typings/visual';
+import type { IPointLike } from '@visactor/vutils';
 import { BaseMark } from './base-mark';
-import type { IMarkStyle } from '../interface';
+import { type IMarkGraphic, type IMarkStyle } from '../interface';
+import type { Datum } from '../../typings/common';
+import type { IGroup, ILine } from '@visactor/vrender-core';
+import type { IMarkSpec } from '../../typings/spec/common';
+export declare const LINE_SEGMENT_ATTRIBUTES: string[];
 export declare abstract class BaseLineMark<T extends ILineLikeMarkSpec = ILineLikeMarkSpec> extends BaseMark<T> {
     protected abstract _getIgnoreAttributes(): string[];
-    setStyle<T>(style: Partial<ConvertToMarkStyleSpec<T>> | Partial<IMarkStyle<T>>, state?: StateValueType, level?: number, stateStyle?: import("../interface").IMarkStateStyle<T>): void;
+    protected _getSegmentAttributes(): string[];
+    protected _segmentStyleKeys: string[];
+    initStyleWithSpec(spec: IMarkSpec<T>): void;
+    setStyle<T>(style: Partial<ConvertToMarkStyleSpec<T>> | Partial<IMarkStyle<T>>, state?: StateValueType, level?: number): void;
+    _isValidPointChannel: (channel: string) => boolean;
+    _getLineSegments(items: any[], points: IPointLike[]): any[];
+    _getPrevPoints(g: ILine): IPointLike[];
+    _runPointsEncoder(newStyles: Record<string, (datum: Datum) => any>, g: IMarkGraphic, attrs?: any): any;
+    _runEncoderOfGraphic(newStyles: Record<string, (datum: Datum) => any>, g: IMarkGraphic, attrs?: any): any;
+    protected _getDataByKey(data: Datum[]): import("../interface").GroupedData<Datum>;
+    protected _runProgressiveJoin(): {
+        graphicsByGroup: {
+            [x: string]: IMarkGraphic[];
+        };
+        graphics: IMarkGraphic[];
+        needUpdate: boolean;
+    };
+    protected _setCommonAttributesToTheme(g: IMarkGraphic): void;
+    protected _addProgressiveGraphic(parent: IGroup, g: IMarkGraphic): void;
 }

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

@@ -1,13 +1,84 @@
-import type { IAttributeOpt, IModelMarkAttributeContext } from '../../compile/mark/interface';
-import type { Datum, IMarkSpec, ICommonSpec, ValueType } from '../../typings';
-import type { IMarkRaw, IMarkStateStyle, IMarkStyle, IMarkOption, StyleConvert, MarkInputStyle } from '../interface';
-import { CompilableMark } from '../../compile/mark/compilable-mark';
-import type { StateValueType } from '../../compile/mark';
-export type ExChannelCall = (key: string | number | symbol, datum: Datum, states: StateValueType, opt: unknown, baseValue: unknown) => unknown;
-export declare class BaseMark<T extends ICommonSpec> extends CompilableMark implements IMarkRaw<T> {
+import { type IModelMarkAttributeContext } from '../../compile/mark/interface';
+import type { Datum, IMarkSpec, ICommonSpec, ValueType, StringOrNumber, Maybe } from '../../typings';
+import type { DataView } from '@visactor/vdataset';
+import { MarkTypeEnum } from '../interface';
+import type { IMarkRaw, IMarkStateStyle, IMarkStyle, IMark, IMarkOption, StyleConvert, MarkInputStyle, GroupedData, IAttrs, IMarkGraphic, ProgressiveContext, IProgressiveTransformResult, MarkType, AnimationStateValues } from '../interface';
+import type { ICompilableMark, IMarkCompileOption, IMarkConfig, IMarkStateManager, StateValueType } from '../../compile/mark/interface';
+import type { ICompilableInitOption } from '../../compile/interface';
+import type { IGroupGraphicAttribute, IGroup, IGraphic } from '@visactor/vrender-core';
+import { GrammarItem } from '../../compile/grammar-item';
+import type { IModel } from '../../model/interface';
+import type { ICompilableData } from '../../compile/data/interface';
+import { type MarkAnimationSpec } from '../../animation/interface';
+export type ExChannelCall = (key: string | number | symbol, datum: Datum, states: StateValueType, baseValue: unknown) => unknown;
+export declare class BaseMark<T extends ICommonSpec> extends GrammarItem implements IMarkRaw<T> {
+    readonly type: MarkType;
+    readonly name: string;
+    readonly key: ICompilableMark['key'];
+    protected _markConfig: IMarkConfig;
+    protected _isCommited?: boolean;
+    commit(render?: boolean, recursion?: boolean): void;
+    uncommit(): void;
+    isCommited(): boolean;
+    getMarkConfig(): IMarkConfig;
+    setMarkConfig(config: IMarkConfig): void;
+    protected _visible: boolean;
+    getVisible(): boolean;
+    setVisible(visible: boolean): void;
+    protected _userId: StringOrNumber;
+    getUserId(): StringOrNumber;
+    setUserId(userId: StringOrNumber): void;
+    readonly model: IModel;
+    protected _data: ICompilableData;
+    getDataView(): DataView | undefined;
+    setDataView(d?: DataView): void;
+    getData(): ICompilableData;
+    setData(d?: ICompilableData): void;
     stateStyle: IMarkStateStyle<T>;
+    state: IMarkStateManager;
+    protected _unCompileChannel: {
+        [key in string]: boolean;
+    };
+    hasState(state: string): boolean;
+    getState(state: string): unknown;
+    protected _animationConfig: Partial<MarkAnimationSpec>;
+    getAnimationConfig(): Partial<MarkAnimationSpec>;
+    setAnimationConfig(config: Partial<MarkAnimationSpec>): void;
+    private _skipBeforeLayouted;
+    setSkipBeforeLayouted(skip: boolean): void;
+    protected _groupKey?: string;
+    setGroupKey(groupKey: string): void;
+    protected _stateSort?: (stateA: string, stateB: string) => number;
+    protected _product: Maybe<IGroup>;
+    getProduct(): IGroup;
+    protected _lastMark?: IMark;
+    protected initMarkData(option: ICompilableInitOption): void;
+    protected _compileProduct(option?: IMarkCompileOption): void;
+    protected _initProduct(group?: IGroup): void;
+    generateProductId(): string;
+    layout(layout: () => void): void;
+    compileData(): void;
+    compileEncode(): void;
+    compileState(): void;
+    compileAnimation(): void;
+    _context: any;
+    compileContext(extraContext?: any): void;
+    getContext(): any;
+    protected compileTransform(): void;
+    updateState(newState: Record<string, unknown>, noRender?: boolean): void;
+    getMarks(): IMark[];
+    runAnimationByState(state?: string): void;
+    stopAnimationByState(state?: string): void;
+    pauseAnimationByState(state?: string): void;
+    resumeAnimationByState(state?: string): void;
+    removeProduct(): void;
+    release(): void;
+    protected _simpleStyle: T;
+    setSimpleStyle(s: T): void;
+    getSimpleStyle(): T;
     protected _option: IMarkOption;
     protected _attributeContext: IModelMarkAttributeContext;
+    protected _encoderOfState: Record<string, Record<string, (datum: Datum) => any>>;
     _extensionChannel: {
         [key: string | number | symbol]: string[];
     };
@@ -16,17 +87,18 @@ export declare class BaseMark<T extends ICommonSpec> extends CompilableMark impl
     };
     constructor(name: string, option: IMarkOption);
     created(): void;
-    initStyleWithSpec(spec: IMarkSpec<T>, key?: string): void;
+    initStyleWithSpec(spec: IMarkSpec<T>): void;
     protected _transformStyleValue<T>(styleConverter: StyleConvert<T>, transform: (value: ValueType<T>) => ValueType<T>): StyleConvert<any>;
     convertAngleToRadian(styleConverter: StyleConvert<number>): any;
     isUserLevel(level: number): boolean;
-    setStyle<U extends keyof T>(style: Partial<IMarkStyle<T>>, state?: StateValueType, level?: number, stateStyle?: IMarkStateStyle<T>): void;
+    setStyle<U extends keyof T>(style: Partial<IMarkStyle<T>>, state?: StateValueType, level?: number): void;
     getStyle(key: string, state?: StateValueType): any;
-    protected _filterAttribute<U extends keyof T>(attr: U, style: MarkInputStyle<T[U]>, state: StateValueType, level: number, isUserLevel: boolean, stateStyle?: IMarkStateStyle<T>): StyleConvert<T[U]>;
-    setReferer<U extends keyof T>(mark: IMarkRaw<T>, styleKey?: U, state?: StateValueType, stateStyle?: IMarkStateStyle<T>): void;
+    protected _filterAttribute<U extends keyof T>(attr: U, style: MarkInputStyle<T[U]>, state: StateValueType, level: number, isUserLevel: boolean): StyleConvert<T[U]>;
+    setReferer<U extends keyof T>(mark: IMarkRaw<T>, styleKey?: U, state?: StateValueType): void;
     setPostProcess<U extends keyof T>(key: U, postProcessFunc: any, state?: StateValueType): void;
-    getAttribute<U extends keyof T>(key: U, datum: Datum, state?: StateValueType, opt?: IAttributeOpt): any;
-    setAttribute<U extends keyof T>(attr: U, style: MarkInputStyle<T[U]>, state?: StateValueType, level?: number, stateStyle?: IMarkStateStyle<T>): void;
+    getAttribute<U extends keyof T>(key: U, datum: Datum, state?: StateValueType): any;
+    getAttributesOfState(datum: Datum, state?: StateValueType): any;
+    setAttribute<U extends keyof T>(attr: U, style: MarkInputStyle<T[U]>, state?: StateValueType, level?: number): void;
     protected _getDefaultStyle(): IMarkStyle<T>;
     protected _styleConvert<U extends keyof T>(style?: MarkInputStyle<T[U]>): StyleConvert<T[U]> | undefined;
     protected _computeAttribute<U extends keyof T>(key: U, state: StateValueType): any;
@@ -35,4 +107,79 @@ export declare class BaseMark<T extends ICommonSpec> extends CompilableMark impl
     private _initSpecStyle;
     private _computeGradientAttr;
     private _computeBorderAttr;
+    protected _dataByGroup: GroupedData<Datum>;
+    protected _dataByKey: GroupedData<Datum>;
+    protected _prevDataByKey: GroupedData<Datum>;
+    protected _graphicMap: Map<string, IMarkGraphic>;
+    protected _graphics: IMarkGraphic[];
+    protected _keyGetter: (datum: Datum) => string;
+    protected _groupKeyGetter: (datum: Datum) => string;
+    protected renderContext?: {
+        parameters?: any;
+        progressive?: ProgressiveContext;
+        beforeTransformProgressive?: IProgressiveTransformResult;
+    };
+    protected _attrsByGroup?: Record<string, T>;
+    protected _getDataByKey(data: Datum[]): GroupedData<Datum>;
+    protected _getCommonContext(): {
+        markType: MarkTypeEnum;
+        markId: number;
+        modelId: number;
+        markUserId: StringOrNumber;
+        modelUserId: StringOrNumber;
+    };
+    prepareMorph(mark: IMark): void;
+    reuse(mark: IMark): void;
+    private _parseProgressiveContext;
+    getGraphics(): IMarkGraphic[];
+    protected _createGraphic(attrs?: any): IGraphic;
+    protected _runGroupData(data: Datum[]): void;
+    protected createAnimationStateList(type: string, animationConfig: Partial<MarkAnimationSpec>): any;
+    protected tryRunMorphing(graphics: IMarkGraphic[]): boolean;
+    protected _runStateAnimation(graphics: IMarkGraphic[]): void;
+    protected _runJoin(data: Datum[]): void;
+    _runEncoderOfGraphic(styles: Record<string, (datum: Datum) => any>, g: IMarkGraphic, attrs?: any): any;
+    _runGroupEncoder(groupStyles: Record<string, (datum: Datum) => any>): any;
+    protected _transformGraphicAttributes(g: IMarkGraphic, attrs: any, groupAttrs?: any): any;
+    protected _separateNormalStyle(normalStyle: Partial<IAttrs<T>>): {
+        updateStyles: {};
+        groupStyles: {};
+    };
+    protected _getEncoderOfStyle: (stateName: string, style: Partial<IAttrs<T>>) => Record<string, (datum: Datum) => any>;
+    protected _setGraphicFromMarkConfig: (g: IMarkGraphic) => void;
+    protected _setStateOfGraphic: (g: IMarkGraphic) => void;
+    protected _addProgressiveGraphic(parent: IGroup, g: IMarkGraphic): void;
+    protected _runEncoder(graphics: IMarkGraphic[], noGroupEncode?: boolean): void;
+    protected _runApplyGraphic(graphics: IMarkGraphic[]): void;
+    protected _updateEncoderByState(): void;
+    protected _runState(graphics: IMarkGraphic[]): void;
+    protected _getAttrsFromConfig(attrs?: IGroupGraphicAttribute): IGroupGraphicAttribute;
+    protected _updateAttrsOfGroup(): void;
+    protected _runBeforeTransform(data: Datum[]): Datum[];
+    protected _runEncoderTransform(data: Datum[], isProgressive: boolean): Datum[];
+    protected _runMainTasks(): void;
+    render(): void;
+    updateMarkState(key: string): void;
+    clearExitGraphics(): void;
+    isProgressive(): boolean;
+    canAnimateAfterProgressive(): boolean;
+    isDoingProgressive(): boolean;
+    clearProgressive(): void;
+    restartProgressive(): void;
+    private _runBeforeProgressive;
+    protected _runProgressiveJoin(): {
+        graphicsByGroup?: Record<string, IMarkGraphic[]>;
+        graphics?: IMarkGraphic[];
+        needUpdate?: boolean;
+    };
+    protected _createIncrementalGraphics(): void;
+    protected _setCommonAttributesToTheme(g: IMarkGraphic): void;
+    protected _runProgressiveEncoder(graphics: IMarkGraphic[]): void;
+    protected _runProgressiveApplyGraphic(graphics: IMarkGraphic[]): void;
+    protected _runProgressiveStep(): void;
+    renderProgressive(): void;
+    updateAnimationState(callback: (graphic: IMarkGraphic) => AnimationStateValues): void;
+    hasAnimationByState(state: keyof MarkAnimationSpec): boolean;
+    hasAnimation(): boolean;
+    runAnimation(): void;
 }

package/types/mark/box-plot.d.ts

@@ -1,12 +1,18 @@
-import type { IBoxPlotMarkSpec } from '../typings/visual';
-import { BaseMark } from './base/base-mark';
-import type { IGroupMark } from '@visactor/vgrammar-core';
+import type { BoxPlotShaftShape, IBoxPlotMarkSpec } from '../typings/visual';
 import type { IBoxPlotMark, IMarkStyle } from './interface';
 import { MarkTypeEnum } from './interface/type';
-export declare class BoxPlotMark extends BaseMark<IBoxPlotMarkSpec> implements IBoxPlotMark {
+import { GlyphMark } from './glyph';
+export declare class BoxPlotMark extends GlyphMark<IBoxPlotMarkSpec, {
+    direction?: 'horizontal' | 'vertical';
+    shaftShape?: BoxPlotShaftShape;
+}> implements IBoxPlotMark {
     static readonly type = MarkTypeEnum.boxPlot;
     readonly type = MarkTypeEnum.boxPlot;
+    protected _isHorizontal(): boolean;
+    setGlyphConfig(cfg: {
+        direction?: 'horizontal' | 'vertical';
+        shaftShape?: BoxPlotShaftShape;
+    }): void;
     protected _getDefaultStyle(): IMarkStyle<IBoxPlotMarkSpec>;
-    protected _initProduct(group?: string | IGroupMark): void;
 }
 export declare const registerBoxPlotMark: () => void;

package/types/mark/cell.d.ts

@@ -1,10 +1,13 @@
 import type { ICellMarkSpec } from '../typings';
-import type { ICellMark, IMarkStyle } from './interface';
+import type { ICellMark, IMarkGraphic, IMarkStyle } from './interface';
 import { MarkTypeEnum } from './interface/type';
-import { BaseSymbolMark } from './symbol';
-export declare class CellMark extends BaseSymbolMark<ICellMarkSpec> implements ICellMark {
+import type { IGraphic } from '@visactor/vrender-core';
+import { BaseMark } from './base';
+export declare class CellMark extends BaseMark<ICellMarkSpec> implements ICellMark {
     static readonly type = MarkTypeEnum.cell;
     readonly type = MarkTypeEnum.cell;
     protected _getDefaultStyle(): IMarkStyle<ICellMarkSpec>;
+    protected _createGraphic(attrs?: any): IGraphic;
+    protected _transformGraphicAttributes(g: IMarkGraphic, attrs: any, groupAttrs?: any): any;
 }
 export declare const registerCellMark: () => void;

package/types/mark/component.d.ts

@@ -1,14 +1,23 @@
-import type { IGroupMark } from '@visactor/vgrammar-core';
 import type { ICommonSpec } from '../typings';
 import { BaseMark } from './base/base-mark';
-import type { IComponentMark, IMarkOption } from './interface';
+import type { IComponentMark, IMarkOption, IMarkStyle } from './interface';
 import { MarkTypeEnum } from './interface/type';
+import type { IGraphic, IGroupGraphicAttribute } from '@visactor/vrender-core';
 export declare class ComponentMark extends BaseMark<ICommonSpec> implements IComponentMark {
     static readonly type = MarkTypeEnum.component;
     type: string;
     private _componentType;
+    private _component;
     private _mode;
     constructor(name: string, option: IMarkOption);
-    protected _initProduct(group?: string | IGroupMark): void;
+    protected _getDefaultStyle(): IMarkStyle<ICommonSpec>;
+    getComponent(): IGraphic<Partial<import("@visactor/vrender-core").IGraphicAttribute>>;
+    clearComponent(): void;
+    protected _getAttrsFromConfig(attrs?: IGroupGraphicAttribute): IGroupGraphicAttribute;
+    protected _attributesTransform: (attrs: any) => any;
+    setAttributeTransform(t: (attrs: any) => any): void;
+    renderInner(): void;
+    render(): void;
+    release(): void;
 }
 export declare const registerComponentMark: () => void;

package/types/mark/glyph.d.ts

@@ -0,0 +1,30 @@
+import type { ICommonSpec } from '../typings/visual';
+import { BaseMark } from './base/base-mark';
+import type { IGlyph, IGlyphGraphicAttribute, IGraphic } from '@visactor/vrender-core';
+import type { IGlyphMark } from './interface/mark';
+import type { MarkType } from './interface/type';
+import type { Datum } from '../typings/common';
+import type { IMarkGraphic } from './interface/common';
+export declare abstract class GlyphMark<T extends ICommonSpec = ICommonSpec, Cfg = any> extends BaseMark<T> implements IGlyphMark<T, Cfg> {
+    protected _defaultGlyphAttrs: T;
+    protected _subMarks: Record<string, {
+        type: MarkType;
+        defaultAttributes?: any;
+    }>;
+    getSubMarks(): Record<string, {
+        type: string;
+        defaultAttributes?: any;
+    }>;
+    protected _glyphConfig: Cfg;
+    setGlyphConfig(cfg: Cfg): void;
+    getGlyphConfig(): Cfg;
+    protected _positionChannels: string[];
+    getPositionChannels(): string[];
+    protected _positionEncoder: (glyphAttrs: any, datum: Datum, g: IGlyph) => Record<string, any>;
+    protected _channelEncoder: Record<string, (channelValue: any) => Record<string, any>>;
+    private _onGlyphAttributeUpdate;
+    protected _setStateOfGraphic: (g: IMarkGraphic) => void;
+    protected _createGraphic(attrs?: IGlyphGraphicAttribute): IGraphic;
+    protected _runProgressiveEncoder(graphics: IMarkGraphic[]): void;
+}
+export declare const registerGlyphMark: () => void;

package/types/mark/group.d.ts

@@ -1,18 +1,17 @@
 import type { Maybe } from '../typings';
 import type { IGroupMarkSpec } from '../typings/visual';
 import { BaseMark } from './base/base-mark';
-import type { IGroupMark, IMark, IMarkStyle, MarkType } from './interface';
+import type { AnimationStateValues, IGroupMark, IMark, IMarkGraphic, MarkType } from './interface';
 import { MarkTypeEnum } from './interface/type';
-import type { IGroupMark as IVGrammarGroupMark } from '@visactor/vgrammar-core';
-import type { IMarkCompileOption } from '../compile/mark';
+import { type IMarkCompileOption } from '../compile/mark';
+import type { IGroup, IGroupGraphicAttribute } from '@visactor/vrender-core';
 export declare class GroupMark extends BaseMark<IGroupMarkSpec> implements IGroupMark {
     static readonly type = MarkTypeEnum.group;
     readonly type = MarkTypeEnum.group;
     protected _marks: IMark[];
     getMarks(): IMark[];
-    protected _product: Maybe<IVGrammarGroupMark>;
-    getProduct: () => Maybe<IVGrammarGroupMark>;
-    protected _getDefaultStyle(): IMarkStyle<IGroupMarkSpec>;
+    protected _product: Maybe<IGroup>;
+    getProduct: () => Maybe<IGroup>;
     protected isMarkExist(mark: IMark): boolean;
     addMark(mark: IMark): boolean;
     removeMark(mark: IMark): boolean;
@@ -21,5 +20,11 @@ export declare class GroupMark extends BaseMark<IGroupMarkSpec> implements IGrou
     getMarkInUserId(id: string | number): IMark;
     getMarkInName(name: string): IMark[];
     protected _compileProduct(option?: IMarkCompileOption): void;
+    protected _getAttrsFromConfig(attrs?: IGroupGraphicAttribute): IGroupGraphicAttribute;
+    getGraphics(): IMarkGraphic[];
+    protected _renderSelf(): void;
+    render(): void;
+    updateAnimationState(callback: (g: IMarkGraphic) => AnimationStateValues): void;
+    release(): void;
 }
 export declare const registerGroupMark: () => void;