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

package/types/component/crosshair/polar.d.ts

@@ -1,40 +1,24 @@
 import type { IComponentOption } from '../interface';
 import { ComponentTypeEnum } from '../interface/type';
 import type { IPolarCrosshairSpec } from './interface';
-import type { TooltipActiveType, TooltipData } from '../../typings';
+import type { IPolarAxis } from '../axis/polar/interface';
+import type { IPoint, StringOrNumber, TooltipActiveType, TooltipData } from '../../typings';
 import { BaseCrossHair } from './base';
 import type { Maybe } from '@visactor/vutils';
-import type { IGraphic } from '@visactor/vrender-core';
 import type { IModelSpecInfo } from '../../model/interface';
+import type { IAxis } from '../axis';
 export declare class PolarCrossHair<T extends IPolarCrosshairSpec = IPolarCrosshairSpec> extends BaseCrossHair<T> {
     static specKey: string;
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
     name: string;
-    private _currValueAngle;
-    private _currValueRadius;
-    private _angleHair;
-    private _radiusHair;
-    private _cacheAngleCrossHairInfo;
-    private _cacheRadiusCrossHairInfo;
-    private _radiusCrosshair;
-    private _radiusLabelCrosshair;
-    private _angleCrosshair;
-    private _angleLabelCrosshair;
     static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
     constructor(spec: T, options: IComponentOption);
-    protected _showDefaultCrosshairBySpec(): void;
-    private _defaultCrosshair;
-    hide(): void;
+    setAxisValue(datum: StringOrNumber, axis: IAxis): void;
     private _findAllAxisContains;
-    private _getAllAxisValues;
-    private _getValueByAxis;
+    protected _getDatumAtPoint(axis: IPolarAxis, point: IPoint): any;
     protected _layoutCrosshair(relativeX: number, relativeY: number, tooltipData?: TooltipData, activeType?: TooltipActiveType): void;
     layoutByValue(tag?: number): void;
-    private _layoutAngle;
-    private _layoutRadius;
-    protected _parseFieldInfo(): void;
-    private _updateCrosshairLabel;
-    protected _getNeedClearVRenderComponents(): IGraphic[];
+    private _layoutByField;
 }
 export declare const registerPolarCrossHair: () => void;

package/types/component/crosshair/utils/cartesian.d.ts

@@ -1,34 +1,13 @@
 import type { ICartesianSeries } from '../../../series';
 import type { ILayoutPoint } from '../../../typings';
-import type { IHair } from '../base';
-import type { AxisCurrentValueMap, ICrosshairInfoX, ICrosshairInfoY } from '../interface';
-export declare const layoutByValue: (tag: number, series: ICartesianSeries, layoutStartPoint: ILayoutPoint, currValueX: AxisCurrentValueMap, currValueY: AxisCurrentValueMap, xHair: IHair, yHair: IHair, enableRemain?: boolean, cacheXCrossHairInfo?: ICrosshairInfoX, cacheYCrossHairInfo?: ICrosshairInfoY) => {
-    x: ICrosshairInfoX;
-    y: ICrosshairInfoY;
-    offsetWidth: number;
-    offsetHeight: number;
-    bandWidth: number;
-    bandHeight: number;
-};
-export declare const layoutVerticalCrosshair: (xHair: IHair, crosshairInfo: ICrosshairInfoX, bandWidth: number, offsetWidth: number) => {
-    visible: boolean;
-    start: {
-        x: number;
-        y: number;
-    };
-    end: {
-        x: number;
-        y: number;
-    };
-};
-export declare const layoutHorizontalCrosshair: (yHair: IHair, crosshairInfo: ICrosshairInfoY, bandHeight: number, offsetHeight: number) => {
+import type { CrossHairStateByField, CrossHairStateItem } from '../interface';
+export declare const layoutByValue: (stateByField: CrossHairStateByField, series: ICartesianSeries, layoutStartPoint: ILayoutPoint, enableRemain?: boolean) => CrossHairStateByField;
+export declare const layoutCrosshair: (stateItem: CrossHairStateItem) => {
     visible: boolean;
     start: {
-        x: number;
-        y: number;
+        [x: string]: number;
     };
     end: {
-        x: number;
-        y: number;
+        [x: string]: number;
     };
 };

package/types/component/crosshair/utils/polar.d.ts

@@ -1,18 +1,19 @@
 import type { IPolarSeries } from '../../../series';
-import type { IHair, IHairRadius } from '../base';
-import type { AxisCurrentValueMap, IPolarCrosshairInfo } from '../interface';
-export declare const layoutByValue: (series: IPolarSeries, currValueAngle: AxisCurrentValueMap, currValueRadius: AxisCurrentValueMap, angleHair: IHair, radiusHair: IHair, enableRemain?: boolean, cacheAngleCrossHairInfo?: IPolarCrosshairInfo, cacheRadiusCrossHairInfo?: IPolarCrosshairInfo) => {
-    angle: IPolarCrosshairInfo;
-    radius: IPolarCrosshairInfo;
-};
-export declare const layoutAngleCrosshair: (angleHair: IHair, crosshairInfo: IPolarCrosshairInfo) => {
-    center: import("../../../typings").IPoint;
+import type { CrossHairStateByField, CrossHairStateItem } from '../interface';
+import type { ILayoutPoint } from '../../../typings/layout';
+export declare const layoutByValue: (stateByField: CrossHairStateByField, series: IPolarSeries, enableRemain?: boolean) => void;
+export declare const layoutCrosshair: (stateItem: CrossHairStateItem, layoutStartPoint: ILayoutPoint, smooth?: boolean) => {
+    center: {
+        x: number;
+        y: number;
+    };
     innerRadius: number;
     radius: number;
     startAngle: number;
     endAngle: number;
     start?: undefined;
     end?: undefined;
+    sides?: undefined;
 } | {
     start: {
         x: number;
@@ -27,11 +28,17 @@ export declare const layoutAngleCrosshair: (angleHair: IHair, crosshairInfo: IPo
     radius?: undefined;
     startAngle?: undefined;
     endAngle?: undefined;
-};
-export declare const layoutRadiusCrosshair: (radiusHair: IHairRadius, crosshairInfo: IPolarCrosshairInfo) => {
-    center: import("../../../typings").IPoint;
+    sides?: undefined;
+} | {
+    center: {
+        x: number;
+        y: number;
+    };
     startAngle: number;
     endAngle: number;
     radius: number;
     sides: number;
+    innerRadius?: undefined;
+    start?: undefined;
+    end?: undefined;
 };

package/types/component/data-zoom/data-filter-base-component.d.ts

@@ -79,7 +79,7 @@ export declare abstract class DataFilterBaseComponent<T extends IDataFilterCompo
     protected _initEvent(): void;
     protected _initData(): void;
     setAttrFromSpec(): void;
-    protected _statePointToData(state: number): any;
+    statePointToData(state: number): any;
     dataToStatePoint(data: number | string): number;
     protected _modeCheck(statePoint: 'start' | 'end', mode: string): any;
     protected _setStateFromSpec(): void;
@@ -105,7 +105,7 @@ export declare abstract class DataFilterBaseComponent<T extends IDataFilterCompo
         zoomDelta: number;
         zoomX?: number;
         zoomY?: number;
-    }) => void;
+    }, e?: BaseEventParams['event']) => void;
     protected _handleChartScroll: (params: {
         scrollX: number;
         scrollY: number;
@@ -115,8 +115,8 @@ export declare abstract class DataFilterBaseComponent<T extends IDataFilterCompo
     protected _initCommonEvent(): void;
     updateLayoutAttribute(): void;
     protected _autoVisible(isShown: boolean): void;
-    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect, ctx: any): void;
-    onLayoutEnd(ctx: any): void;
+    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect): void;
+    onLayoutEnd(): void;
     getBoundsInRect(rect: ILayoutRect): IBoundsLike;
     hide(): void;
     show(): void;

package/types/component/data-zoom/data-zoom/data-zoom.d.ts

@@ -28,7 +28,7 @@ export declare class DataZoom<T extends IDataZoomSpec = IDataZoomSpec> extends D
     constructor(spec: T, options: IComponentOption);
     created(): void;
     setAttrFromSpec(): void;
-    onLayoutEnd(ctx: any): void;
+    onLayoutEnd(): void;
     protected _initValueScale(): void;
     protected _updateScaleRange(): void;
     protected _computeDomainOfValueScale(): unknown[];

package/types/component/data-zoom/interface.d.ts

@@ -1,3 +1,4 @@
+import type { BaseEventParams } from '../../event/interface';
 import type { IOrientType } from '../../typings';
 import type { IDelayType } from '../../typings/event';
 import type { IComponentSpec } from '../base/interface';
@@ -35,12 +36,22 @@ export interface IDataFilterComponentSpec extends Omit<IComponentSpec, 'width' |
 }
 export interface IRoamDragSpec extends IRoamSpec {
     reverse?: boolean;
+    filter?: (delta: [number, number], e?: BaseEventParams['event']) => boolean;
 }
 export interface IRoamScrollSpec extends IRoamSpec {
     reverse?: boolean;
+    filter?: (params: {
+        scrollX: number;
+        scrollY: number;
+    }, e?: BaseEventParams['event']) => boolean;
 }
 export interface IRoamZoomSpec extends IRoamSpec {
     focus?: boolean;
+    filter?: (params: {
+        zoomDelta: number;
+        zoomX?: number;
+        zoomY?: number;
+    }, e?: BaseEventParams['event']) => boolean;
 }
 export interface IRoamSpec {
     enable?: boolean;

package/types/component/data-zoom/scroll-bar/scroll-bar.d.ts

@@ -18,7 +18,7 @@ export declare class ScrollBar<T extends IScrollBarSpec = IScrollBarSpec> extend
     protected _component: ScrollBarComponent;
     constructor(spec: T, options: IComponentOption);
     setAttrFromSpec(): void;
-    onLayoutEnd(ctx: any): void;
+    onLayoutEnd(): void;
     protected _updateScaleRange(): void;
     protected _computeWidth(): number;
     protected _computeHeight(): number;
@@ -26,7 +26,6 @@ export declare class ScrollBar<T extends IScrollBarSpec = IScrollBarSpec> extend
     protected _createOrUpdateComponent(): void;
     protected _handleChange(start: number, end: number, updateComponent?: boolean): void;
     protected _handleDataCollectionChange(): void;
-    protected _initCommonEvent(): void;
     protected _getComponentAttrs(): Partial<ScrollBarAttributes>;
     protected _getNeedClearVRenderComponents(): IGraphic[];
 }

package/types/component/geo/geo-coordinate.d.ts

@@ -1,6 +1,6 @@
 import type { IPoint } from '../../typings/coordinate';
 import { Projection } from './projection';
-import type { IEffect, IModelLayoutOption, IModelRenderOption, IModelSpecInfo } from '../../model/interface';
+import type { IEffect, IModelRenderOption, IModelSpecInfo } from '../../model/interface';
 import { ComponentTypeEnum } from '../interface/type';
 import { BaseComponent } from '../base/base-component';
 import type { IGeoRegionSpec, IRegion } from '../../region/interface';
@@ -42,7 +42,7 @@ export declare class GeoCoordinate extends BaseComponent<IGeoRegionSpec> impleme
     initEvent(): void;
     initProjection(): void;
     coordinateHelper(): void;
-    onLayoutEnd(ctx: IModelLayoutOption): void;
+    onLayoutEnd(): void;
     onRender(ctx: IModelRenderOption): void;
     changeRegions(regions: IRegion[]): void;
     protected _getNeedClearVRenderComponents(): IGraphic[];

package/types/component/geo/interface.d.ts

@@ -1,6 +1,6 @@
 import type { IPoint } from '../../typings/coordinate';
-import type { ProjectionType } from '@visactor/vgrammar-core';
 import type { IComponent } from '../interface';
+export type ProjectionType = 'albers' | 'albersUsa' | 'azimuthalEqualArea' | 'azimuthalEquidistant' | 'conicConformal' | 'conicEqualArea' | 'conicEquidistant' | 'equalEarth' | 'equirectangular' | 'gnomonic' | 'identity' | 'mercator' | 'naturalEarth1' | 'orthographic' | 'stereographic' | 'transverseMercator';
 export interface IProjectionSpec {
     name: string;
     type: ProjectionType;

package/types/component/label/base-label.d.ts

@@ -5,6 +5,9 @@ import type { IRegion } from '../../region/interface';
 import type { IModelRenderOption } from '../../model/interface';
 import type { ILabelSpec } from './interface';
 import type { IGraphic } from '@visactor/vrender-core';
+import type { IComponentMark } from '../../mark/interface/mark';
+import type { ICompilableMark } from '../../compile/mark/interface';
+import type { IMark } from '../../mark/interface/common';
 export declare abstract class BaseLabelComponent<T = any> extends BaseComponent<T> {
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
@@ -29,6 +32,8 @@ export declare abstract class BaseLabelComponent<T = any> extends BaseComponent<
         reSize: boolean;
         reCompile: boolean;
     };
+    _getDataLabelType(baseMark: ICompilableMark, type?: string): string;
+    _setTransformOfComponent(labelComponent: IComponentMark, baseMark: IMark | IMark[]): void;
     onRender(ctx: IModelRenderOption): void;
     changeRegions(regions: IRegion[]): void;
     protected _getNeedClearVRenderComponents(): IGraphic[];

package/types/component/label/interface.d.ts

@@ -1,12 +1,11 @@
 import type { BaseLabelAttrs } from '@visactor/vrender-components';
 import type { ConvertToMarkStyleSpec, Datum, IComposedTextMarkSpec, IFormatMethod, ITextMarkSpec } from '../../typings';
 import type { IComponentSpec } from '../base/interface';
-import type { ILabelMark } from '../../mark/interface';
+import type { ILabelMark, IMark } from '../../mark/interface';
 import type { ISeries } from '../../series/interface';
-import type { ICompilableMark } from '../../compile/mark/interface';
 import type { IRegion } from '../../region/interface';
 export interface ILabelInfo {
-    baseMark: ICompilableMark;
+    baseMark: IMark;
     labelMark: ILabelMark;
     series: ISeries;
     labelSpec: TransformedLabelSpec;
@@ -34,9 +33,11 @@ export interface ILabelSpec extends IComponentSpec, ILabelAnimationSpec {
     dataFilter?: BaseLabelAttrs['dataFilter'];
     customLayoutFunc?: BaseLabelAttrs['customLayoutFunc'];
     customOverlapFunc?: BaseLabelAttrs['customOverlapFunc'];
+    onAfterOverlapping?: BaseLabelAttrs['onAfterOverlapping'];
     labelLayout?: 'series' | 'region';
     support3d?: boolean;
     syncState?: boolean;
+    showRelatedMarkTooltip?: boolean;
 }
 export type ILabelAnimationSpec = Pick<BaseLabelAttrs, 'animation' | 'animationEnter' | 'animationUpdate' | 'animationExit'>;
 export type IMultiLabelSpec<T extends Omit<ILabelSpec, 'position'>> = T | T[];

package/types/component/label/label.d.ts

@@ -2,14 +2,15 @@ import type { IComponentOption } from '../interface';
 import { ComponentTypeEnum } from '../interface/type';
 import type { IRegion } from '../../region/interface';
 import type { IModelInitOption, IModelSpecInfo } from '../../model/interface';
-import type { IComponentMark } from '../../mark/interface';
-import type { ILabel, IMark as IVGrammarMark } from '@visactor/vgrammar-core';
+import type { IMark } from '../../mark/interface';
+import { type IComponentMark } from '../../mark/interface';
 import { BaseLabelComponent } from './base-label';
 import type { Maybe } from '@visactor/vutils';
 import type { ILabelInfo } from './interface';
 import type { IChartSpecInfo } from '../../chart/interface';
 import type { IChartSpec } from '../../typings';
 import { LabelSpecTransformer } from './label-transformer';
+import type { IGraphic } from '@visactor/vrender-core';
 export declare class Label<T extends IChartSpec = any> extends BaseLabelComponent<T> {
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
@@ -33,8 +34,9 @@ export declare class Label<T extends IChartSpec = any> extends BaseLabelComponen
     updateLayoutAttribute(): void;
     protected _updateMultiLabelAttribute(labelInfo: ILabelInfo[], labelComponent: IComponentMark): void;
     protected _updateSingleLabelAttribute(labelInfo: ILabelInfo, labelComponent: IComponentMark): void;
-    protected _updateLabelComponentAttribute(component: ILabel, target: IVGrammarMark | IVGrammarMark[], labelInfos: ILabelInfo[]): void;
+    protected _updateLabelComponentAttribute(labelComponent: IComponentMark, baseMark: IMark | IMark[], labelInfos: ILabelInfo[]): void;
     compileMarks(): void;
     getVRenderComponents(): any[];
+    getLabelInfoByTextGraphic(text: IGraphic): ILabelInfo;
 }
 export declare const registerLabel: () => void;

package/types/component/label/util.d.ts

@@ -1,6 +1,6 @@
 import type { WaterfallSeries } from './../../series/waterfall/waterfall';
 import type { Datum } from '../../typings/common';
-import type { LabelItem, Strategy } from '@visactor/vrender-components';
+import type { LabelItem, OverlapAttrs, Strategy } from '@visactor/vrender-components';
 import type { ILabelInfo, ILabelSpec } from './interface';
 export declare const labelRuleMap: {
     rect: typeof barLabel;
@@ -17,20 +17,14 @@ export declare const labelRuleMap: {
     venn: typeof vennLabel;
 };
 export declare function defaultLabelConfig(rule: string, labelInfo: ILabelInfo): any;
-export declare function textAttribute(labelInfo: ILabelInfo, datum: Datum, formatMethod?: ILabelSpec['formatMethod'], formatter?: ILabelSpec['formatter']): any;
+export declare function textAttribute(labelInfo: ILabelInfo, datum: Datum, formatMethod?: ILabelSpec['formatMethod'], formatter?: ILabelSpec['formatter']): Partial<import("../../typings").IComposedTextMarkSpec>;
 export declare function symbolLabel(labelInfo: ILabelInfo): {
     position: string | ((datum: Datum) => any);
-    overlap: boolean | {
-        strategy: Strategy[] | import("@visactor/vrender-components").ShiftYStrategy;
-        avoidBaseMark: boolean;
-    };
+    overlap: boolean | OverlapAttrs;
 };
 export declare function lineDataLabel(labelInfo: ILabelInfo): {
     position: string | ((datum: Datum) => any);
-    overlap: boolean | {
-        strategy: Strategy[] | import("@visactor/vrender-components").ShiftYStrategy;
-        avoidBaseMark: boolean;
-    };
+    overlap: boolean | OverlapAttrs;
 };
 export declare function barLabel(labelInfo: ILabelInfo): {
     position: (data: any) => string;
@@ -42,6 +36,7 @@ export declare function barLabel(labelInfo: ILabelInfo): {
 export declare function pointLabel(labelInfo: ILabelInfo): {
     position: string;
     overlap: boolean | {
+        clampForce: boolean;
         avoidBaseMark: boolean;
     };
 };
@@ -69,6 +64,10 @@ export declare function vennLabel(labelInfo: ILabelInfo): {
 export declare function LineLabel(labelInfo: ILabelInfo): {
     position: string;
     data: any;
+    overlap: {
+        avoidBaseMark: boolean;
+        clampForce: boolean;
+    };
 };
 export declare function sankeyLabel(labelInfo: ILabelInfo): {
     position: import("@visactor/vrender-components").Functional<string>;

package/types/component/legend/util.d.ts

@@ -13,7 +13,7 @@ export declare function transformLegendTitleAttributes(title: ITitle): {
     };
     background?: {
         visible?: boolean;
-        style?: Omit<import("./interface").NoVisibleMarkStyle<import("../..").IRectMarkSpec>, "width" | "height" | "visible">;
+        style?: Omit<import("./interface").NoVisibleMarkStyle<import("../..").IRectMarkSpec>, "visible" | "width" | "height">;
     };
     text?: string | number | string[] | number[] | {
         type?: "text";
@@ -32,10 +32,10 @@ export declare function transformLegendTitleAttributes(title: ITitle): {
             element: any;
         } & import("@visactor/vrender-core").SimpleDomStyleOptions & import("@visactor/vrender-core").CommonDomOptions;
     };
+    visible?: boolean;
+    align?: "start" | "end" | "center";
     padding?: import("@visactor/vrender-components").Padding;
     maxWidth?: number;
     minWidth?: number;
-    visible?: boolean;
     space?: number;
-    align?: "start" | "end" | "center";
 };

package/types/component/marker/base-marker.d.ts

@@ -59,7 +59,7 @@ export declare abstract class BaseMarker<T extends IMarkerSpec> extends BaseComp
     clear(): void;
     private _getFirstSeries;
     protected _getNeedClearVRenderComponents(): IGraphic[];
-    onLayoutStart(layoutRect: IRect, chartViewRect: ILayoutRect, ctx: any): void;
+    onLayoutStart(layoutRect: IRect, chartViewRect: ILayoutRect): void;
     _compareSpec(spec: T, prevSpec: T): {
         change: boolean;
         reMake: boolean;

package/types/component/tooltip/processor/interface.d.ts

@@ -1,7 +1,7 @@
-import type { Datum } from '@visactor/vgrammar-core';
 import type { IMark } from '../../../mark/interface';
 import type { ISeries } from '../../../series/interface';
 import type { IDimensionInfo } from '../../../event/events/dimension/interface';
+import type { Datum } from '../../../typings/common';
 export type DimensionTooltipInfo = IDimensionInfo[];
 export type MarkTooltipInfo<T = Datum> = {
     datum: T;

package/types/component/tooltip/processor/util.d.ts

@@ -1,4 +1,4 @@
 import type { Maybe } from '@visactor/vutils';
 import type { DimensionTooltipInfo, MarkTooltipInfo, TooltipInfo } from './interface';
-export declare const isMarkInfo: (info: Maybe<TooltipInfo>) => info is MarkTooltipInfo<any>;
+export declare const isMarkInfo: (info: Maybe<TooltipInfo>) => info is MarkTooltipInfo<import("../../../typings").Datum>;
 export declare const isDimensionInfo: (info: Maybe<TooltipInfo>) => info is DimensionTooltipInfo;

package/types/component/tooltip/tooltip.d.ts

@@ -1,5 +1,5 @@
 import { ComponentTypeEnum } from '../interface/type';
-import type { IModelLayoutOption, IModelRenderOption } from '../../model/interface';
+import type { IModelRenderOption } from '../../model/interface';
 import type { IRegion } from '../../region/interface';
 import { BaseComponent } from '../base/base-component';
 import type { BaseEventParams, EventCallback, EventQuery, EventType } from '../../event/interface';
@@ -26,6 +26,7 @@ export declare class Tooltip extends BaseComponent<any> implements ITooltip {
     private _needInitEventOfTooltip?;
     private _enterable;
     private _isReleased;
+    private _isEnterTooltip;
     protected _spec: ITooltipSpec;
     tooltipHandler?: ITooltipHandler;
     processor: ITooltipActiveTypeAsKeys<MarkTooltipProcessor, DimensionTooltipProcessor, GroupTooltipProcessor>;
@@ -43,8 +44,7 @@ export declare class Tooltip extends BaseComponent<any> implements ITooltip {
     protected _getNeedClearVRenderComponents(): IGraphic[];
     protected _registerEvent(): void;
     protected _releaseEvent(): void;
-    onLayout(ctx: IModelLayoutOption): void;
-    onLayoutEnd(ctx: IModelLayoutOption): void;
+    onLayoutEnd(): void;
     onRender(ctx: IModelRenderOption): void;
     created(): void;
     release(): void;

package/types/constant/data.d.ts

@@ -20,3 +20,4 @@ export declare const MOSAIC_CAT_START_PERCENT: string;
 export declare const MOSAIC_CAT_END_PERCENT: string;
 export declare const SEGMENT_FIELD_START: string;
 export declare const SEGMENT_FIELD_END: string;
+export declare const DEFAULT_KEY: string;

package/types/constant/event.d.ts

@@ -1,4 +1,54 @@
-export { HOOK_EVENT as VGRAMMAR_HOOK_EVENT } from '@visactor/vgrammar-core';
+export declare enum HOOK_EVENT {
+    BEFORE_EVALUATE_DATA = "beforeEvaluateData",
+    AFTER_EVALUATE_DATA = "afterEvaluateData",
+    BEFORE_EVALUATE_SCALE = "beforeEvaluateScale",
+    AFTER_EVALUATE_SCALE = "afterEvaluateScale",
+    BEFORE_PARSE_VIEW = "beforeParseView",
+    AFTER_PARSE_VIEW = "afterParseView",
+    BEFORE_TRANSFORM = "beforeTransform",
+    AFTER_TRANSFORM = "afterTransform",
+    BEFORE_CREATE_VRENDER_STAGE = "beforeCreateVRenderStage",
+    AFTER_CREATE_VRENDER_STAGE = "afterCreateVRenderStage",
+    BEFORE_CREATE_VRENDER_LAYER = "beforeCreateVRenderLayer",
+    AFTER_CREATE_VRENDER_LAYER = "afterCreateVRenderLayer",
+    BEFORE_STAGE_RESIZE = "beforeStageResize",
+    AFTER_STAGE_RESIZE = "afterStageResize",
+    BEFORE_VRENDER_DRAW = "beforeVRenderDraw",
+    AFTER_VRENDER_DRAW = "afterVRenderDraw",
+    BEFORE_MARK_JOIN = "beforeMarkJoin",
+    AFTER_MARK_JOIN = "afterMarkJoin",
+    BEFORE_MARK_UPDATE = "beforeMarkUpdate",
+    AFTER_MARK_UPDATE = "afterMarkUpdate",
+    BEFORE_MARK_STATE = "beforeMarkState",
+    AFTER_MARK_STATE = "afterMarkState",
+    BEFORE_MARK_ENCODE = "beforeMarkEncode",
+    AFTER_MARK_ENCODE = "afterMarkEncode",
+    BEFORE_DO_LAYOUT = "beforeDoLayout",
+    AFTER_DO_LAYOUT = "afterDoLayout",
+    BEFORE_MARK_LAYOUT_END = "beforeMarkLayoutEnd",
+    AFTER_MARK_LAYOUT_END = "afterMarkLayoutEnd",
+    BEFORE_DO_RENDER = "beforeDoRender",
+    AFTER_DO_RENDER = "afterDoRender",
+    BEFORE_MARK_RENDER_END = "beforeMarkRenderEnd",
+    AFTER_MARK_RENDER_END = "afterMarkRenderEnd",
+    BEFORE_CREATE_VRENDER_MARK = "beforeCreateVRenderMark",
+    AFTER_CREATE_VRENDER_MARK = "afterCreateVRenderMark",
+    BEFORE_ADD_VRENDER_MARK = "beforeAddVRenderMark",
+    AFTER_ADD_VRENDER_MARK = "afterAddVRenderMark",
+    AFTER_VRENDER_NEXT_RENDER = "afterVRenderNextRender",
+    BEFORE_ELEMENT_UPDATE_DATA = "beforeElementUpdateData",
+    AFTER_ELEMENT_UPDATE_DATA = "afterElementUpdateData",
+    BEFORE_ELEMENT_STATE = "beforeElementState",
+    AFTER_ELEMENT_STATE = "afterElementState",
+    BEFORE_ELEMENT_ENCODE = "beforeElementEncode",
+    AFTER_ELEMENT_ENCODE = "afterElementEncode",
+    ANIMATION_START = "animationStart",
+    ANIMATION_END = "animationEnd",
+    ELEMENT_ANIMATION_START = "elementAnimationStart",
+    ELEMENT_ANIMATION_END = "elementAnimationEnd",
+    ALL_ANIMATION_START = "allAnimationStart",
+    ALL_ANIMATION_END = "allAnimationEnd"
+}
 export declare const BASE_EVENTS: string[];
 export declare enum ChartEvent {
     initialized = "initialized",
@@ -43,7 +93,8 @@ export declare enum ChartEvent {
     tooltipRelease = "tooltipRelease",
     afterResize = "afterResize",
     afterRender = "afterRender",
-    afterLayout = "afterLayout"
+    afterLayout = "afterLayout",
+    afterMarkLayoutEnd = "afterMarkLayoutEnd"
 }
 export declare enum Event_Source_Type {
     chart = "chart",

package/types/core/factory.d.ts

@@ -1,18 +1,22 @@
 import type { IChartConstructor, IChartOption, IChart, IChartSpecTransformerOption, IChartSpecTransformer } from '../chart/interface';
 import type { ISeriesConstructor, ISeriesMarkInfo, ISeriesOption, SeriesMarkNameEnum } from '../series/interface';
 import type { IComponentConstructor } from '../component/interface';
-import type { IMarkOption, MarkConstructor } from '../mark/interface';
+import type { IMarkDataTransform, IMarkOption, MarkConstructor } from '../mark/interface';
 import type { IRegion, IRegionConstructor } from '../region/interface';
 import type { IBaseModelSpecTransformer, IBaseModelSpecTransformerOption, IModelOption } from '../model/interface';
 import type { Transform, Parser } from '@visactor/vdataset';
 import type { ILayoutConstructor } from '../layout/interface';
-import type { MarkAnimationSpec } from '@visactor/vgrammar-core';
 import type { IChartPluginConstructor } from '../plugin/chart/interface';
 import type { IComponentPluginConstructor } from '../plugin/components/interface';
+import type { IGraphic } from '@visactor/vrender-core';
+import type { IStageEventPlugin, VRenderComponentOptions } from './interface';
+import type { MarkAnimationSpec } from '../animation/interface';
+import type { IBaseTriggerOptions, ITriggerConstructor } from '../interaction/interface/trigger';
 export declare class Factory {
     private static _charts;
     private static _series;
     private static _components;
+    private static _graphicComponents;
     private static _marks;
     private static _regions;
     private static _animations;
@@ -31,10 +35,23 @@ export declare class Factory {
     };
     static registerChart(key: string, chart: IChartConstructor): void;
     static registerSeries(key: string, series: ISeriesConstructor): void;
-    static registerComponent(key: string, cmp: IComponentConstructor, alwaysCheck?: boolean): void;
+    static registerComponent(key: string, cmp: IComponentConstructor, alwaysCheck?: boolean, createOrder?: number): void;
+    static registerGraphicComponent(key: string, creator: (attrs: any, options?: VRenderComponentOptions) => IGraphic): void;
+    static createGraphicComponent(componentType: string, attrs: any, options?: VRenderComponentOptions): IGraphic<Partial<import("@visactor/vrender-core").IGraphicAttribute>>;
     static registerMark(key: string, mark: MarkConstructor): void;
     static registerRegion(key: string, region: IRegionConstructor): void;
     static registerTransform(key: string, transform: Transform): void;
+    private static _grammarTransforms;
+    static registerGrammarTransform(type: string, transform: {
+        canProgressive?: boolean;
+        transform: IMarkDataTransform;
+        isGraphic?: boolean;
+    }): void;
+    static getGrammarTransform(type: string): {
+        canProgressive?: boolean;
+        transform: IMarkDataTransform<any, any, any>;
+        isGraphic?: boolean;
+    };
     static registerLayout(key: string, layout: ILayoutConstructor): void;
     static registerAnimation(key: string, animation: (params?: any, preset?: any) => MarkAnimationSpec): void;
     static registerImplement(key: string, implement: (...args: any) => void): void;
@@ -50,6 +67,7 @@ export declare class Factory {
     static getComponents(): {
         cmp: IComponentConstructor;
         alwaysCheck?: boolean;
+        createOrder: number;
     }[];
     static getComponentInKey(name: string): IComponentConstructor;
     static getLayout(): ILayoutConstructor[];
@@ -65,4 +83,11 @@ export declare class Factory {
     static getComponentPluginInType(type: string): IComponentPluginConstructor;
     static registerFormatter(func: typeof Factory['_formatter']): void;
     static getFormatter(): (text: string | number | string[] | number[], datum: any, formatter: string | string[]) => any;
+    private static _stageEventPlugins;
+    static registerStageEventPlugin: (type: string, Plugin: IStageEventPlugin<any>) => void;
+    static getStageEventPlugin: (type: string) => IStageEventPlugin<any>;
+    private static _interactionTriggers;
+    static registerInteractionTrigger: (interactionType: string, interaction: ITriggerConstructor) => void;
+    static createInteractionTrigger(interactionType: string, options?: IBaseTriggerOptions): import("../interaction/interface/trigger").ITrigger<IBaseTriggerOptions>;
+    static hasInteractionTrigger(interactionType: string): boolean;
 }

package/types/core/index.d.ts

@@ -9,9 +9,10 @@ export * from '../typings/spec/common';
 export * from '../event/interface';
 export * from '../theme/interface';
 export * from './interface';
+export type { IMarkGraphic, IGraphicContext } from '../mark/interface/';
 export * from '../constant/base';
 export * from '../constant/data';
 export * from '../typings/spec/index';
 export * from '../typings/tooltip';
 export * from '../theme/index';
-export { vglobal } from '@visactor/vrender-core';
+export { vglobal, createGroup, createRichText, createText, createArc, createArea, createRect, createLine, createSymbol } from '@visactor/vrender-core';