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

package/types/interaction/triggers/element-highlight-by-name.d.ts

@@ -0,0 +1,24 @@
+import { BaseTrigger } from './base';
+import type { IElementHighlightByNameOptions, ITrigger } from '../interface/trigger';
+import type { BaseEventParams } from '../../event/interface';
+import type { IMarkGraphic } from '../../mark/interface';
+export declare class ElementHighlightByName extends BaseTrigger<IElementHighlightByNameOptions> implements ITrigger<IElementHighlightByNameOptions> {
+    static type: string;
+    type: string;
+    static defaultOptions: Partial<IElementHighlightByNameOptions>;
+    constructor(options?: IElementHighlightByNameOptions);
+    getStartState(): string;
+    getResetState(): string;
+    protected getEvents(): {
+        type: "none" | import("@visactor/vrender-core").GraphicEventType;
+        handler: (e: BaseEventParams) => void;
+    }[];
+    protected _filterByName(e: BaseEventParams): boolean;
+    protected _parseTargetKey(e: BaseEventParams): any;
+    start(itemKey: any): void;
+    resetAll(): void;
+    reset(g?: IMarkGraphic): void;
+    handleStart: (e: BaseEventParams) => void;
+    handleReset: (e: BaseEventParams) => void;
+}
+export declare const registerElementHighlightByName: () => void;

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

@@ -0,0 +1,25 @@
+import type { IElementHighlightOptions, ITrigger } from '../interface/trigger';
+import type { IMarkGraphic } from '../../mark/interface/common';
+import { BaseTrigger } from './base';
+import type { GraphicEventType } from '@visactor/vrender-core';
+import type { BaseEventParams } from '../../event/interface';
+export declare class ElementHighlight extends BaseTrigger<IElementHighlightOptions> implements ITrigger<IElementHighlightOptions> {
+    static type: string;
+    type: string;
+    static defaultOptions: Partial<IElementHighlightOptions>;
+    protected _lastGraphic?: IMarkGraphic;
+    constructor(options?: IElementHighlightOptions);
+    getStartState(): string;
+    getResetState(): string;
+    protected _resetType?: 'view' | 'self';
+    protected getEvents(): {
+        type: 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 registerElementHighlight: () => void;

package/types/interaction/triggers/element-select-by-graphic-name.d.ts

@@ -0,0 +1,8 @@
+import type { IMarkGraphic } from '../../mark/interface/common';
+import { ElementSelect } from './element-select';
+export declare class ElementSelectByGraphicName extends ElementSelect {
+    static type: string;
+    type: string;
+    start(markGraphic: IMarkGraphic): void;
+}
+export declare const registerElementSelectByGraphicName: () => void;

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,8 @@
+export declare const enum TRIGGER_TYPE_ENUM {
+    DIMENSION_HOVER = "dimension-hover",
+    ELEMENT_HIGHLIGHT = "element-highlight",
+    ELEMENT_SELECT = "element-select",
+    ELEMENT_ACTIVE = "element-active",
+    ELEMENT_HIGHLIGHT_BY_GRPHIC_NAME = "element-highlight-by-graphic-name",
+    ELEMENT_SELECT_BY_GRPHIC_NAME = "element-select-by-graphic-name"
+}

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;

package/types/layout/interface.d.ts

@@ -76,8 +76,8 @@ 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;

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;
@@ -51,8 +50,8 @@ export declare class LayoutItem implements ILayoutItem {
     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;

package/types/mark/arc.d.ts

@@ -10,8 +10,8 @@ export declare class BaseArcMark<T extends IArcMarkSpec> extends BaseMark<T> imp
     };
     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,22 @@
 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, IMarkStyle } from '../interface';
+import type { Datum } from '../../typings/common';
+import type { 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>;
 }

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, MarkType } from '../interface';
+import { MarkStateManager } from '../../compile/mark';
+import type { ICompilableMark, IMarkCompileOption, IMarkConfig, StateValueType } from '../../compile/mark';
+import type { ICompilableInitOption } from '../../compile/interface';
+import type { IGroupGraphicAttribute, IGroup } 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: MarkStateManager;
+    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 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,50 @@ 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 _graphicMap: Map<string, IMarkGraphic>;
+    protected _graphics: IMarkGraphic[];
+    protected _keyGetter: (datum: Datum) => string;
+    protected _groupKeyGetter: (datum: Datum) => string;
+    private renderContext?;
+    protected _getDataByKey(data: Datum[]): GroupedData<Datum>;
+    protected _getCommonContext(): {
+        markType: MarkTypeEnum;
+        markId: number;
+        modelId: number;
+        markUserId: StringOrNumber;
+        modelUserId: StringOrNumber;
+    };
+    reuse(mark: IMark): void;
+    getGraphics(): IMarkGraphic[];
+    protected _createGraphic(attrs?: any): IMarkGraphic;
+    protected _runGroupData(data: Datum[]): 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>>, splitGroupEncoder?: boolean): {
+        updateStyles: Record<string, (datum: Datum) => any>;
+        groupStyles: Record<string, (datum: Datum) => any>;
+    };
+    protected _getEncoderByState: (stateName: string) => Record<string, (datum: Datum) => any>;
+    protected _setGraphicFromMarkConfig: (g: IMarkGraphic) => void;
+    protected _setStateOfGraphic: (g: IMarkGraphic) => void;
+    protected _runEncoder(splitGroupEncoder?: boolean): void;
+    protected _runState(): void;
+    protected _getAttrsFromConfig(attrs?: IGroupGraphicAttribute): IGroupGraphicAttribute;
+    protected _updateAttrsOfGroup(): void;
+    protected runBeforeTransform(data: Datum[]): Datum[];
+    protected _runMainTasks(): void;
+    render(): void;
+    updateMarkState(key: string): void;
+    protected _cleanExitGraphics(): void;
+    isProgressive(): boolean;
+    canAnimateAfterProgressive(): boolean;
+    isDoingProgressive(): boolean;
+    clearProgressive(): void;
+    restartProgressive(): void;
+    protected renderBeforeProgressive(): void;
+    renderProgressive(): 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 { 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: IGraphic, attrs: any, groupAttrs?: any): any;
 }
 export declare const registerCellMark: () => void;

package/types/mark/component.d.ts

@@ -1,14 +1,22 @@
-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>>;
+    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,29 @@
+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;
+}
+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 { 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,10 @@ 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;
+    release(): void;
 }
 export declare const registerGroupMark: () => void;

package/types/mark/index.d.ts

@@ -15,7 +15,9 @@ import { BaseMark } from './base';
 import { PolygonMark, registerPolygonMark } from './polygon/polygon';
 import { Pyramid3dMark, registerPyramid3dMark } from './polygon/pyramid-3d';
 import { ImageMark, registerImageMark } from './image';
+import { registerMarkFilterTransform } from './transform/filter';
+import { registerMarkMapTransform } from './transform/map';
 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 };
+export { registerLineMark, registerSymbolMark, registerGroupMark, registerRuleMark, registerTextMark, registerAreaMark, registerRectMark, registerRect3dMark, registerPathMark, registerArcMark, registerArc3dMark, registerPolygonMark, registerPyramid3dMark, registerRippleMark, registerImageMark, registerComponentMark, registerMarkMapTransform, registerMarkFilterTransform };
 export declare const registerAllMarks: () => void;

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

@@ -2,11 +2,11 @@ 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';
 export interface VisualScaleType {
     scale: IBaseScale;
     field: StringOrNumber;
@@ -33,22 +33,52 @@ 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 interface IGraphicContext {
+    markType: MarkTypeEnum;
+    markId: number;
+    modelId: number;
+    markUserId?: number | string;
+    modelUserId?: number | string;
+    diffState?: DiffStateValues;
+    data?: Datum[];
+    uniqueKey?: string;
+    key?: string;
+    groupKey?: string;
+    states?: string[];
+}
+export interface IMarkGraphic extends IGraphic {
+    runtimeStateCache?: Record<string, any>;
+    context?: IGraphicContext;
+}
 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;
+    isProgressive: () => boolean;
+    isDoingProgressive: () => boolean;
+    clearProgressive: () => void;
+    restartProgressive: () => void;
+    renderProgressive: () => void;
+    canAnimateAfterProgressive: () => boolean;
 }
 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 +89,7 @@ export interface IMarkOption extends ICompilableMarkOption {
     seriesId?: number;
     componentType?: string;
     attributeContext?: IModelMarkAttributeContext;
+    parent?: IGroupMark | false;
 }
 export interface IMarkConstructor {
     type: MarkType;
@@ -85,3 +116,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';