@visactor/vchart-types 1.13.1 → 1.13.2

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

@@ -5,9 +5,8 @@ import type { IComposedTextMarkSpec, IFormatMethod, IRectMarkSpec, IRichTextForm
 import type { IComponentSpec } from '../base/interface';
 import type { Datum } from '@visactor/vrender-components';
 import type { ICartesianSeries, IGeoSeries, IPolarSeries } from '../../series/interface';
-import type { IOptionAggr, IOptionAggrField, IOptionSeries, IOptionWithCoordinates } from '../../data/transforms/aggregation';
-import type { IOptionRegr } from '../../data/transforms/regression';
-import type { VChart } from '../../vchart-all';
+import type { IOptionAggr, IOptionAggrField, IOptionRegr, IOptionSeries, IOptionWithCoordinates } from '../../data/transforms/interface';
+import type { IVChart } from '../../core/interface';
 export type IMarkerSupportSeries = ICartesianSeries | IPolarSeries | IGeoSeries;
 export type IPolarPoint = {
     angle: number;
@@ -114,7 +113,7 @@ export type IMarkProcessOptions = {
     processData?: DataView;
 };
 export type IMarkerAttributeContext = {
-    vchart: VChart;
+    vchart: IVChart;
     relativeSeries: IMarkerSupportSeries;
     startRelativeSeries: IMarkerSupportSeries;
     endRelativeSeries: IMarkerSupportSeries;

package/types/component/marker/mark-line/interface/spec.d.ts

@@ -3,7 +3,7 @@ import type { IAggrType, IMarkerPositionsSpec, IDataPointSpec, IMarkerSpec, IDat
 import type { IRegressType } from '../../mark-area/interface';
 import type { IMarkLineTheme } from './theme';
 import type { Datum, ILineMarkSpec, IPoint } from '../../../../typings';
-import type { BaseMarkerAnimation, MarkCommonLineAnimationType } from '@visactor/vrender-components/es/marker/type';
+import type { BaseMarkerAnimation, MarkCommonLineAnimationType } from '@visactor/vrender-components';
 export type IMarkLine = IComponent;
 export type IMarkLineSpec = (IMarkerSpec & (IMarkLineXSpec | IMarkLineYSpec | IMarkLineXYSpec | IMarkLineXYY1Spec | IMarkLineYXX1Spec | IMarkLineAngleSpec | IMarkLineRadiusSpec | IMarkLineAngRadRad1Spec | IMarkLineRadAngAng1Spec | IMarkLineAngRadSpec | IMarkLineCoordinateSpec | IMarkerPositionsSpec) & IMarkLineTheme & BaseMarkerAnimation<MarkCommonLineAnimationType>) | (IStepMarkLineSpec & BaseMarkerAnimation<MarkCommonLineAnimationType>);
 export interface IMarkLineXSpec extends IMarkerCrossSeriesSpec {

package/types/component/marker/mark-point/interface/theme.d.ts

@@ -2,7 +2,7 @@ import type { IImageGraphicAttribute, IRichTextGraphicAttribute, IGroupGraphicAt
 import type { IMarkPointItemPosition } from '@visactor/vrender-components';
 import type { ILineMarkSpec, ISymbolMarkSpec } from '../../../../typings';
 import type { IMarkerLabelSpec, IMarkerRef, IMarkerState, IMarkerSymbol } from '../../interface';
-import type { IRegion } from 'src/region';
+import type { IRegion } from '../../../../region/interface';
 export type IOffsetCallback = (region: IRegion) => number;
 export interface IItemContent extends IMarkerRef {
     type?: 'symbol' | 'text' | 'image' | 'richText';

package/types/component/player/interface/theme.d.ts

@@ -1,6 +1,5 @@
-import type { ControllerLayout, OrientType } from '@visactor/vrender-components';
+import type { ControllerLayout, OrientType, BaseGraphicAttributes } from '@visactor/vrender-components';
 import type { ISymbolMarkSpec, IRectMarkSpec } from '../../../typings';
-import type { BaseGraphicAttributes } from '@visactor/vrender-components';
 import type { ILayoutItemSpec } from '../../../layout/interface';
 export interface IPlayerTheme extends ILayoutItemSpec {
     visible?: boolean;

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

@@ -1,6 +1,6 @@
 import type { PopTipAttributes } from '@visactor/vrender-components';
 import type { IColorKey } from '../../theme/color-scheme/interface';
-import type { ITokenKey } from '../../theme/token';
+import type { ITokenKey } from '../../theme/token/interface';
 export interface IPoptipTheme extends Omit<PopTipAttributes, 'titleStyle' | 'contentStyle' | 'panel'> {
     titleStyle?: Partial<Omit<PopTipAttributes['titleStyle'], 'fill' | 'fontSize'>> & {
         fill?: PopTipAttributes['titleStyle']['fill'] | IColorKey;

package/types/component/title/interface/theme.d.ts

@@ -1,6 +1,6 @@
 import type { ILayoutItemSpec } from '../../../layout/interface';
 import type { IColorKey } from '../../../theme/color-scheme/interface';
-import type { ITokenKey } from '../../../theme/token';
+import type { ITokenKey } from '../../../theme/token/interface';
 import type { StringOrNumber } from '../../../typings';
 import type { TextAlign, TextBaseLine } from '../../../typings/visual';
 export interface ITitleTextTheme {

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

@@ -1,7 +1,7 @@
 import type { ITextAttribute } from '@visactor/vrender-core';
 import type { ILayoutNumber, ITooltipShapePattern, StringOrNumber, TextAlign, TextBaseLine } from '../../../typings';
 import type { Padding } from '@visactor/vrender-components';
-import type { ITokenKey } from '../../../theme/token';
+import type { ITokenKey } from '../../../theme/token/interface';
 export interface ITooltipTextTheme<ColorType = string> {
     fontFamily?: string;
     fontSize?: number | ITokenKey;

package/types/core/factory.d.ts

@@ -64,5 +64,5 @@ export declare class Factory {
     static getComponentPlugins(): IComponentPluginConstructor[];
     static getComponentPluginInType(type: string): IComponentPluginConstructor;
     static registerFormatter(func: typeof Factory['_formatter']): void;
-    static getFormatter(): (text: string | number | number[] | string[], datum: any, formatter: string | string[]) => any;
+    static getFormatter(): (text: string | number | string[] | number[], datum: any, formatter: string | string[]) => any;
 }

package/types/core/interface.d.ts

@@ -1,20 +1,19 @@
-import type { DataSet } from '@visactor/vdataset';
-import type { IParserOptions } from '@visactor/vdataset';
+import type { DataSet, IParserOptions } from '@visactor/vdataset';
 import type { Datum, IDataValues, IInitOption, IMarkStateSpec, IPoint, IRegionQuerier, IShowTooltipOption, ISpec, ITooltipHandler, Maybe, MaybeArray, StringOrNumber } from '../typings';
 import type { IMorphConfig } from '../animation/spec';
 import type { IBoundsLike } from '@visactor/vutils';
 import type { EventCallback, EventParams, EventQuery, EventType } from '../event/interface';
 import type { IMark } from '../mark/interface';
 import type { ISeries } from '../series/interface/series';
-import type { ITheme } from '../theme';
+import type { ITheme } from '../theme/interface';
 import type { IComponent } from '../component/interface';
 import type { LayoutCallBack } from '../layout/interface';
-import type { Compiler } from '../compile/compiler';
 import type { DimensionIndexOption, IChart, IChartSpecInfo } from '../chart/interface';
-import type { Stage } from '@visactor/vrender-core';
+import type { IStage } from '@visactor/vrender-core';
 import type { IContainerSize } from '@visactor/vrender-components';
 import type { IBaseScale } from '@visactor/vscale';
 import type { IUpdateSpecResult } from '../model/interface';
+import type { ICompiler } from '../compile/interface';
 export type DataLinkSeries = {
     seriesId?: StringOrNumber;
     seriesIndex?: number;
@@ -82,9 +81,9 @@ export interface IVChart {
     getImageBuffer: () => void;
     setLayout: (layout: LayoutCallBack) => void;
     reLayout: () => void;
-    getCompiler: () => Compiler;
+    getCompiler: () => ICompiler;
     getChart: () => Maybe<IChart>;
-    getStage: () => Stage;
+    getStage: () => IStage;
     getCanvas: () => HTMLCanvasElement | undefined;
     getContainer: () => Maybe<HTMLElement>;
     getComponents: () => IComponent[];

package/types/core/vchart.d.ts

@@ -8,7 +8,7 @@ import type { IComponentConstructor } from '../component/interface';
 import type { EventCallback, EventParams, EventQuery, EventType } from '../event/interface';
 import type { IParserOptions, Transform } from '@visactor/vdataset';
 import { DataSet, DataView } from '@visactor/vdataset';
-import type { Stage } from '@visactor/vrender-core';
+import type { IStage } from '@visactor/vrender-core';
 import type { GeoSourceType } from '../typings/geo';
 import type { GeoSourceOption } from '../series/map/geo-source';
 import type { IMark, MarkConstructor } from '../mark/interface';
@@ -172,7 +172,7 @@ export declare class VChart implements IVChart {
     reLayout(): void;
     getCompiler(): Compiler;
     getChart(): IChart;
-    getStage(): Stage;
+    getStage(): IStage;
     getCanvas(): HTMLCanvasElement | undefined;
     getContainer(): Maybe<HTMLElement>;
     getComponents(): import("../component/interface").IComponent[];
@@ -201,7 +201,7 @@ export declare class VChart implements IVChart {
     }): void;
     private _initChartPlugin;
     private _chartPluginApply;
-    protected _getMode(): (typeof RenderModeEnum)["desktop-browser"] | "desktop-browser" | "mobile-browser" | "node" | "worker" | "miniApp" | "wx" | "tt" | "harmony" | "desktop-miniApp" | "lynx";
+    protected _getMode(): "node" | (typeof RenderModeEnum)["desktop-browser"] | "desktop-browser" | "mobile-browser" | "worker" | "miniApp" | "wx" | "tt" | "harmony" | "desktop-miniApp" | "lynx";
     protected _getChartOption(type: string): IChartOption;
 }
 export declare const registerVChartCore: () => void;

package/types/data/transforms/aggregation.d.ts

@@ -1,33 +1,6 @@
 import type { DataView } from '@visactor/vdataset';
-import type { IAggrType, IDataPointSpec, IMarkerSupportSeries } from '../../component/marker/interface';
-import type { CoordinateType, Datum, StringOrNumber } from '../../typings';
-export type IOption = {
-    field: string;
-};
-export type IOptionAggrField = {
-    field: string;
-    aggrType: IAggrType;
-};
-export type IOptionPos = IOptionAggrField | string | number | StringOrNumber[];
-export type IOptionSeries = {
-    getRelativeSeries: () => IMarkerSupportSeries;
-    getStartRelativeSeries: () => IMarkerSupportSeries;
-    getEndRelativeSeries: () => IMarkerSupportSeries;
-};
-export type IOptionCallback = (relativeSeriesData: any, startRelativeSeriesData: any, endRelativeSeriesData: any, relativeSeries: IMarkerSupportSeries, startRelative: IMarkerSupportSeries, endRelative: IMarkerSupportSeries) => IOptionPos;
-export type IOptionAggr = {
-    x?: IOptionPos | IOptionCallback;
-    y?: IOptionPos | IOptionCallback;
-    angle?: IOptionPos | IOptionCallback;
-    radius?: IOptionPos | IOptionCallback;
-    areaName?: string | IOptionCallback;
-    getRefRelativeSeries?: () => IMarkerSupportSeries;
-} & IOptionSeries;
-export type IOptionWithCoordinates = {
-    coordinates: ((seriesData: Datum[], relativeSeries: IMarkerSupportSeries) => IDataPointSpec[] | IDataPointSpec) | IDataPointSpec | IDataPointSpec[];
-    getSeriesByIdOrIndex: (seriesUserId: StringOrNumber, seriesIndex: number) => IMarkerSupportSeries;
-    coordinateType: CoordinateType;
-} & IOptionSeries;
+import type { StringOrNumber } from '../../typings';
+import type { IOption, IOptionAggr, IOptionCallback, IOptionWithCoordinates } from './interface';
 export declare const markerMin: (_data: Array<DataView>, opt: IOption) => number;
 export declare const markerMax: (_data: Array<DataView>, opt: IOption) => number;
 export declare function markerSum(_data: Array<DataView>, opt: IOption): number;

package/types/data/transforms/dimension-statistics.d.ts

@@ -1,19 +1,7 @@
 import type { IFieldsMeta } from '../../typings/spec';
 import type { DataView } from '@visactor/vdataset';
 import type { Datum } from '../../typings';
-export type StatisticOperations = Array<'max' | 'min' | 'values' | 'array-max' | 'array-min' | 'allValid'>;
-export interface IStatisticsOption {
-    fields: {
-        key: string;
-        operations: StatisticOperations;
-        filter?: (fv: any) => boolean;
-        customize?: {
-            max: number;
-            min: number;
-        } | any[];
-    }[];
-    target?: 'parser' | 'latest';
-}
+import type { IStatisticsOption, StatisticOperations } from './interface';
 export declare const dimensionStatistics: (data: Array<DataView>, op: IStatisticsOption) => {};
 export declare const dimensionStatisticsOfSimpleData: (latestData: Datum[], fields: {
     key: string;

package/types/data/transforms/hierarchy-dimension-statistics.d.ts

@@ -1,3 +1,3 @@
-import type { IStatisticsOption } from './dimension-statistics';
 import type { DataView } from '@visactor/vdataset';
+import type { IStatisticsOption } from './interface';
 export declare const hierarchyDimensionStatistics: (data: Array<DataView>, op: IStatisticsOption) => {};

package/types/data/transforms/interface.d.ts

@@ -0,0 +1,47 @@
+import type { IAggrType, IDataPointSpec, IMarkerSupportSeries } from '../../component/marker/interface';
+import type { Datum, StringOrNumber } from '../../typings/common';
+import type { CoordinateType } from '../../typings/coordinate';
+export type StatisticOperations = Array<'max' | 'min' | 'values' | 'array-max' | 'array-min' | 'allValid'>;
+export interface IStatisticsOption {
+    fields: {
+        key: string;
+        operations: StatisticOperations;
+        filter?: (fv: any) => boolean;
+        customize?: {
+            max: number;
+            min: number;
+        } | any[];
+    }[];
+    target?: 'parser' | 'latest';
+}
+export type IOption = {
+    field: string;
+};
+export type IOptionAggrField = {
+    field: string;
+    aggrType: IAggrType;
+};
+export type IOptionPos = IOptionAggrField | string | number | StringOrNumber[];
+export type IOptionSeries = {
+    getRelativeSeries: () => IMarkerSupportSeries;
+    getStartRelativeSeries: () => IMarkerSupportSeries;
+    getEndRelativeSeries: () => IMarkerSupportSeries;
+};
+export type IOptionCallback = (relativeSeriesData: any, startRelativeSeriesData: any, endRelativeSeriesData: any, relativeSeries: IMarkerSupportSeries, startRelative: IMarkerSupportSeries, endRelative: IMarkerSupportSeries) => IOptionPos;
+export type IOptionAggr = {
+    x?: IOptionPos | IOptionCallback;
+    y?: IOptionPos | IOptionCallback;
+    angle?: IOptionPos | IOptionCallback;
+    radius?: IOptionPos | IOptionCallback;
+    areaName?: string | IOptionCallback;
+    getRefRelativeSeries?: () => IMarkerSupportSeries;
+} & IOptionSeries;
+export type IOptionWithCoordinates = {
+    coordinates: ((seriesData: Datum[], relativeSeries: IMarkerSupportSeries) => IDataPointSpec[] | IDataPointSpec) | IDataPointSpec | IDataPointSpec[];
+    getSeriesByIdOrIndex: (seriesUserId: StringOrNumber, seriesIndex: number) => IMarkerSupportSeries;
+    coordinateType: CoordinateType;
+} & IOptionSeries;
+export type IOptionRegr = {
+    fieldX: string;
+    fieldY: string;
+};

package/types/data/transforms/regression.d.ts

@@ -1,6 +1,3 @@
 import type { DataView } from '@visactor/vdataset';
-export type IOptionRegr = {
-    fieldX: string;
-    fieldY: string;
-};
+import type { IOptionRegr } from './interface';
 export declare function markerRegression(_data: Array<DataView>, opt: IOptionRegr): any[];

package/types/event/events/dimension/interface.d.ts

@@ -1,7 +1,7 @@
 import type { BaseEventParams } from '../../interface';
 import type { ISeries } from '../../../series/interface';
 import type { Datum } from '../../../typings';
-import type { IAxis } from '../../../component/axis';
+import type { IAxis } from '../../../component/axis/interface';
 export declare enum DimensionEventEnum {
     dimensionHover = "dimensionHover",
     dimensionClick = "dimensionClick"

package/types/event/interface.d.ts

@@ -3,7 +3,6 @@ import type { IElement } from '@visactor/vgrammar-core';
 import type { IChart } from '../chart/interface';
 import type { IModel } from '../model/interface';
 import type { IMark, MarkType } from '../mark/interface';
-import type { VChart } from '../core/vchart';
 import type { DimensionEventParams } from './events/dimension/interface';
 import type { Datum, IPoint, StringOrNumber } from '../typings';
 import type { ChartEvent, Event_Bubble_Level, Event_Source_Type, VGRAMMAR_HOOK_EVENT } from '../constant/event';
@@ -148,7 +147,7 @@ export type EventParamsDefinition = {
     [key: string]: ExtendEventParam;
 };
 export interface IEventDispatcher {
-    globalInstance: VChart;
+    globalInstance: IVChart;
     register: <Evt extends EventType>(eType: Evt, handler: EventHandler<EventParamsDefinition[Evt]>) => this;
     unregister: <Evt extends EventType>(eType: Evt, handler?: EventHandler<EventParamsDefinition[Evt]>) => this;
     dispatch: <Evt extends EventType>(eType: Evt, params?: EventParamsDefinition[Evt], level?: EventBubbleLevel) => this;

package/types/interaction/interface.d.ts

@@ -3,7 +3,7 @@ import type { IMark } from '../mark/interface';
 import type { RenderMode } from '../typings/spec/common';
 import type { BaseEventParams, IEventDispatcher, EventType } from '../event/interface';
 import type { IModel } from '../model/interface';
-import type { StateValue } from '../compile/mark';
+import type { StateValue } from '../compile/mark/interface';
 import type { StringOrNumber } from '../typings/common';
 export interface IInteraction {
     registerMark: (state: StateValue, mark: IMark) => void;
@@ -53,10 +53,6 @@ export interface ISelectSpec extends IBaseInteractionSpec {
     trigger?: Trigger;
     triggerOff?: Trigger | number;
 }
-export interface ITriggerSpec {
-    hover?: IHoverSpec | boolean;
-    select?: ISelectSpec | boolean;
-}
 export type IElementActiveSpec = IBaseInteractionSpec & Pick<ElementActiveSpec, 'type' | 'trigger' | 'triggerOff' | 'state'>;
 export type IElementSelectSpec = IBaseInteractionSpec & Pick<ElementSelectSpec, 'type' | 'trigger' | 'triggerOff' | 'state' | 'isMultiple' | 'reverseState'>;
 export type IElementHighlightSpec = IBaseInteractionSpec & Pick<ElementHighlightSpec, 'type' | 'blurState' | 'highlightState' | 'triggerOff' | 'trigger'>;

package/types/mark/arc-3d.d.ts

@@ -1,8 +1,7 @@
 import type { IArc3dMarkSpec } from '../typings';
 import { BaseArcMark } from './arc';
-import type { IMarkRaw } from './interface';
+import type { IArc3dMark } from './interface';
 import { MarkTypeEnum } from './interface/type';
-export type IArc3dMark = IMarkRaw<IArc3dMarkSpec>;
 export declare class Arc3dMark extends BaseArcMark<IArc3dMarkSpec> implements IArc3dMark {
     static readonly type = MarkTypeEnum.arc3d;
     readonly type: MarkTypeEnum;

package/types/mark/arc.d.ts

@@ -1,8 +1,7 @@
 import type { IArcMarkSpec, Datum, StateValueType } from '../typings';
 import { BaseMark } from './base/base-mark';
-import type { IMarkOption, IMarkRaw, IMarkStyle } from './interface';
+import type { IArcMark, IMarkOption, IMarkRaw, IMarkStyle } from './interface';
 import { MarkTypeEnum } from './interface/type';
-export type IArcMark = IMarkRaw<IArcMarkSpec>;
 export declare class BaseArcMark<T extends IArcMarkSpec> extends BaseMark<T> implements IMarkRaw<T> {
     readonly type: MarkTypeEnum;
     _unCompileChannel: {

package/types/mark/area.d.ts

@@ -1,8 +1,7 @@
 import type { IAreaMarkSpec } from '../typings/visual';
 import { BaseLineMark } from './base/base-line';
-import type { IMarkRaw, IMarkStyle } from './interface';
+import type { IAreaMark, IMarkStyle } from './interface';
 import { MarkTypeEnum } from './interface/type';
-export type IAreaMark = IMarkRaw<IAreaMarkSpec>;
 export declare class AreaMark extends BaseLineMark<IAreaMarkSpec> implements IAreaMark {
     static readonly type = MarkTypeEnum.area;
     readonly type = MarkTypeEnum.area;

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

@@ -1,9 +1,8 @@
 import type { IBoxPlotMarkSpec } from '../typings/visual';
 import { BaseMark } from './base/base-mark';
 import type { IGroupMark } from '@visactor/vgrammar-core';
-import type { IMarkRaw, IMarkStyle } from './interface';
+import type { IBoxPlotMark, IMarkStyle } from './interface';
 import { MarkTypeEnum } from './interface/type';
-export type IBoxPlotMark = IMarkRaw<IBoxPlotMarkSpec>;
 export declare class BoxPlotMark extends BaseMark<IBoxPlotMarkSpec> implements IBoxPlotMark {
     static readonly type = MarkTypeEnum.boxPlot;
     readonly type = MarkTypeEnum.boxPlot;

package/types/mark/cell.d.ts

@@ -1,8 +1,7 @@
 import type { ICellMarkSpec } from '../typings';
-import type { IMarkRaw, IMarkStyle } from './interface';
+import type { ICellMark, IMarkStyle } from './interface';
 import { MarkTypeEnum } from './interface/type';
 import { BaseSymbolMark } from './symbol';
-export type ICellMark = IMarkRaw<ICellMarkSpec>;
 export declare class CellMark extends BaseSymbolMark<ICellMarkSpec> implements ICellMark {
     static readonly type = MarkTypeEnum.cell;
     readonly type = MarkTypeEnum.cell;

package/types/mark/component.d.ts

@@ -1,9 +1,8 @@
 import type { IGroupMark } from '@visactor/vgrammar-core';
 import type { ICommonSpec } from '../typings';
 import { BaseMark } from './base/base-mark';
-import type { IMarkOption, IMarkRaw } from './interface';
+import type { IComponentMark, IMarkOption } from './interface';
 import { MarkTypeEnum } from './interface/type';
-export type IComponentMark = IMarkRaw<ICommonSpec>;
 export declare class ComponentMark extends BaseMark<ICommonSpec> implements IComponentMark {
     static readonly type = MarkTypeEnum.component;
     type: string;

package/types/mark/group.d.ts

@@ -1,18 +1,10 @@
 import type { Maybe } from '../typings';
 import type { IGroupMarkSpec } from '../typings/visual';
 import { BaseMark } from './base/base-mark';
-import type { IMark, IMarkRaw, IMarkStyle, MarkType } from './interface';
+import type { IGroupMark, IMark, IMarkStyle, MarkType } from './interface';
 import { MarkTypeEnum } from './interface/type';
 import type { IGroupMark as IVGrammarGroupMark } from '@visactor/vgrammar-core';
 import type { IMarkCompileOption } from '../compile/mark';
-export interface IGroupMark extends IMarkRaw<IGroupMarkSpec> {
-    addMark: (m: IMark) => boolean;
-    removeMark: (m: IMark) => boolean;
-    getMarks: () => IMark[];
-    getMarkInType: (type: MarkType) => IMark[];
-    getMarkInId: (id: number) => IMark | undefined;
-    getMarkInName: (name: string) => IMark[];
-}
 export declare class GroupMark extends BaseMark<IGroupMarkSpec> implements IGroupMark {
     static readonly type = MarkTypeEnum.group;
     readonly type = MarkTypeEnum.group;

package/types/mark/image.d.ts

@@ -1,8 +1,7 @@
 import type { IImageMarkSpec } from '../typings/visual';
 import { BaseMark } from './base/base-mark';
-import type { IMarkRaw, IMarkStyle } from './interface';
+import type { IImageMark, IMarkStyle } from './interface';
 import { MarkTypeEnum } from './interface/type';
-export type IImageMark = IMarkRaw<IImageMarkSpec>;
 export declare class ImageMark extends BaseMark<IImageMarkSpec> implements IImageMark {
     static readonly type = MarkTypeEnum.image;
     readonly type = MarkTypeEnum.image;

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

@@ -3,7 +3,7 @@ import type { ICommonSpec, VisualType, ValueType, FunctionType } from '../../typ
 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';
+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';

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

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

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

@@ -0,0 +1,44 @@
+import type { IMarkSpec } from '../../typings';
+import type { IArc3dMarkSpec, IArcMarkSpec, IAreaMarkSpec, IBoxPlotMarkSpec, ICellMarkSpec, ICommonSpec, IComposedTextMarkSpec, IGroupMarkSpec, IImageMarkSpec, ILineMarkSpec, ILinkPathMarkSpec, IPathMarkSpec, IPolygonMarkSpec, IPyramid3dMarkSpec, IRect3dMarkSpec, IRectMarkSpec, IRippleMarkSpec, IRuleMarkSpec, ISymbolMarkSpec } from '../../typings/visual';
+import type { IMark, IMarkRaw } from './common';
+import type { MarkType } from './type';
+export type IComponentMark = IMarkRaw<ICommonSpec>;
+export interface ILabelMark extends ITextMark {
+    skipEncode: boolean;
+    getRule: () => string;
+    setRule: (rule: string) => void;
+    getTarget: () => IMark;
+    setTarget: (target: IMark) => void;
+    getComponent: () => IComponentMark;
+    setComponent: (component: IComponentMark) => void;
+}
+export type ITextMark = IMarkRaw<IComposedTextMarkSpec> & {
+    getTextType: () => 'text' | 'rich';
+};
+export type ITextSpec<T> = IMarkSpec<T> & {
+    textType?: 'rich' | 'text';
+};
+export type IArc3dMark = IMarkRaw<IArc3dMarkSpec>;
+export type IPolygonMark = IMarkRaw<IPolygonMarkSpec>;
+export type IPyramid3dMark = IMarkRaw<IPyramid3dMarkSpec>;
+export type IArcMark = IMarkRaw<IArcMarkSpec>;
+export type IAreaMark = IMarkRaw<IAreaMarkSpec>;
+export type IBoxPlotMark = IMarkRaw<IBoxPlotMarkSpec>;
+export type ICellMark = IMarkRaw<ICellMarkSpec>;
+export type IImageMark = IMarkRaw<IImageMarkSpec>;
+export type ILineMark = IMarkRaw<ILineMarkSpec>;
+export type ILinkPathMark = IMarkRaw<ILinkPathMarkSpec>;
+export type IPathMark = IMarkRaw<IPathMarkSpec>;
+export type IRect3dMark = IMarkRaw<IRect3dMarkSpec>;
+export type IRectMark = IMarkRaw<IRectMarkSpec>;
+export type IRippleMark = IMarkRaw<IRippleMarkSpec>;
+export type IRuleMark = IMarkRaw<IRuleMarkSpec>;
+export type ISymbolMark = IMarkRaw<ISymbolMarkSpec>;
+export interface IGroupMark extends IMarkRaw<IGroupMarkSpec> {
+    addMark: (m: IMark) => boolean;
+    removeMark: (m: IMark) => boolean;
+    getMarks: () => IMark[];
+    getMarkInType: (type: MarkType) => IMark[];
+    getMarkInId: (id: number) => IMark | undefined;
+    getMarkInName: (name: string) => IMark[] | undefined;
+}

package/types/mark/label.d.ts

@@ -1,7 +1,7 @@
-import type { IComponentMark } from './component';
 import type { IMark } from './interface/common';
 import { MarkTypeEnum } from './interface/type';
-import { ITextMark, TextMark } from './text';
+import { TextMark } from './text';
+import type { ILabelMark } from './interface/mark';
 export declare class LabelMark extends TextMark implements ILabelMark {
     static readonly type = MarkTypeEnum.text;
     static readonly constructorType = MarkTypeEnum.label;
@@ -16,13 +16,4 @@ export declare class LabelMark extends TextMark implements ILabelMark {
     getComponent(): IMark;
     setComponent(component: IMark): void;
 }
-export interface ILabelMark extends ITextMark {
-    skipEncode: boolean;
-    getRule: () => string;
-    setRule: (rule: string) => void;
-    getTarget: () => IMark;
-    setTarget: (target: IMark) => void;
-    getComponent: () => IComponentMark;
-    setComponent: (component: IComponentMark) => void;
-}
 export declare const registerLabelMark: () => void;

package/types/mark/line.d.ts

@@ -1,8 +1,7 @@
 import type { ILineMarkSpec } from '../typings/visual';
 import { BaseLineMark } from './base/base-line';
-import type { IMarkRaw, IMarkStyle } from './interface';
+import type { ILineMark, IMarkStyle } from './interface';
 import { MarkTypeEnum } from './interface/type';
-export type ILineMark = IMarkRaw<ILineMarkSpec>;
 export declare class LineMark extends BaseLineMark<ILineMarkSpec> implements ILineMark {
     static readonly type = MarkTypeEnum.line;
     readonly type = MarkTypeEnum.line;

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

@@ -1,9 +1,8 @@
 import { BaseMark } from './base/base-mark';
 import type { ILinkPathMarkSpec } from '../typings/visual';
-import type { IMarkRaw, IMarkStyle } from './interface';
+import type { ILinkPathMark, IMarkStyle } from './interface';
 import { MarkTypeEnum } from './interface/type';
 import type { IGroupMark } from '@visactor/vgrammar-core';
-export type ILinkPathMark = IMarkRaw<ILinkPathMarkSpec>;
 export declare class LinkPathMark extends BaseMark<ILinkPathMarkSpec> implements ILinkPathMark {
     static readonly type = MarkTypeEnum.linkPath;
     readonly type = MarkTypeEnum.linkPath;

package/types/mark/path.d.ts

@@ -1,8 +1,7 @@
 import type { IPathMarkSpec } from '../typings/visual';
 import { BaseMark } from './base/base-mark';
-import type { IMarkRaw, IMarkStyle } from './interface';
+import type { IMarkStyle, IPathMark } from './interface';
 import { MarkTypeEnum } from './interface/type';
-export type IPathMark = IMarkRaw<IPathMarkSpec>;
 export declare class PathMark extends BaseMark<IPathMarkSpec> implements IPathMark {
     static readonly type = MarkTypeEnum.path;
     readonly type = MarkTypeEnum.path;

package/types/mark/polygon/polygon.d.ts

@@ -1,8 +1,7 @@
 import type { IPolygonMarkSpec } from '../../typings/visual';
 import { BasePolygonMark } from './base-polygon';
-import type { IMarkRaw, IMarkStyle } from '../interface';
+import type { IMarkStyle, IPolygonMark } from '../interface';
 import { MarkTypeEnum } from '../interface/type';
-export type IPolygonMark = IMarkRaw<IPolygonMarkSpec>;
 export declare class PolygonMark extends BasePolygonMark<IPolygonMarkSpec> implements IPolygonMark {
     static readonly type = MarkTypeEnum.polygon;
     readonly type = MarkTypeEnum.polygon;

package/types/mark/polygon/pyramid-3d.d.ts

@@ -1,8 +1,7 @@
 import type { IPyramid3dMarkSpec } from '../../typings/visual';
-import type { IMarkRaw } from '../interface';
 import { MarkTypeEnum } from '../interface/type';
 import { BasePolygonMark } from './base-polygon';
-export type IPyramid3dMark = IMarkRaw<IPyramid3dMarkSpec>;
+import type { IPyramid3dMark } from '../interface/mark';
 export declare class Pyramid3dMark extends BasePolygonMark<IPyramid3dMarkSpec> implements IPyramid3dMark {
     static readonly type = MarkTypeEnum.pyramid3d;
     readonly type = MarkTypeEnum.pyramid3d;

package/types/mark/rect-3d.d.ts

@@ -1,8 +1,7 @@
 import type { IRect3dMarkSpec } from '../typings/visual';
 import { BaseMark } from './base/base-mark';
-import type { IMarkRaw, IMarkStyle } from './interface';
+import type { IMarkStyle, IRect3dMark } from './interface';
 import { MarkTypeEnum } from './interface/type';
-export type IRect3dMark = IMarkRaw<IRect3dMarkSpec>;
 export declare class Rect3dMark extends BaseMark<IRect3dMarkSpec> implements IRect3dMark {
     static readonly type = MarkTypeEnum.rect3d;
     readonly type = MarkTypeEnum.rect3d;

package/types/mark/rect.d.ts

@@ -1,8 +1,7 @@
 import type { IRectMarkSpec } from '../typings/visual';
 import { BaseMark } from './base/base-mark';
-import type { IMarkRaw, IMarkStyle } from './interface';
+import type { IMarkStyle, IRectMark } from './interface';
 import { MarkTypeEnum } from './interface/type';
-export type IRectMark = IMarkRaw<IRectMarkSpec>;
 export declare class RectMark extends BaseMark<IRectMarkSpec> implements IRectMark {
     static readonly type = MarkTypeEnum.rect;
     readonly type = MarkTypeEnum.rect;

package/types/mark/ripple.d.ts

@@ -1,9 +1,8 @@
 import { BaseMark } from './base/base-mark';
 import type { IRippleMarkSpec } from '../typings/visual';
-import type { IMarkRaw, IMarkStyle } from './interface';
+import type { IMarkStyle, IRippleMark } from './interface';
 import { MarkTypeEnum } from './interface/type';
 import type { IGroupMark } from '@visactor/vgrammar-core';
-export type IRippleMark = IMarkRaw<IRippleMarkSpec>;
 export declare class RippleMark extends BaseMark<IRippleMarkSpec> implements IRippleMark {
     static readonly type = MarkTypeEnum.ripple;
     readonly type = MarkTypeEnum.ripple;

package/types/mark/rule.d.ts

@@ -1,8 +1,7 @@
 import type { IRuleMarkSpec } from '../typings/visual';
 import { BaseMark } from './base/base-mark';
-import type { IMarkRaw, IMarkStyle } from './interface';
+import type { IMarkStyle, IRuleMark } from './interface';
 import { MarkTypeEnum } from './interface/type';
-export type IRuleMark = IMarkRaw<IRuleMarkSpec>;
 export declare class RuleMark extends BaseMark<IRuleMarkSpec> implements IRuleMark {
     static readonly type = MarkTypeEnum.rule;
     readonly type = MarkTypeEnum.rule;