@visactor/vchart-types 1.10.0-alpha.4 → 1.10.0-alpha.6

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

@@ -12,7 +12,7 @@ import type { IEvent } from '../../event/interface';
 import type { DataView } from '@visactor/vdataset';
 import type { DataSet } from '@visactor/vdataset';
 import { Stack } from '../stack';
-import type { IParserOptions } from '@visactor/vdataset/es/parser';
+import type { IParserOptions } from '@visactor/vdataset';
 import type { IBoundsLike } from '@visactor/vutils';
 import type { IRunningConfig as IMorphConfig, IView } from '@visactor/vgrammar-core';
 import { CompilableBase } from '../../compile/compilable-base';

package/types/chart/interface/chart.d.ts

@@ -1,7 +1,7 @@
 import type { IEvent } from '../../event/interface';
 import type { LayoutCallBack } from '../../layout/interface';
 import type { IView } from '@visactor/vgrammar-core';
-import type { IParserOptions } from '@visactor/vdataset/es/parser';
+import type { IParserOptions } from '@visactor/vdataset';
 import type { IComponent, IComponentConstructor } from '../../component/interface';
 import type { IMark } from '../../mark/interface';
 import type { IModel, IModelConstructor, IModelSpecInfo, IUpdateSpecResult } from '../../model/interface';

package/types/compile/compiler.d.ts

@@ -3,7 +3,7 @@ import type { CompilerListenerParameters, CompilerModel, IGrammarItem, IRenderCo
 import type { IBoundsLike } from '@visactor/vutils';
 import type { EventSourceType } from '../event/interface';
 import type { IChart } from '../chart/interface';
-import type { VChart } from '../core/vchart';
+import { VChart } from '../core/vchart';
 import type { IColor, Stage } from '@visactor/vrender-core';
 import type { IMorphConfig } from '../animation/spec';
 type EventListener = {

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

@@ -39,21 +39,24 @@ export declare abstract class AxisComponent<T extends ICommonAxisSpec & Record<s
     protected abstract axisHelper(): any;
     protected abstract getSeriesStatisticsField(s: ISeries): string[];
     protected abstract updateSeriesScale(): void;
-    protected abstract collectData(depth: number, rawData?: boolean): {
-        min: number;
-        max: number;
-        values: any[];
-    }[];
+    protected abstract collectSeriesField(depth: number, series: ISeries): string | string[];
     abstract transformScaleDomain(): void;
     protected _dataFieldText: string;
     protected _axisMark: IComponentMark;
     protected _gridMark: IComponentMark;
     protected _coordinateType: CoordinateType;
+    getCoordinateType(): CoordinateType;
     constructor(spec: T, options: IComponentOption);
     protected _getNeedClearVRenderComponents(): IGraphic[];
     getVRenderComponents(): any[];
     created(): void;
+    protected _shouldComputeTickData(): boolean;
     protected _initData(): void;
+    protected collectData(depth: number, rawData?: boolean): {
+        min: number;
+        max: number;
+        values: any[];
+    }[];
     protected isSeriesDataEnable(): boolean;
     protected setSeriesAndRegionsFromSpec(): void;
     getBindSeriesFilter(): {
@@ -72,7 +75,6 @@ export declare abstract class AxisComponent<T extends ICommonAxisSpec & Record<s
         reSize: boolean;
         reCompile: boolean;
     };
-    protected getLabelFormatMethod(): (value: any, datum: any, index: number) => any;
     protected _delegateAxisContainerEvent(component: IGroup): void;
     protected _getAxisAttributes(): any;
     protected _getGridAttributes(): {
@@ -91,6 +93,7 @@ export declare abstract class AxisComponent<T extends ICommonAxisSpec & Record<s
             style: any;
         };
     };
+    protected _getLabelFormatMethod(): (value: any, datum: any, index: number) => any;
     protected _initTickDataSet<T extends ITickDataOpt>(options: T, index?: number): DataView;
     protected _tickTransformOption(): ITickDataOpt;
     addTransformToTickData(options: ITransformOptions, execute?: boolean): void;

package/types/component/axis/cartesian/axis.d.ts

@@ -86,11 +86,7 @@ export declare abstract class CartesianAxis<T extends ICartesianAxisCommonSpec =
     update(ctx: IComponentOption): void;
     resize(ctx: IComponentOption): void;
     protected collectScale(): IBaseScale[];
-    protected collectData(depth?: number, rawData?: boolean): {
-        min: number;
-        max: number;
-        values: any[];
-    }[];
+    protected collectSeriesField(depth: number, series: ICartesianSeries): string | string[];
     protected updateSeriesScale(): void;
     _transformLayoutPosition: (pos: Partial<IPoint>) => {
         x: number;

package/types/component/axis/cartesian/time-axis.d.ts

@@ -16,7 +16,7 @@ export declare class CartesianTimeAxis<T extends ICartesianTimeAxisSpec = ICarte
     setAttrFromSpec(): void;
     protected _initData(): void;
     protected computeData(updateType?: 'range' | 'domain' | 'force'): void;
-    protected getLabelFormatMethod(): any;
+    protected _getLabelFormatMethod(): any;
     protected getLabelItems(length: number): any[];
     transformScaleDomain(): void;
 }

package/types/component/axis/cartesian/util/index.d.ts

@@ -1,2 +1 @@
 export * from './common';
-export * from './time';

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

@@ -1,5 +1,5 @@
 import type { IBaseScale } from '@visactor/vscale';
-import type { Datum, IPolarOrientType, StringOrNumber } from '../../../typings';
+import type { CoordinateType, Datum, IPolarOrientType, StringOrNumber } from '../../../typings';
 import type { IComponent } from '../../interface/common';
 import type { ICartesianAxisSpec } from '../cartesian/interface';
 import type { ITextGraphicAttribute } from '@visactor/vrender-core';
@@ -15,6 +15,7 @@ export interface IAxis extends IComponent {
     getScales: () => IBaseScale[];
     getOrient: () => ICartesianAxisSpec['orient'] | IPolarOrientType;
     getInverse: () => boolean;
+    getCoordinateType: () => CoordinateType;
     visible: boolean;
     directionStr?: 'l2r' | 'r2l' | 't2b' | 'b2t';
 }

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

@@ -13,6 +13,7 @@ export interface ICommonAxisSpec extends Omit<IComponentSpec, 'orient' | 'center
     select?: boolean;
     hover?: boolean;
     sampling?: boolean;
+    forceInitTick?: boolean;
 }
 export interface ILinearAxisSpec {
     min?: number;
@@ -63,6 +64,7 @@ export interface ISubTick extends IAxisItem<IRuleMarkSpec> {
 export interface ILabel extends IAxisItem<ITextMarkSpec> {
     type?: 'text' | 'rich';
     formatMethod?: IFormatMethod<[text: string | string[], datum?: Datum]>;
+    formatter?: string | string[];
     space?: number;
     inside?: boolean;
     minGap?: number;

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

@@ -44,11 +44,7 @@ export declare abstract class PolarAxis<T extends IPolarAxisCommonSpec = IPolarA
     protected _tickTransformOption(): IPolarTickDataOpt;
     afterCompile(): void;
     protected updateScaleRange(): boolean;
-    protected collectData(depth: number, rawData?: boolean): {
-        min: number;
-        max: number;
-        values: any[];
-    }[];
+    protected collectSeriesField(depth: number, series: IPolarSeries): string | string[];
     protected abstract computeDomain(data: {
         min: number;
         max: number;

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

@@ -1,3 +1,8 @@
 import type { ITheme } from '../../theme';
+import { type IOrientType } from '../../typings';
+import type { ComponentThemeWithDirection } from '../interface';
 import { ComponentTypeEnum } from '../interface/type';
 export declare function getComponentThemeFromGlobalTheme(type: ComponentTypeEnum, chartTheme: ITheme, componentSpec: any, chartSpec: any): any;
+export declare const getComponentThemeWithDirection: <T>(componentSpec: {
+    orient?: IOrientType;
+}, originalTheme: ComponentThemeWithDirection<T>) => T;

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

@@ -22,6 +22,7 @@ export interface IHair {
     label?: {
         visible: boolean;
         formatMethod?: (text: StringOrNumber | string[], position: string) => string | string[];
+        formatter?: string | string[];
         textStyle?: Dict<any>;
         minWidth?: number;
         maxWidth?: number;
@@ -30,6 +31,9 @@ export interface IHair {
         zIndex?: number;
     };
 }
+export interface IHairRadius extends IHair {
+    smooth?: boolean;
+}
 export declare abstract class BaseCrossHair<T extends ICartesianCrosshairSpec | IPolarCrosshairSpec> extends BaseComponent<T> implements ICrossHair {
     static specKey: string;
     specKey: string;
@@ -75,7 +79,6 @@ export declare abstract class BaseCrossHair<T extends ICartesianCrosshairSpec |
     onLayoutEnd(ctx: IModelLayoutOption): void;
     onRender(ctx: IModelRenderOption): void;
     protected _releaseEvent(): void;
-    protected _firstSeries<T>(): T | null;
     protected _parseCrosshairSpec(): void;
     protected _parseField(field: ICrosshairCategoryFieldSpec, fieldName: string): any;
     protected _filterAxisByPoint<T>(axisMap: IAxisInfo<T>, relativeX: number, relativeY: number): IAxisInfo<T>;

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

@@ -2,7 +2,6 @@ import type { Maybe } from '@visactor/vutils';
 import type { IComponentOption } from '../interface';
 import { ComponentTypeEnum } from '../interface/type';
 import type { ICartesianCrosshairSpec } from './interface';
-import type { IBound } from './base';
 import { BaseCrossHair } from './base';
 import type { IGraphic } from '@visactor/vrender-core';
 import type { IAxis } from '../axis/interface';
@@ -32,18 +31,13 @@ export declare class CartesianCrossHair<T extends ICartesianCrosshairSpec = ICar
     private _findAllAxisContains;
     private _getValueAt;
     clearAxisValue(): void;
-    setAxisValue(v: StringOrNumber, axis: IAxis): void;
+    setAxisValue(value: StringOrNumber, axis: IAxis): void;
     private _getAllAxisValues;
     protected _layoutCrosshair(relativeX: number, relativeY: number): void;
     hide(): void;
-    _setRegionArea(outRegion: IBound, currentValue: Map<number, {
-        v: StringOrNumber;
-        axis: IAxis;
-    }>): void;
     layoutByValue(tag?: number): void;
     private _layoutVertical;
     private _layoutHorizontal;
-    private _getRectSize;
     protected _parseFieldInfo(): void;
     private _updateCrosshair;
     private _updateCrosshairLabel;

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

@@ -0,0 +1,46 @@
+import type { StringOrNumber } from '../../../typings';
+import type { IAxis } from '../../axis';
+export interface ICrosshairInfoX {
+    height: number;
+    leftPos: number;
+    rightPos: number;
+    topPos: number;
+    x: number;
+    bottom: {
+        visible: boolean;
+        text: StringOrNumber;
+        dx: number;
+        dy: number;
+    };
+    top: {
+        visible: boolean;
+        text: StringOrNumber;
+        dx: number;
+        dy: number;
+    };
+    visible: boolean;
+    _isCache?: boolean;
+    axis: IAxis;
+}
+export interface ICrosshairInfoY {
+    width: number;
+    leftPos: number;
+    topPos: number;
+    bottomPos: number;
+    y: number;
+    left: {
+        visible: boolean;
+        text: StringOrNumber;
+        dx: number;
+        dy: number;
+    };
+    right: {
+        visible: boolean;
+        text: StringOrNumber;
+        dx: number;
+        dy: number;
+    };
+    visible: boolean;
+    _isCache?: boolean;
+    axis: IAxis;
+}

package/types/component/crosshair/interface/common.d.ts

@@ -0,0 +1,7 @@
+import type { StringOrNumber } from '../../../typings';
+import type { IAxis } from '../../axis';
+export type AxisCurrentValueMap = Map<number, {
+    value: StringOrNumber;
+    axis: IAxis;
+    [key: string]: any;
+}>;

package/types/component/crosshair/interface/index.d.ts

@@ -1,2 +1,5 @@
 export * from './spec';
 export * from './theme';
+export * from './cartesian';
+export * from './polar';
+export * from './common';

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

@@ -0,0 +1,23 @@
+import type { IPoint, StringOrNumber } from '../../../typings';
+import type { IPolarAxis } from '../../axis';
+export interface IPolarCrosshairInfo {
+    x: number;
+    y: number;
+    center: IPoint;
+    radius: number;
+    distance: number;
+    startAngle: number;
+    endAngle: number;
+    innerRadius: number;
+    visible: boolean;
+    sides: number;
+    angle: number;
+    point: IPoint;
+    _isCache?: boolean;
+    label?: {
+        visible: boolean;
+        text: StringOrNumber;
+        offset: number;
+    };
+    axis?: IPolarAxis;
+}

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

@@ -56,6 +56,7 @@ export interface ICrosshairRectSpec {
 export interface ICrosshairLabelSpec {
     visible?: boolean;
     formatMethod?: (text: StringOrNumber | string[]) => string | string[];
+    formatter?: string | string[];
     style?: Partial<ITextMarkSpec>;
     labelBackground?: ICrosshairLabelBackgroundSpec;
 }

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

@@ -30,8 +30,8 @@ export declare class PolarCrossHair<T extends IPolarCrosshairSpec = IPolarCrossh
     private _getValueByAxis;
     protected _layoutCrosshair(relativeX: number, relativeY: number): void;
     layoutByValue(tag?: number): void;
-    private _layoutVertical;
-    private _layoutHorizontal;
+    private _layoutAngle;
+    private _layoutRadius;
     protected _parseFieldInfo(): void;
     private _updateCrosshairLabel;
     protected _getNeedClearVRenderComponents(): IGraphic[];

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

@@ -0,0 +1,32 @@
+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) => {
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+};
+export declare const layoutHorizontalCrosshair: (yHair: IHair, crosshairInfo: ICrosshairInfoY, bandHeight: number, offsetHeight: number) => {
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+};

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

@@ -0,0 +1,9 @@
+import type { Tag } from '@visactor/vrender-components';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { Datum } from '../../../typings';
+import type { ICrosshairTheme } from '../interface';
+import type { ITheme } from '../../../theme';
+export declare function limitTagInBounds(shape: Tag, bounds: IBoundsLike): void;
+export declare function getDatumByValue(data: Datum[], value: number, startField: string, endField?: string): Datum | null;
+export declare const getCartesianCrosshairTheme: (chartTheme: ITheme, chartSpec: any) => ICrosshairTheme;
+export declare const getPolarCrosshairTheme: (chartTheme: ITheme, chartSpec: any) => ICrosshairTheme;

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

@@ -0,0 +1 @@
+export * from './common';

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

@@ -0,0 +1,37 @@
+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;
+    innerRadius: number;
+    radius: number;
+    startAngle: number;
+    endAngle: number;
+    start?: undefined;
+    end?: undefined;
+} | {
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+    center?: undefined;
+    innerRadius?: undefined;
+    radius?: undefined;
+    startAngle?: undefined;
+    endAngle?: undefined;
+};
+export declare const layoutRadiusCrosshair: (radiusHair: IHairRadius, crosshairInfo: IPolarCrosshairInfo) => {
+    center: import("../../../typings").IPoint;
+    startAngle: number;
+    endAngle: number;
+    radius: number;
+    sides: number;
+};

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

@@ -73,6 +73,7 @@ export declare class DataZoom<T extends IDataZoomSpec = IDataZoomSpec> extends D
         };
         disableTriggerEvent: boolean;
     };
+    protected _getHandlerTextFormatMethod(spec: IDataZoomSpec['startText']): (text: any) => any;
     protected _getNeedClearVRenderComponents(): IGraphic[];
 }
 export declare const registerDataZoom: () => void;

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

@@ -1,7 +1,7 @@
 import type { IMarkSpec } from '../../../typings/spec';
 import type { IAreaMarkSpec, ILineMarkSpec, IRectMarkSpec, ISymbolMarkSpec, ITextMarkSpec } from '../../../typings/visual';
 import type { IComponentSpec } from '../../base/interface';
-import type { IComponent } from '../../interface';
+import type { ComponentThemeWithDirection, IComponent } from '../../interface';
 import type { IFilterMode } from '../constant';
 import type { IDataFilterComponent, IDataFilterComponentSpec } from '../interface';
 export type IDataZoom = IComponent & IDataFilterComponent;
@@ -43,11 +43,13 @@ export interface IDataZoomSpec extends IDataZoomStyle, IDataFilterComponentSpec
         padding?: number;
         style?: IMarkSpec<ITextMarkSpec>;
         formatMethod?: (text: string | number) => string | string[];
+        formatter?: string | string[];
     };
     endText?: {
         padding?: number;
         style?: IMarkSpec<ITextMarkSpec>;
         formatMethod?: (text: string | number) => string | string[];
+        formatter?: string | string[];
     };
     brushSelect?: boolean;
     ignoreBandSize?: boolean;
@@ -58,7 +60,4 @@ export type IDataZoomCommonTheme = IComponentSpec & IDataZoomStyle & {
     height?: IDataZoomSpec['height'];
     brushSelect?: boolean;
 };
-export type IDataZoomTheme = IDataZoomCommonTheme & {
-    horizontal?: Omit<IDataZoomCommonTheme, 'orient'>;
-    vertical?: Omit<IDataZoomCommonTheme, 'orient'>;
-};
+export type IDataZoomTheme = ComponentThemeWithDirection<IDataZoomCommonTheme>;

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

@@ -1,6 +1,7 @@
 import type { ILayoutItemSpec } from '../../../layout/interface';
 import type { IPadding } from '../../../typings';
 import type { IRectMarkSpec } from '../../../typings/visual';
+import type { ComponentThemeWithDirection } from '../../interface';
 import type { IFilterMode } from '../constant';
 import type { IDataFilterComponentSpec } from '../interface';
 export interface IScrollBarStyle {
@@ -21,7 +22,4 @@ export type IScrollBarCommonTheme = ILayoutItemSpec & IScrollBarStyle & {
     round?: IScrollBarSpec['round'];
     innerPadding?: IScrollBarSpec['innerPadding'];
 };
-export type IScrollBarTheme = IScrollBarCommonTheme & {
-    horizontal?: Omit<IScrollBarCommonTheme, 'orient'>;
-    vertical?: Omit<IScrollBarCommonTheme, 'orient'>;
-};
+export type IScrollBarTheme = ComponentThemeWithDirection<IScrollBarCommonTheme>;

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

@@ -1,6 +1,3 @@
-import type { IOrientType } from '../../typings';
-import type { ComponentTypeEnum } from '../interface';
-import type { ITheme } from '../../theme';
 export interface IDataFilterWithNewDomainOption {
     getNewDomain: () => any[];
     isContinuous: () => boolean;
@@ -20,4 +17,3 @@ export interface IDataFilterComputeDomainOption {
     };
 }
 export declare const dataFilterComputeDomain: (data: Array<any>, op: IDataFilterComputeDomainOption) => any[];
-export declare const getDataFilterTheme: (orient: IOrientType, type: ComponentTypeEnum, chartTheme: ITheme) => any;

package/types/component/index.d.ts

@@ -45,3 +45,4 @@ export { ScrollBar, DataZoom, CustomMark, Brush, MapLabelComponent, CartesianAxi
 export { registerBrush, registerScrollBar, registerTitle, registerTooltip, registerCartesianBandAxis, registerCartesianCrossHair, registerCartesianLinearAxis, registerCartesianLogAxis, registerCartesianSymlogAxis, registerCartesianTimeAxis, registerContinuousLegend, registerCustomMark, registerDataZoom, registerDiscreteLegend, registerGeoCoordinate, registerIndicator, registerLabel, registerTotalLabel, registerMapLabel, registerMarkArea, registerMarkLine, registerMarkPoint, registerPlayer, registerPolarBandAxis, registerPolarCrossHair, registerPolarLinearAxis, registerPoptip };
 export type { IComponent, IScrollBarSpec, IBrushSpec, ICartesianAxisSpec, ICartesianBandAxisSpec, ICartesianCrosshairSpec, ICartesianLinearAxisSpec, ICartesianTimeAxisSpec, ICartesianLogAxisSpec, IContinuousLegendSpec, IDataZoomSpec, IDiscreteLegendSpec, IGeoCoordinateSpec, IIndicatorSpec, ILabelSpec, IMapLabelSpec, IMarkAreaSpec, IMarkLineSpec, IStepMarkLineSpec, IMarkPointSpec, IPlayerSpec, IPolarAxisSpec, IPolarBandAxisSpec, IPolarCrosshairSpec, IPolarLinearAxisSpec, ITitleSpec, ITooltipSpec };
 export type { IComponentTheme, ICrosshairTheme, IAxisItemTheme, IAxisCommonTheme, IBandAxisTheme, IPolarAxisCommonTheme, ICartesianAxisCommonTheme, IBrushTheme, IDataZoomTheme, IScrollBarTheme, IIndicatorTheme, IMapLabelTheme, ITotalLabelTheme, ISizeLegendTheme, IColorLegendTheme, IDiscreteLegendTheme, IContinuousLegendTheme, IMarkAreaTheme, IMarkLineTheme, IMarkPointTheme, IPlayerTheme, IPoptipTheme, ITitleTheme, ITooltipTheme };
+export * from './tooltip/interface';

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

@@ -15,6 +15,7 @@ import type { ComponentTypeEnum } from './type';
 import type { ITotalLabelTheme } from '../label';
 import type { IPoptipTheme } from '../poptip/interface';
 import type { IColorKey } from '../../theme';
+import type { Direction, IOrientType } from '../../typings';
 export interface IComponentTheme {
     axis?: IAxisCommonTheme;
     axisBand?: IAxisCommonTheme;
@@ -42,3 +43,10 @@ export interface IComponentTheme {
     [ComponentTypeEnum.poptip]?: IPoptipTheme;
     [ComponentTypeEnum.totalLabel]?: ITotalLabelTheme;
 }
+export type ComponentThemeWithDirection<T extends {
+    orient?: IOrientType;
+}> = T & {
+    orient?: IOrientType;
+    [Direction.horizontal]?: Omit<T, 'orient'>;
+    [Direction.vertical]?: Omit<T, 'orient'>;
+};

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

@@ -11,7 +11,7 @@ export interface ILabelSpec extends IComponentSpec {
     interactive?: boolean;
     textType?: 'text' | 'rich';
     formatMethod?: IFormatMethod<[text: string | string[], datum?: Datum, ctx?: ILabelFormatMethodContext]>;
-    formatter?: string;
+    formatter?: string | string[];
     offset?: number;
     position?: string;
     style?: ConvertToMarkStyleSpec<IComposedTextMarkSpec>;

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

@@ -1,4 +1,5 @@
 import type { IRectMarkSpec, ISymbolMarkSpec, ITextMarkSpec, StringOrNumber } from '../../../typings';
+import type { ComponentThemeWithDirection } from '../../interface';
 import type { ILegendCommonSpec, NoVisibleMarkStyle } from '../interface';
 type Text = StringOrNumber;
 export type TextAttribute = {
@@ -44,16 +45,9 @@ export type ISizeLegendSpec = IContinuousLegendSpec & {
     align?: 'top' | 'bottom' | 'left' | 'right';
 };
 export type IContinuousLegendTheme = Omit<IContinuousLegendSpec, 'type' | 'field' | 'scale' | 'regionIndex' | 'regionId' | 'seriesIndex' | 'seriesId' | 'id' | 'defaultSelected'>;
-export interface IColorLegendTheme {
-    horizontal?: IContinuousLegendTheme;
-    vertical?: IContinuousLegendTheme;
-}
-export interface ISizeLegendTheme {
-    horizontal?: IContinuousLegendTheme & {
-        sizeBackground?: ISizeLegendSpec['sizeBackground'];
-    };
-    vertical?: IContinuousLegendTheme & {
-        sizeBackground?: ISizeLegendSpec['sizeBackground'];
-    };
-}
+export type ISizeLegendCommonTheme = IContinuousLegendTheme & {
+    sizeBackground?: ISizeLegendSpec['sizeBackground'];
+};
+export type IColorLegendTheme = ComponentThemeWithDirection<IContinuousLegendTheme>;
+export type ISizeLegendTheme = ComponentThemeWithDirection<ISizeLegendCommonTheme>;
 export {};

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

@@ -1,9 +1,10 @@
 import type { IRectMarkSpec, ISymbolMarkSpec, ITextMarkSpec } from '../../../typings/visual';
-import type { DiscreteLegendAttrs, LegendItemDatum, LegendItem } from '@visactor/vrender-components';
+import type { DiscreteLegendAttrs, LegendItemDatum, LegendItem, LegendPagerAttributes, LegendScrollbarAttributes } from '@visactor/vrender-components';
 import type { ILegendCommonSpec, NoVisibleMarkStyle } from '../interface';
 import type { IFormatMethod, StringOrNumber } from '../../../typings';
 import type { IBaseScale } from '@visactor/vscale';
 import type { IGlobalScale } from '../../../scale/interface';
+import type { ComponentThemeWithDirection } from '../../interface';
 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> = {
@@ -16,6 +17,7 @@ export type LegendItemStyle<T> = {
     };
 };
 export type IItem = {
+    align?: 'left' | 'right';
     background?: {
         visible?: boolean;
     } & LegendItemStyle<LegendItemStyleValue<NoVisibleMarkStyle<IRectMarkSpec>>>;
@@ -24,18 +26,23 @@ export type IItem = {
         space?: number;
     } & LegendItemStyle<LegendItemStyleValue<Partial<NoVisibleMarkStyle<ISymbolMarkSpec>>>>;
     label?: {
+        widthRatio?: number;
         space?: number;
         formatMethod?: formatterCallback;
+        formatter?: string;
     } & LegendItemStyle<LegendItemStyleValue<NoVisibleMarkStyle<ITextMarkSpec>>>;
     value?: {
+        widthRatio?: number;
         space?: number;
         alignRight?: boolean;
         formatMethod?: formatterCallback;
+        formatter?: string | string[];
     } & LegendItemStyle<LegendItemStyleValue<NoVisibleMarkStyle<ITextMarkSpec>>>;
     focusIconStyle?: NoVisibleMarkStyle<ISymbolMarkSpec>;
     maxWidth?: number | string;
     width?: number | string;
     height?: number | string;
+    autoEllipsisStrategy?: 'labelFirst' | 'valueFirst' | 'none';
 } & Omit<LegendItem, 'background' | 'shape' | 'label' | 'value' | 'focusIconStyle' | 'width' | 'height' | 'maxWidth'>;
 export type IPager = {
     textStyle?: Partial<NoVisibleMarkStyle<ITextMarkSpec>>;
@@ -49,14 +56,20 @@ export type IPager = {
             disable?: Omit<NoVisibleMarkStyle<ISymbolMarkSpec>, 'symbolType'>;
         };
     };
-} & Omit<DiscreteLegendAttrs['pager'], 'textStyle' | 'handler'>;
+} & Omit<LegendPagerAttributes, 'textStyle' | 'handler'>;
+export type ILegendScrollbar = {
+    type: 'scrollbar';
+    railStyle?: Omit<Partial<NoVisibleMarkStyle<IRectMarkSpec>>, 'width' | 'height'>;
+    sliderStyle?: Omit<Partial<NoVisibleMarkStyle<IRectMarkSpec>>, 'width' | 'height'>;
+} & Omit<LegendScrollbarAttributes, 'railStyle' | 'sliderStyle'>;
 export type IDiscreteLegendSpec = ILegendCommonSpec & {
     type?: 'discrete';
     data?: (data: LegendItemDatum[], colorScale: IBaseScale, globalScale: IGlobalScale) => LegendItemDatum[];
     item?: IItem;
-    pager?: IPager;
+    pager?: IPager | ILegendScrollbar;
     scaleName?: string;
     field?: string;
     defaultSelected?: string[];
 } & Omit<DiscreteLegendAttrs, 'layout' | 'title' | 'items' | 'item' | 'pager'>;
-export type IDiscreteLegendTheme = Omit<IDiscreteLegendSpec, 'type' | 'data' | 'regionIndex' | 'regionId' | 'seriesIndex' | 'seriesId' | 'id' | 'defaultSelected'>;
+export type IDiscreteLegendCommonTheme = Omit<IDiscreteLegendSpec, 'type' | 'data' | 'regionIndex' | 'regionId' | 'seriesIndex' | 'seriesId' | 'id' | 'defaultSelected'>;
+export type IDiscreteLegendTheme = ComponentThemeWithDirection<IDiscreteLegendCommonTheme>;

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

@@ -23,5 +23,6 @@ export declare class DiscreteLegend extends BaseLegend<IDiscreteLegendSpec> {
     protected _getLegendConstructor(): typeof LegendComponent;
     protected _initEvent(): void;
     private _getLegendItems;
+    private _addLegendItemFormatMethods;
 }
 export declare const registerDiscreteLegend: () => void;

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

@@ -1,4 +1,4 @@
-import type { ILegendCommonSpec, ITitle } from './interface';
+import type { ITitle } from './interface';
 export declare function transformLegendTitleAttributes(title: ITitle): {
     textStyle?: import("./interface").NoVisibleMarkStyle<import("../..").ITextMarkSpec>;
     style?: import("./interface").NoVisibleMarkStyle<import("../..").ITextMarkSpec>;
@@ -29,4 +29,3 @@ export declare function transformLegendTitleAttributes(title: ITitle): {
     space?: number;
     align?: "start" | "end" | "center";
 };
-export declare function getLayout(spec: ILegendCommonSpec): "vertical" | "horizontal";