@visactor/vchart-types 1.9.2 → 1.10.0-alpha.0

package/types/component/axis/interface/spec.d.ts

@@ -1,9 +1,8 @@
 import type { AxisItem, AxisItemStateStyle } from '@visactor/vrender-components';
 import type { IAnimationSpec } from '../../../animation/spec';
-import type { Datum, IPadding, IRectMarkSpec, IRuleMarkSpec, ISymbolMarkSpec, ITextMarkSpec, StringOrNumber } from '../../../typings';
+import type { Datum, IFormatMethod, IPadding, IRectMarkSpec, IRichTextFormatMethod, IRuleMarkSpec, ISymbolMarkSpec, ITextMarkSpec, StringOrNumber } from '../../../typings';
 import type { IComponentSpec } from '../../base/interface';
 import type { AxisType, IAxisItem, IBandAxisLayer, ITickCalculationCfg, StyleCallback } from './common';
-import type { IRichTextCharacter } from '@visactor/vrender-core';
 export interface ICommonAxisSpec extends Omit<IComponentSpec, 'orient' | 'center'>, IAnimationSpec<string, string> {
     type?: AxisType;
     visible?: boolean;
@@ -62,8 +61,8 @@ export interface ISubTick extends IAxisItem<IRuleMarkSpec> {
     state?: AxisItemStateStyle<IRuleMarkSpec>;
 }
 export interface ILabel extends IAxisItem<ITextMarkSpec> {
-    type?: 'text' | 'rich' | 'html';
-    formatMethod?: (text: string | string[], datum?: Datum) => string | string[] | IRichTextCharacter[];
+    type?: 'text' | 'rich';
+    formatMethod?: IFormatMethod<[text: string | string[], datum?: Datum]>;
     space?: number;
     inside?: boolean;
     minGap?: number;
@@ -75,6 +74,8 @@ export interface IDomainLine extends IAxisItem<IRuleMarkSpec> {
     state?: AxisItemStateStyle<IRuleMarkSpec>;
 }
 export interface ITitle extends IAxisItem<ITextMarkSpec> {
+    type?: 'text' | 'rich';
+    text?: ITextMarkSpec['text'] | ReturnType<IRichTextFormatMethod<[]>>;
     position?: 'start' | 'middle' | 'end';
     space?: number;
     padding?: IPadding | number | number[];
@@ -85,8 +86,6 @@ export interface ITitle extends IAxisItem<ITextMarkSpec> {
         space?: number;
         state?: AxisItemStateStyle<Partial<ISymbolMarkSpec>>;
     };
-    type?: 'text' | 'rich' | 'html';
-    text?: string | string[] | IRichTextCharacter[];
     angle?: number;
     state?: AxisItemStateStyle<Partial<ITextMarkSpec>>;
 }

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

@@ -1,8 +1,8 @@
+import { Datum, IFormatMethod } from '../../typings';
 import type { IPercent } from '../../typings/layout';
 import type { ConvertToMarkStyleSpec, ITextMarkSpec } from '../../typings/visual';
 import type { IComponentSpec } from '../base/interface';
 import type { IComponent } from '../interface';
-import type { IRichTextCharacter } from '@visactor/vrender-core';
 export interface IIndicatorItemSpec {
     visible?: boolean;
     field?: string;
@@ -12,8 +12,8 @@ export interface IIndicatorItemSpec {
     fitPercent?: number;
     fitStrategy?: 'default' | 'inscribed';
     style?: Omit<ConvertToMarkStyleSpec<ITextMarkSpec>, 'visible' | 'text'> & {
-        type?: 'text' | 'rich' | 'html';
-        text?: string | string[] | number | number[] | IRichTextCharacter[];
+        type?: 'text' | 'rich';
+        text?: IFormatMethod<[activeDatum: Datum]> | ITextMarkSpec['text'] | ReturnType<IFormatMethod<[activeDatum: Datum]>>;
     };
 }
 export type IIndicator = IComponent;
@@ -28,10 +28,10 @@ export interface IIndicatorSpec extends IComponentSpec {
     title?: IIndicatorItemSpec;
     content?: IIndicatorItemSpec[] | IIndicatorItemSpec;
 }
-export interface IIndicatorItemTheme extends IIndicatorItemSpec {
+export interface IIndicatorItemTheme extends Omit<IIndicatorItemSpec, 'style'> {
     style?: Omit<ITextMarkSpec, 'visible'>;
 }
-export interface IIndicatorTheme extends IIndicatorSpec {
+export interface IIndicatorTheme extends Omit<IIndicatorSpec, 'content' | 'title'> {
     title?: IIndicatorItemTheme;
     content?: IIndicatorItemTheme;
 }

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

@@ -16,10 +16,10 @@ export declare abstract class BaseLabelComponent<T = any> extends BaseComponent<
         hover: boolean;
         select: boolean;
         state: {
-            hover?: Partial<import("../..").ITextMarkSpec>;
-            hover_reverse?: Partial<import("../..").ITextMarkSpec>;
-            selected?: Partial<import("../..").ITextMarkSpec>;
-            selected_reverse?: Partial<import("../..").ITextMarkSpec>;
+            hover?: Partial<import("../../typings").IComposedTextMarkSpec>;
+            hover_reverse?: Partial<import("../../typings").IComposedTextMarkSpec>;
+            selected?: Partial<import("../../typings").IComposedTextMarkSpec>;
+            selected_reverse?: Partial<import("../../typings").IComposedTextMarkSpec>;
         };
     };
     _compareSpec(spec: T, prevSpec: T): {

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

@@ -1,7 +1,6 @@
 import type { BaseLabelAttrs } from '@visactor/vrender-components';
-import type { ConvertToMarkStyleSpec, Datum, ITextMarkSpec } from '../../typings';
+import type { ConvertToMarkStyleSpec, Datum, IComposedTextMarkSpec, IFormatMethod, ITextMarkSpec } from '../../typings';
 import type { IComponentSpec } from '../base/interface';
-import type { IRichTextCharacter } from '@visactor/vrender-core';
 import type { ILabelMark } from '../../mark/label';
 import type { ISeries } from '../../series';
 export interface ILabelFormatMethodContext {
@@ -10,13 +9,13 @@ export interface ILabelFormatMethodContext {
 export interface ILabelSpec extends IComponentSpec {
     visible?: boolean;
     interactive?: boolean;
-    textType?: string;
-    formatMethod?: (text: string | string[], datum?: Datum, ctx?: ILabelFormatMethodContext) => string | string[] | IRichTextCharacter[];
+    textType?: 'text' | 'rich';
+    formatMethod?: IFormatMethod<[text: string | string[], datum?: Datum, ctx?: ILabelFormatMethodContext]>;
     formatter?: string;
     offset?: number;
     position?: string;
-    style?: ConvertToMarkStyleSpec<ITextMarkSpec>;
-    state?: LabelStateStyle<Partial<ITextMarkSpec>>;
+    style?: ConvertToMarkStyleSpec<IComposedTextMarkSpec>;
+    state?: LabelStateStyle<Partial<IComposedTextMarkSpec>>;
     overlap?: BaseLabelAttrs['overlap'];
     smartInvert?: BaseLabelAttrs['smartInvert'];
     animation?: BaseLabelAttrs['animation'];
@@ -24,7 +23,6 @@ export interface ILabelSpec extends IComponentSpec {
     customLayoutFunc?: BaseLabelAttrs['customLayoutFunc'];
     customOverlapFunc?: BaseLabelAttrs['customOverlapFunc'];
     labelLayout?: 'series' | 'region';
-    centerOffset?: number;
     support3d?: boolean;
     syncState?: boolean;
 }
@@ -34,7 +32,7 @@ type LabelStateStyle<T> = {
     selected?: T;
     selected_reverse?: T;
 };
-export type ITotalLabelSpec = Pick<ILabelSpec, 'visible' | 'formatMethod' | 'interactive' | 'offset' | 'style' | 'state'>;
+export type ITotalLabelSpec = Pick<ILabelSpec, 'visible' | 'formatMethod' | 'interactive' | 'offset' | 'style' | 'state' | 'textType'>;
 export interface ITotalLabelTheme extends Pick<ILabelSpec, 'visible' | 'interactive' | 'offset' | 'overlap' | 'smartInvert' | 'animation'> {
     style?: ITextMarkSpec;
 }

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

@@ -56,7 +56,7 @@ export declare function stackLabel(labelInfo: ILabelInfo): {
     };
 };
 export declare function treemapLabel(labelInfo: ILabelInfo): {
-    customLayoutFunc: (labels: LabelItem[]) => import("@visactor/vrender-core").IText[];
+    customLayoutFunc: (labels: LabelItem[], text: any) => any;
     overlap: boolean;
 };
 export declare function LineLabel(labelInfo: ILabelInfo): {

package/types/component/legend/discrete/interface.d.ts

@@ -1,10 +1,10 @@
 import type { IRectMarkSpec, ISymbolMarkSpec, ITextMarkSpec } from '../../../typings/visual';
 import type { DiscreteLegendAttrs, LegendItemDatum, LegendItem } from '@visactor/vrender-components';
 import type { ILegendCommonSpec, NoVisibleMarkStyle } from '../interface';
-import type { StringOrNumber } from '../../../typings';
+import type { IFormatMethod, StringOrNumber } from '../../../typings';
 import type { IBaseScale } from '@visactor/vscale';
 import type { IGlobalScale } from '../../../scale/interface';
-export type formatterCallback = (text: StringOrNumber, item: LegendItemDatum, index: number) => any;
+export type formatterCallback = IFormatMethod<[text: StringOrNumber, item: LegendItemDatum, index: number]>;
 export type LegendItemStyleValue<T> = T | ((item: LegendItemDatum, isSelected: boolean, index: number, allItems: LegendItemDatum[]) => T);
 export type LegendItemStyle<T> = {
     style?: T;

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

@@ -1,6 +1,6 @@
 import type { IPadding } from '@visactor/vutils';
-import type { SymbolType, IRichTextCharacter } from '@visactor/vrender-core';
-import type { IRectMarkSpec, ISymbolMarkSpec, ITextMarkSpec, StringOrNumber } from '../../typings';
+import type { SymbolType } from '@visactor/vrender-core';
+import type { IComposedTextMarkSpec, IFormatMethod, IRectMarkSpec, IRichTextFormatMethod, ISymbolMarkSpec, StringOrNumber } from '../../typings';
 import type { IComponentSpec } from '../base/interface';
 import type { Datum } from '@visactor/vrender-components';
 import type { ICartesianSeries } from '../../series/interface';
@@ -44,10 +44,10 @@ export type IMarkerLabelWithoutRefSpec = {
         padding?: IPadding | number[] | number;
         style?: Omit<IRectMarkSpec, 'visible'>;
     };
-    type?: 'text' | 'rich' | 'html';
-    text?: string | string[] | number | number[] | IRichTextCharacter[];
-    formatMethod?: (markData: Datum[], seriesData: Datum[]) => string | string[] | number | number[] | IRichTextCharacter[];
-    style?: Omit<ITextMarkSpec, 'visible'>;
+    type?: 'rich' | 'text';
+    text?: string | string[] | number | number[] | ReturnType<IRichTextFormatMethod<[]>>;
+    formatMethod?: IFormatMethod<[markData: Datum[], seriesData: Datum[]]>;
+    style?: Omit<IComposedTextMarkSpec, 'visible'>;
     shape?: {
         visible?: boolean;
         style: Omit<ISymbolMarkSpec, 'visible'>;

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

@@ -6,6 +6,6 @@ export interface IMarkAreaTheme {
         style?: IPolygonMarkSpec;
     };
     label?: {
-        position?: IMarkAreaLabelPosition;
+        position?: keyof typeof IMarkAreaLabelPosition;
     } & IMarkerLabelWithoutRefSpec;
 }

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

@@ -6,7 +6,7 @@ export interface IMarkLineTheme {
         style?: ILineMarkSpec;
     };
     label?: {
-        position?: IMarkLineLabelPosition;
+        position?: keyof typeof IMarkLineLabelPosition;
     } & IMarkerLabelSpec;
     startSymbol?: IMarkerSymbol;
     endSymbol?: IMarkerSymbol;

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

@@ -4,7 +4,7 @@ import type { ILineMarkSpec, ISymbolMarkSpec } from '../../../../typings';
 import type { IMarkerLabelSpec, IMarkerRef, IMarkerSymbol } from '../../interface';
 export interface IItemContent extends IMarkerRef {
     type?: 'symbol' | 'text' | 'image' | 'richText';
-    position?: IMarkPointItemPosition;
+    position?: keyof typeof IMarkPointItemPosition;
     offsetX?: number;
     offsetY?: number;
     confine?: boolean;

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

@@ -1,14 +1,10 @@
 import type { IComponent } from '../../interface';
 import type { ITextGraphicAttribute, IRichTextCharacter, RichTextWordBreak } from '@visactor/vrender-core';
-import type { IOrientType, IPadding, StringOrNumber } from '../../../typings';
+import type { IOrientType, IPadding } from '../../../typings';
 import type { IComponentSpec } from '../../base/interface';
-export interface ITitleSpec extends Omit<IComponentSpec, 'orient'> {
+interface ITitleSpecWithoutText extends Omit<IComponentSpec, 'orient'> {
     visible?: boolean;
     orient?: IOrientType;
-    text?: string | number | string[] | number[] | IRichTextCharacter[];
-    textType?: string;
-    subtext?: string | number | string[] | number[] | IRichTextCharacter[];
-    subtextType?: string;
     x?: number;
     y?: number;
     width?: number;
@@ -43,5 +39,20 @@ export interface ITitleSpec extends Omit<IComponentSpec, 'orient'> {
         character?: IRichTextCharacter[];
     } & Partial<ITextGraphicAttribute>;
 }
-export type Text = StringOrNumber;
+export type ITitleTextSpec = {
+    textType?: 'text';
+    text: string | number | string[] | number[];
+} | {
+    textType: 'rich';
+    text: IRichTextCharacter[];
+};
+export type ISubTitleTextSpec = {
+    subtextType?: 'text';
+    subtext?: string | number | string[] | number[];
+} | {
+    subtextType?: 'rich';
+    subtext?: IRichTextCharacter[];
+};
+export type ITitleSpec = ITitleSpecWithoutText & ITitleTextSpec & ISubTitleTextSpec;
 export type ITitle = IComponent;
+export {};

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 { TextMark } from './text';
+import { ITextMark, TextMark } from './text';
 export declare class LabelMark extends TextMark implements ILabelMark {
     static readonly type = MarkTypeEnum.text;
     static readonly constructorType = MarkTypeEnum.label;
@@ -16,7 +16,7 @@ export declare class LabelMark extends TextMark implements ILabelMark {
     getComponent(): IMark;
     setComponent(component: IMark): void;
 }
-export interface ILabelMark extends IMark {
+export interface ILabelMark extends ITextMark {
     skipEncode: boolean;
     getRule: () => string;
     setRule: (rule: string) => void;

package/types/mark/text.d.ts

@@ -1,13 +1,22 @@
-import type { ITextMarkSpec } from '../typings/visual';
+import type { IComposedTextMarkSpec } from '../typings/visual';
 import { BaseMark } from './base/base-mark';
-import type { IMarkRaw, IMarkStyle } from './interface';
+import type { IMarkOption, IMarkRaw, IMarkStyle } from './interface';
 import { MarkTypeEnum } from './interface';
-import type { IGroupMark } from '@visactor/vgrammar-core';
-export type ITextMark = IMarkRaw<ITextMarkSpec>;
-export declare class TextMark extends BaseMark<ITextMarkSpec> implements ITextMark {
+import { IMarkSpec } from '../typings/spec/common';
+export type ITextMark = IMarkRaw<IComposedTextMarkSpec> & {
+    getTextType: () => 'text' | 'rich';
+};
+export type ITextSpec<T> = IMarkSpec<T> & {
+    textType?: 'rich' | 'text';
+};
+export declare class TextMark extends BaseMark<IComposedTextMarkSpec> implements ITextMark {
     static readonly type = MarkTypeEnum.text;
     readonly type = MarkTypeEnum.text;
-    protected _getDefaultStyle(): IMarkStyle<ITextMarkSpec>;
-    protected _initProduct(group?: string | IGroupMark): void;
+    protected _textType: 'text' | 'rich';
+    getTextType(): "text" | "rich";
+    constructor(name: string, option: IMarkOption);
+    protected _getDefaultStyle(): IMarkStyle<IComposedTextMarkSpec>;
+    initStyleWithSpec(spec: ITextSpec<IComposedTextMarkSpec>, key?: string): void;
+    compileEncode(): void;
 }
 export declare const registerTextMark: () => void;

package/types/series/dot/interface.d.ts

@@ -1,10 +1,10 @@
 import type { ICartesianSeriesSpec, ICartesianSeriesTheme } from '../cartesian/interface';
-import type { IMarkSpec, IMarkTheme } from '../../typings/spec/common';
+import type { IFormatMethod, IMarkSpec, IMarkTheme } from '../../typings/spec/common';
 import type { ISymbolMarkSpec, IRuleMarkSpec, ITextMarkSpec, ConvertToMarkStyleSpec } from '../../typings/visual';
 import type { SeriesMarkNameEnum } from '../interface/type';
 interface ISequenceLabel {
     visible?: boolean;
-    formatMethod?: (text: string | string[], datum?: any) => string | string[];
+    formatMethod?: IFormatMethod<[text: string | string[], datum?: any]>;
     style?: Omit<ConvertToMarkStyleSpec<ITextMarkSpec>, 'visible'>;
 }
 interface ISequenceGrid {

package/types/series/funnel/interface.d.ts

@@ -1,6 +1,8 @@
-import type { Datum, IMarkSpec, IMarkTheme, ISeriesSpec, IOrientType, IPathMarkSpec, IPolygonMarkSpec, IRuleMarkSpec, ITextMarkSpec, IPyramid3dMarkSpec, IPercent } from '../../typings';
+import type { Datum, IMarkSpec, IMarkTheme, ISeriesSpec, IOrientType, IPathMarkSpec, IPolygonMarkSpec, IRuleMarkSpec, ITextMarkSpec, IPyramid3dMarkSpec, IPercent, IComposedTextMarkSpec, IFormatMethod } from '../../typings';
 import type { IAnimationSpec } from '../../animation/spec';
 import type { SeriesMarkNameEnum } from '../interface/type';
+import { ILabelSpec } from '../../component';
+import { ITextSpec } from '../../mark/text';
 type FunnelMarks = 'funnel';
 export type FunnelAppearPreset = 'clipIn' | 'fadeIn';
 export interface IFunnelSeriesSpec extends ISeriesSpec, IAnimationSpec<FunnelMarks, FunnelAppearPreset> {
@@ -25,11 +27,11 @@ export interface IFunnelSeriesSpec extends ISeriesSpec, IAnimationSpec<FunnelMar
     [SeriesMarkNameEnum.outerLabel]?: IFunnelOuterLabelSpec;
     [SeriesMarkNameEnum.transformLabel]?: IFunnelLabelSpec;
 }
-interface IFunnelLabelSpec extends IMarkSpec<ITextMarkSpec> {
+interface IFunnelLabelSpec extends Omit<ILabelSpec, 'position'> {
     limit?: 'shapeSize' | number;
-    formatMethod?: (text: string | string[], datum?: Datum) => string | string[];
 }
-export interface IFunnelOuterLabelSpec extends IFunnelLabelSpec {
+export interface IFunnelOuterLabelSpec extends ITextSpec<IComposedTextMarkSpec> {
+    formatMethod?: IFormatMethod<[text: string | string[], datum?: Datum]>;
     position?: 'left' | 'right' | 'top' | 'bottom';
     spaceWidth?: number;
     alignLabel?: boolean;

package/types/series/line/interface.d.ts

@@ -16,7 +16,7 @@ export interface ILineSeriesSpec extends ICartesianSeriesSpec, IAnimationSpec<Li
     [SeriesMarkNameEnum.line]?: IMarkSpec<ILineMarkSpec>;
     [SeriesMarkNameEnum.label]?: ILineLikeLabelSpec;
     [SeriesMarkNameEnum.lineLabel]?: Omit<ILabelSpec, 'position'> & {
-        position: 'start' | 'end';
+        position?: 'start' | 'end';
     };
     seriesMark?: 'line' | 'point';
     activePoint?: boolean;

package/types/series/map/interface.d.ts

@@ -1,6 +1,7 @@
 import type { IPathMarkSpec, ITextMarkSpec } from '../../typings/visual';
 import type { IMarkSpec, IMarkTheme, ISeriesSpec } from '../../typings/spec/common';
 import type { IAnimationSpec } from '../../animation/spec';
+import { ILabelSpec } from '../../component';
 type LineMarks = 'area';
 export interface IMapSeriesSpec extends ISeriesSpec, IAnimationSpec<LineMarks, 'fadeIn'> {
     type: 'map';
@@ -14,11 +15,7 @@ export interface IMapSeriesSpec extends ISeriesSpec, IAnimationSpec<LineMarks, '
     };
     area?: IMarkSpec<Omit<IPathMarkSpec, 'smoothScale'>>;
     defaultFillColor?: string;
-    label?: IMarkSpec<ITextMarkSpec> & {
-        offset?: number;
-        position?: string;
-        formatMethod?: (text: string | string[], datum?: any) => string | string[];
-    };
+    label?: Omit<ILabelSpec, 'position'>;
 }
 export interface IMapSeriesTheme {
     defaultFillColor?: string;

package/types/series/pie/interface.d.ts

@@ -57,14 +57,15 @@ export interface IArcLabelLayoutSpec {
     strategy?: ArcLabelStrategyType;
     tangentConstraint?: boolean;
 }
-export interface IArcLabelSpec extends ILabelSpec {
+export type IArcLabelSpec = Omit<ILabelSpec, 'position'> & {
     position?: 'outside' | 'inside';
     showRule?: 'all' | 'max' | 'min' | 'minAndMax' | 'headAndTail';
     coverEnable?: boolean;
     rotate?: boolean;
     spaceWidth?: number;
     layoutArcGap?: number;
+    centerOffset?: number;
     style?: ITextMarkSpec;
     line?: IArcLabelLineSpec;
     layout?: IArcLabelLayoutSpec;
-}
+};

package/types/series/range-column/interface.d.ts

@@ -1,6 +1,6 @@
 import type { IBarSeriesSpec } from '../bar/interface';
 import type { ICartesianSeriesTheme } from '../cartesian/interface';
-import type { IMarkSpec, IMarkTheme } from '../../typings/spec/common';
+import type { IFormatMethod, IMarkSpec, IMarkTheme } from '../../typings/spec/common';
 import type { IPositionedTextMarkSpec, IRectMarkSpec, ITextMarkSpec } from '../../typings/visual';
 import type { IAnimationSpec } from '../../animation/spec';
 import type { RangeColumnAppearPreset } from './animation';
@@ -26,16 +26,16 @@ export interface IRangeColumnSeriesSpec extends Omit<IBarSeriesSpec, 'type' | 'l
     [SeriesMarkNameEnum.label]?: Partial<ILabelSpec> & {
         position?: PositionEnum;
         [SeriesMarkNameEnum.minLabel]?: IMarkSpec<IPositionedTextMarkSpec> & {
-            visible: boolean;
+            visible?: boolean;
             position?: keyof typeof minMaxPositionEnum;
             offset?: number;
-            formatMethod?: (text: string | string[], datum?: any) => string | string[];
+            formatMethod?: IFormatMethod<[text: string | string[], datum?: any]>;
         };
         [SeriesMarkNameEnum.maxLabel]?: IMarkSpec<IPositionedTextMarkSpec> & {
-            visible: boolean;
+            visible?: boolean;
             position?: minMaxPositionEnum;
             offset?: number;
-            formatMethod?: (text: string | string[], datum?: any) => string | string[];
+            formatMethod?: IFormatMethod<[text: string | string[], datum?: any]>;
         };
     };
 }

package/types/series/treemap/interface.d.ts

@@ -5,6 +5,7 @@ import type { ICartesianSeriesTheme } from '../cartesian/interface';
 import type { IAnimationSpec } from '../../animation/spec';
 import type { TreemapAppearPreset, TreemapMark } from './animation';
 import type { SeriesMarkNameEnum } from '../interface/type';
+import { ILabelSpec } from '../../component';
 export interface ITreemapSeriesSpec extends Omit<ISeriesSpec, 'data'>, IAnimationSpec<TreemapMark, TreemapAppearPreset> {
     type: 'treemap';
     categoryField: string;
@@ -23,8 +24,8 @@ export interface ITreemapSeriesSpec extends Omit<ISeriesSpec, 'data'>, IAnimatio
     drillField?: string;
     [SeriesMarkNameEnum.leaf]?: IMarkSpec<IRectMarkSpec>;
     [SeriesMarkNameEnum.nonLeaf]?: IMarkSpec<IRectMarkSpec>;
-    [SeriesMarkNameEnum.label]?: IMarkSpec<ITextMarkSpec>;
-    [SeriesMarkNameEnum.nonLeafLabel]?: IMarkSpec<ITextMarkSpec> & {
+    [SeriesMarkNameEnum.label]?: Omit<ILabelSpec, 'position' | 'overlap'>;
+    [SeriesMarkNameEnum.nonLeafLabel]?: Omit<ILabelSpec, 'position' | 'overlap'> & {
         position?: TreemapOptions['labelPosition'];
         padding?: TreemapOptions['labelPadding'];
     };

package/types/series/word-cloud/interface.d.ts

@@ -1,4 +1,4 @@
-import type { ITextMarkSpec, IMarkSpec, ISeriesSpec } from '../../typings';
+import type { ITextMarkSpec, IMarkSpec, ISeriesSpec, ITextFormatMethod } from '../../typings';
 import type { IAnimationSpec, IMarkAnimateSpec, IStateAnimateSpec } from '../../animation/spec';
 import type { SeriesMarkNameEnum } from '../interface/type';
 import type { WordcloudAppearPreset } from './animation';
@@ -71,7 +71,7 @@ export interface IWordCloudSeriesBaseSpec extends ISeriesSpec, IAnimationSpec<st
     wordCloudShapeConfig?: WordCloudShapeConfigType;
     [SeriesMarkNameEnum.word]?: IMarkSpec<ITextMarkSpec> & {
         padding?: number;
-        formatMethod?: (datum?: any) => string;
+        formatMethod?: ITextFormatMethod<[datum?: any]>;
     };
     [SeriesMarkNameEnum.fillingWord]?: IMarkSpec<ITextMarkSpec> & {
         padding?: number;
@@ -87,11 +87,9 @@ export interface IWordCloudSeriesSpec extends IWordCloudSeriesBaseSpec {
 export interface IWordCloudSeriesTheme {
     [SeriesMarkNameEnum.word]?: IMarkSpec<ITextMarkSpec> & {
         padding?: number;
-        formatMethod?: (datum?: any) => string;
     };
     [SeriesMarkNameEnum.fillingWord]?: IMarkSpec<ITextMarkSpec> & {
         padding?: number;
-        formatMethod?: (datum?: any) => string;
     };
 }
 export interface IWordCloud3dSeriesSpec extends IWordCloudSeriesBaseSpec {
@@ -102,10 +100,8 @@ export interface IWordCloud3dSeriesSpec extends IWordCloudSeriesBaseSpec {
 export interface IWordCloud3dSeriesTheme {
     [SeriesMarkNameEnum.word]?: IMarkSpec<ITextMarkSpec> & {
         padding?: number;
-        formatMethod?: (text: string | string[], datum?: any) => string | string[];
     };
     [SeriesMarkNameEnum.fillingWord]?: IMarkSpec<ITextMarkSpec> & {
         padding?: number;
-        formatMethod?: (text: string | string[], datum?: any) => string | string[];
     };
 }

package/types/typings/spec/common.d.ts

@@ -14,7 +14,7 @@ import type { Datum, StringOrNumber } from '../common';
 import type { IInvalidType } from '../data';
 import type { IMorphSeriesSpec } from '../../animation/spec';
 import type { IPlayer } from '../../component/player';
-import type { IMarkProgressiveConfig, MarkTypeEnum } from '../../mark/interface';
+import { IMarkProgressiveConfig, MarkTypeEnum } from '../../mark/interface';
 import type { IDataZoomSpec, IScrollBarSpec } from '../../component/data-zoom';
 import type { ICrosshairSpec } from '../../component/crosshair/interface';
 import type { ITheme } from '../../theme';
@@ -23,9 +23,9 @@ import type { IBrushSpec } from '../../component/brush';
 import type { ITotalLabelSpec } from '../../component/label';
 import type { ILegendSpec } from '../../component/legend';
 import type { ILayoutOrientPadding, ILayoutPaddingSpec } from '../layout';
-import type { ICustomPath2D } from '@visactor/vrender-core';
+import type { ICustomPath2D, IRichTextCharacter } from '@visactor/vrender-core';
 import type { ICommonAxisSpec } from '../../component/axis';
-import type { IMediaQuerySpec } from '..';
+import type { IComposedTextMarkSpec, IMediaQuerySpec } from '..';
 export type IChartPadding = ILayoutOrientPadding | number;
 export interface IInitOption extends Omit<IRenderOption, 'pluginList'> {
     dom?: string | HTMLElement;
@@ -235,12 +235,12 @@ export interface IPerformanceHook {
     beforeVRenderDraw?: () => void;
     afterVRenderDraw?: () => void;
 }
-export type IBuildinMarkSpec = {
+export type IBuiltInMarkSpec = {
     [MarkTypeEnum.group]: IGroupMarkSpec;
     [MarkTypeEnum.symbol]: ISymbolMarkSpec;
     [MarkTypeEnum.rule]: IRuleMarkSpec;
     [MarkTypeEnum.line]: ILineMarkSpec;
-    [MarkTypeEnum.text]: ITextMarkSpec;
+    [MarkTypeEnum.text]: IComposedTextMarkSpec;
     [MarkTypeEnum.rect]: IRectMarkSpec;
     [MarkTypeEnum.rect3d]: IRect3dMarkSpec;
     [MarkTypeEnum.image]: IImageMarkSpec;
@@ -255,8 +255,8 @@ export type IBuildinMarkSpec = {
     [MarkTypeEnum.progressArc]: IProgressArcMarkSpec;
     [MarkTypeEnum.ripple]: IRippleMarkSpec;
 };
-export type EnableMarkType = keyof IBuildinMarkSpec;
-export interface ICustomMarkSpec<T extends EnableMarkType> extends IMarkSpec<IBuildinMarkSpec[T]> {
+export type EnableMarkType = keyof IBuiltInMarkSpec;
+export interface ICustomMarkSpec<T extends EnableMarkType> extends IMarkSpec<IBuiltInMarkSpec[T]> {
     type: T;
     dataIndex?: number;
     dataId?: StringOrNumber;
@@ -273,3 +273,12 @@ export interface IExtensionMarkSpec<T extends Exclude<EnableMarkType, MarkTypeEn
 export interface IExtensionGroupMarkSpec extends ICustomMarkSpec<MarkTypeEnum.group> {
     children?: ICustomMarkSpec<EnableMarkType>[];
 }
+export type ITextFormatMethod<T extends any[]> = (...args: T) => ITextMarkSpec['text'] | {
+    type: 'text';
+    text: ITextMarkSpec['text'];
+};
+export type IRichTextFormatMethod<T extends any[]> = (...args: T) => {
+    type: 'rich';
+    text: IRichTextCharacter[];
+} | IRichTextCharacter[];
+export type IFormatMethod<T extends any[]> = (...args: T) => ReturnType<ITextFormatMethod<T>> | ReturnType<IRichTextFormatMethod<T>>;

package/types/typings/visual.d.ts

@@ -6,10 +6,10 @@ import type { ScaleType } from './scale';
 import type { ShapeType } from './shape';
 import type { IPoint } from './coordinate';
 import type { IAttributeOpt, IModelMarkAttributeContext } from '../compile/mark';
-import type { Datum, StringOrNumber } from './common';
+import type { Datum } from './common';
 import type { IPadding } from '@visactor/vutils';
 import type { IColorKey } from '../theme/color-scheme/interface';
-import type { IRepeatType, TextAlignType, TextBaselineType, IRichTextCharacter } from '@visactor/vrender-core';
+import type { IRepeatType, TextAlignType, TextBaselineType, IRichTextAttribute, IGraphicStyle } from '@visactor/vrender-core';
 export interface IVisualSpecBase<D, T> {
     type: ScaleType;
     domain: D[];
@@ -80,6 +80,7 @@ export interface ICommonSpec {
     texturePadding?: number;
     outerBorder?: IBorder;
     innerBorder?: IBorder;
+    html?: IMarkHtmlSpec;
     [key: string]: any;
 }
 export interface IFillMarkSpec extends ICommonSpec {
@@ -87,6 +88,7 @@ export interface IFillMarkSpec extends ICommonSpec {
     fillOpacity?: number;
     background?: string | HTMLImageElement | HTMLCanvasElement | null;
 }
+export type IMarkHtmlSpec = Partial<IGraphicStyle['html']>;
 export interface ISymbolMarkSpec extends IFillMarkSpec {
     dx?: number;
     dy?: number;
@@ -116,8 +118,7 @@ export interface IRuleMarkSpec extends ILineMarkSpec {
     y1?: number;
 }
 export interface ITextMarkSpec extends IFillMarkSpec {
-    type?: 'html' | 'rich' | 'text';
-    text?: StringOrNumber | string[] | IRichTextCharacter[] | Function;
+    text?: string | number | string[] | number[];
     dx?: number;
     dy?: number;
     fontSize?: number;
@@ -129,13 +130,17 @@ export interface ITextMarkSpec extends IFillMarkSpec {
     maxLineWidth?: number;
     ellipsis?: string;
     suffixPosition?: 'start' | 'end' | 'middle';
-    lineBreak?: string;
     underline?: boolean;
     lineThrough?: boolean;
     lineHeight?: number | string;
     poptip?: PopTipAttributes;
     direction?: 'horizontal' | 'vertical';
 }
+export type IRichTextMarkSpec = IRichTextAttribute & IFillMarkSpec & {
+    type: 'rich';
+    text: IRichTextAttribute['textConfig'];
+};
+export type IComposedTextMarkSpec = ITextMarkSpec | IRichTextMarkSpec;
 export type IPositionedTextMarkSpec = Omit<ITextMarkSpec, 'align' | 'textAlign' | 'baseline' | 'textBaseline'>;
 export interface IRectMarkSpec extends IFillMarkSpec {
     cornerRadius?: number | number[];