@visactor/vchart-types 1.13.7-alpha.0 → 2.0.0-alpha.0

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

@@ -1,20 +1,38 @@
-import type { IMarkStateStyle, MarkType } from '../../mark/interface';
+import type { IMark, IMarkStateStyle, MarkType } from '../../mark/interface';
 import type { IModel } from '../../model/interface';
 import type { GrammarItemCompileOption, GrammarItemInitOption, IGrammarItem } from '../interface';
 import type { DataView } from '@visactor/vdataset';
-import type { IAnimate, IAnimateArranger, IElement, IGroupMark, IMark, IMarkConfig, MarkAnimationSpec, Nil, TransformSpec } from '@visactor/vgrammar-core';
 import type { Maybe, Datum, StringOrNumber } from '../../typings';
 import type { IRegion } from '../../region/interface';
 import type { ICompilableData } from '../data/interface';
+import type { ICustomPath2D, IGraphic, IGroup } from '@visactor/vrender-core';
+import type { MarkAnimationSpec } from '../../animation/interface';
+export interface IMarkConfig {
+    clipPath?: IGraphic[] | ((graphics: IGraphic[]) => IGraphic[]);
+    clip?: boolean;
+    zIndex?: number;
+    interactive?: boolean;
+    setCustomizedShape?: (datum: any[], attrs: any, path: ICustomPath2D) => ICustomPath2D;
+    large?: boolean;
+    largeThreshold?: number;
+    progressiveStep?: number;
+    progressiveThreshold?: number;
+    support3d?: boolean;
+    graphicName?: string | ((g: IMarkConfig) => string);
+    morph?: boolean;
+    morphKey?: string;
+    morphElementKey?: string;
+    overflow?: 'scroll' | 'hidden' | 'scroll-x' | 'scroll-y';
+    skipTheme?: boolean;
+}
 export interface IMarkStateManager {
     getStateInfoList: () => IStateInfo[];
     getStateInfo: (stateValue: StateValue) => IStateInfo;
     addStateInfo: (stateInfo: IStateInfo) => void;
     changeStateInfo: (stateInfo: Partial<IStateInfo>) => void;
     clearStateInfo: (stateValues: StateValue[]) => void;
-    checkOneState: (renderNode: IElement, datum: Datum | Datum[], state: IStateInfo, isMultiMark?: boolean) => 'in' | 'out' | 'skip';
-    checkState: (renderNode: IElement, datum: Datum | Datum[]) => StateValue[];
-    updateLayoutState: (noRender?: boolean) => void;
+    checkOneState: (renderNode: IGraphic, datum: Datum[], state: IStateInfo) => 'in' | 'out' | 'skip';
+    checkState: (renderNode: IGraphic, datum: Datum[]) => StateValue[];
 }
 export interface IMarkData extends ICompilableData {
     setCompiledProductId: (name: string) => any;
@@ -33,48 +51,37 @@ export interface ICompilableMark extends IGrammarItem {
     readonly name: string;
     readonly key?: string | ((datum: Datum) => string);
     readonly model: IModel;
-    getData: () => IMarkData | undefined;
-    setData: (d: IMarkData) => void;
+    commit: (render?: boolean, recursion?: boolean) => void;
+    uncommit: () => void;
+    isCommited: () => boolean;
+    getData: () => ICompilableData | undefined;
+    setData: (d: ICompilableData) => void;
     getDataView: () => DataView | undefined;
-    setDataView: (d?: DataView, productId?: string) => void;
+    setDataView: (d: DataView) => void;
     state: IMarkStateManager;
     readonly stateStyle: IMarkStateStyle<any>;
     hasState: (state: string) => boolean;
     getState: (state: string) => any;
     updateState: (newState: Record<string, unknown>) => void;
-    updateStaticEncode: () => void;
     compileEncode: () => void;
-    updateLayoutState: (noRender?: boolean, recursion?: boolean) => void;
-    updateMarkState: (key: string) => void;
-    setTransform: (transform: TransformSpec[] | Nil) => void;
     setAnimationConfig: (config: Partial<MarkAnimationSpec>) => void;
     getAnimationConfig: () => Partial<MarkAnimationSpec>;
     getVisible: () => boolean;
     setVisible: (visible: boolean) => void;
-    getGroupKey: () => string | undefined;
     setGroupKey: (groupKey: string) => void;
     getUserId: () => StringOrNumber | undefined;
     setUserId: (id: StringOrNumber) => void;
     compile: (option?: IMarkCompileOption) => void;
-    getProduct: () => Maybe<IMark>;
-    getProductElements: () => Maybe<IMark['elements']>;
+    getProduct: () => Maybe<IGroup>;
     getMarks: () => ICompilableMark[];
     setSkipBeforeLayouted: (skip: boolean) => void;
-    getSkipBeforeLayouted: () => boolean;
-    setStateSortCallback: (stateSort: (stateA: string, stateB: string) => number) => void;
     getMarkConfig: () => IMarkConfig;
     setMarkConfig: (config: IMarkConfig) => void;
-    runAnimationByState: (animationState?: string) => IAnimateArranger;
-    stopAnimationByState: (animationState?: string) => IAnimate;
-    pauseAnimationByState: (animationState: string) => IAnimate;
-    resumeAnimationByState: (animationState: string) => IAnimate;
-}
-export interface IMarkDataInitOption extends ICompilableMarkOption {
-    mark: ICompilableMark;
+    getContext: () => any;
+    layout: (layoutCallback: () => void) => void;
 }
 export interface IMarkCompileOption extends GrammarItemCompileOption {
-    group?: string | IGroupMark;
-    ignoreChildren?: boolean;
+    group?: IGroup;
     context?: any;
 }
 export interface IStateInfo {
@@ -83,7 +90,11 @@ export interface IStateInfo {
     datums?: any[] | null | undefined;
     datumKeys?: string[] | null | undefined;
     items?: any[] | null | undefined;
-    filter?: ((datum: any, options: Record<string, any>) => boolean) | null | undefined;
+    filter?: ((datum: any, options: {
+        mark?: IMark;
+        type?: string;
+        renderNode?: IGraphic;
+    }) => boolean) | null | undefined;
     cache?: {
         [key: string]: {
             [key: string]: boolean;
@@ -116,7 +127,10 @@ export declare enum STATE_VALUE_ENUM {
     STATE_SELECTED = "selected",
     STATE_SELECTED_REVERSE = "selected_reverse",
     STATE_SANKEY_EMPHASIS = "selected",
-    STATE_SANKEY_EMPHASIS_REVERSE = "blur"
+    STATE_SANKEY_EMPHASIS_REVERSE = "blur",
+    STATE_HIGHLIGHT = "highlight",
+    STATE_BLUR = "blur",
+    STATE_ACTIVE = "active"
 }
 export declare enum STATE_VALUE_ENUM_REVERSE {
     STATE_HOVER_REVERSE = "hover_reverse",
@@ -130,11 +144,6 @@ export type STATE_CUSTOM = string;
 export type StateValueNot = STATE_HOVER_REVERSE | STATE_CUSTOM;
 export type StateValue = STATE_NORMAL | STATE_HOVER | STATE_CUSTOM;
 export type StateValueType = StateValue | StateValueNot;
-export interface IAttributeOpt {
-    element: IElement;
-    mark: IElement['mark'];
-    parent: IElement['mark']['group'];
-}
 export interface IModelMarkAttributeContext {
     [key: string]: unknown;
 }

package/types/compile/mark/mark-state-manager.d.ts

@@ -1,26 +1,24 @@
-import type { IElement, IMark as IVGrammarMark } from '@visactor/vgrammar-core';
+import type { IMark, IMarkGraphic } from '../../mark/interface';
 import type { Datum, StringOrNumber } from '../../typings';
-import type { IStateManagerOption } from '../signal/interface';
-import { StateManager } from '../signal/state-manager';
-import type { CompilableMark } from './compilable-mark';
 import type { IMarkStateManager, IStateInfo, StateValue } from './interface';
+import type { ICompilableInitOption } from '../interface/compilable-item';
+import { StateManager } from '../state-manager';
 export declare class MarkStateManager extends StateManager implements IMarkStateManager {
-    protected _mark: CompilableMark;
+    protected _mark: IMark;
     private _stateInfoList;
     getStateInfoList(): IStateInfo[];
-    constructor(option: IStateManagerOption, mark: CompilableMark);
+    constructor(options: ICompilableInitOption, mark: IMark);
     protected _getDefaultStateMap(): Record<string, unknown>;
     getStateInfo(stateValue: StateValue): IStateInfo;
     addStateInfo(stateInfo: IStateInfo): void;
     private _clearStateBeforeSet;
     changeStateInfo(stateInfo: Partial<IStateInfo>): void;
     clearStateInfo(stateValues: StateValue[]): void;
-    checkOneState(renderNode: IElement, datum: Datum | Datum[], state: IStateInfo, isMultiMark?: boolean): 'in' | 'out' | 'skip';
-    checkState(renderNode: IElement, datum: Datum | Datum[]): StateValue[];
-    checkDatumState(state: IStateInfo, datum: Datum | Datum[], isMultiMark: boolean): boolean;
+    protected _isMultiMark(): boolean;
+    checkOneState(renderNode: IMarkGraphic, datum: Datum[], state: IStateInfo): 'in' | 'out' | 'skip';
+    checkState(renderNode: IMarkGraphic, datum: Datum[]): StateValue[];
+    checkDatumState(state: IStateInfo, datum: Datum[]): boolean;
     checkItemsState(state: IStateInfo, item: any): boolean | undefined;
-    checkFieldsState(state: IStateInfo, datum: Datum | Datum[], item: any, isMultiMark: boolean): boolean;
-    checkLinearFieldState(domain: StringOrNumber[], key: string, datum: any, item: any, isMultiMark: boolean): boolean;
-    updateLayoutState(noRender?: boolean): void;
-    compileState(product: IVGrammarMark, stateSort?: (stateA: string, stateB: string) => number): void;
+    checkFieldsState(state: IStateInfo, datum: Datum[], item: any): boolean;
+    checkLinearFieldState(domain: StringOrNumber[], key: string, datum: any, item: any): boolean;
 }

package/types/compile/mark/util.d.ts

@@ -2,4 +2,4 @@ import type { IAttrs, IMarkStateStyle } from '../../mark/interface';
 export declare function isAttrChangeable<T>(key: string, stateStyle: IMarkStateStyle<T>): boolean;
 export declare function isStateAttrChangeable<T>(key: string, stateStyle: Partial<IAttrs<T>>, facetField: string): boolean;
 export declare function stateInDefaultEnum(state: string): boolean;
-export declare function stateToReverse(state: string): any;
+export declare function stateToReverse(state: string): string;

package/types/compile/state-manager.d.ts

@@ -0,0 +1,11 @@
+import { CompilableBase } from './compilable-base';
+import type { ICompilableInitOption, StateValueMap } from './interface/compilable-item';
+export declare class StateManager extends CompilableBase {
+    compile(): void;
+    protected _stateMap: StateValueMap;
+    getStateMap(): StateValueMap;
+    protected _getDefaultStateMap(): StateValueMap;
+    constructor(options: ICompilableInitOption);
+    initStateMap(state?: StateValueMap): void;
+    updateState(newState: Partial<StateValueMap>, noRender?: boolean): void;
+}

package/types/compile/util.d.ts

@@ -1,2 +1,16 @@
+import type { IMorphConfig } from '../animation/spec';
+import type { IMark } from '../mark/interface';
+import type { DiffResult } from '../typings/common';
 import type { RenderMode } from '../typings/spec';
 export declare function toRenderMode(mode: RenderMode): any;
+export declare function traverseGroupMark<T>(group: IMark, apply: (mark: IMark) => T, filter?: (mark: IMark) => boolean, leafFirst?: boolean, stop?: boolean): T | undefined;
+export declare function findSimpleMarks(groups: IMark[]): IMark[];
+export declare function diffUpdateByGroup(prev: IMark[], next: IMark[], prevKey: (datum: IMark) => string, nextKey: (datum: IMark) => string): {
+    prev: IMark[];
+    next: IMark[];
+    update: {
+        prev: IMark[];
+        next: IMark[];
+    }[];
+};
+export declare function diffMarks(prevMarks: IMark[], nextMarks: IMark[], runningConfig: IMorphConfig): DiffResult<IMark[], IMark[]>;

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

@@ -4,12 +4,13 @@ import type { IGraphic } from '@visactor/vrender-core';
 import type { IOrientType, IPolarOrientType, StringOrNumber, CoordinateType } from '../../typings';
 import { BaseComponent } from '../base/base-component';
 import { CompilableData } from '../../compile/data';
-import type { IAxis, ICommonAxisSpec, ITick } from './interface';
+import { type IAxis, type ICommonAxisSpec, type ITick } from './interface';
 import { type IComponentOption } from '../interface';
 import type { ISeries } from '../../series/interface';
 import type { ITransformOptions } from '@visactor/vdataset';
 import { DataView } from '@visactor/vdataset';
 import type { IComponentMark } from '../../mark/interface/mark';
+import type { ICompilableMark } from '../../compile/mark';
 export declare abstract class AxisComponent<T extends ICommonAxisSpec & Record<string, any> = any> extends BaseComponent<T> implements IAxis {
     static specKey: string;
     specKey: string;
@@ -50,7 +51,7 @@ export declare abstract class AxisComponent<T extends ICommonAxisSpec & Record<s
     getCoordinateType(): CoordinateType;
     constructor(spec: T, options: IComponentOption);
     protected _getNeedClearVRenderComponents(): IGraphic[];
-    getVRenderComponents(): any[];
+    getVRenderComponents(): import("@visactor/vrender-core").IGroup[];
     created(): void;
     protected _shouldComputeTickData(): boolean;
     protected _initData(): void;
@@ -68,8 +69,9 @@ export declare abstract class AxisComponent<T extends ICommonAxisSpec & Record<s
     protected initEvent(): void;
     protected updateScaleDomain(): void;
     protected _clearRawDomain(): void;
-    onLayoutEnd(ctx: any): void;
+    onLayoutEnd(): void;
     protected computeData(updateType?: 'domain' | 'range' | 'force'): void;
+    protected _updateTickDataMarks(m: ICompilableMark): void;
     protected initScales(): void;
     _compareSpec(spec: T, prevSpec: T): {
         change: boolean;

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

@@ -77,7 +77,7 @@ export declare abstract class CartesianAxis<T extends ICartesianAxisCommonSpec =
     protected updateScaleRange(): boolean;
     init(option: IModelInitOption): void;
     setAttrFromSpec(): void;
-    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect, ctx: any): void;
+    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect): void;
     protected getSeriesStatisticsField(s: ICartesianSeries): string[];
     protected _tickTransformOption(): ICartesianTickDataOpt;
     protected axisHelper(): IAxisHelper;

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

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

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

@@ -48,3 +48,11 @@ export interface ITickCalculationCfg {
 export interface IBandAxisLayer extends Omit<ITickCalculationCfg, 'noDecimals' | 'tickMode'> {
     visible?: boolean;
 }
+export declare enum AxisEnum {
+    lineAxis = "lineAxis",
+    circleAxis = "circleAxis"
+}
+export declare enum GridEnum {
+    lineAxisGrid = "lineAxisGrid",
+    circleAxisGrid = "circleAxisGrid"
+}

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

@@ -3,7 +3,6 @@ import type { IRegion } from '../../region/interface';
 import type { IComponent, IComponentOption } from '../interface';
 import type { IComponentPluginService, IComponentPlugin } from '../../plugin/components/interface';
 import type { IBoundsLike } from '@visactor/vutils';
-import type { IGroupMark } from '@visactor/vgrammar-core';
 import type { IAnimate } from '../../animation/interface';
 import type { Datum, ILayoutRect } from '../../typings';
 import type { IComponentSpec } from './interface';
@@ -41,7 +40,7 @@ export declare class BaseComponent<T extends IComponentSpec = IComponentSpec> ex
     release(): void;
     clear(): void;
     compile(): void;
-    compileMarks(group?: string | IGroupMark): void;
+    compileMarks(group?: IGroup): void;
     reAppendComponents(): void;
     protected _delegateEvent: (component: IGraphic, event: any, type: string, item?: any, datum?: Datum) => void;
     getBoundsInRect(rect: ILayoutRect, fullRect: ILayoutRect): IBoundsLike;

package/types/component/brush/brush.d.ts

@@ -6,7 +6,7 @@ import type { IModelRenderOption, IModelSpecInfo } from '../../model/interface';
 import type { IRegion } from '../../region/interface';
 import type { IGraphic } from '@visactor/vrender-core';
 import type { ISeries } from '../../series/interface';
-import type { IElement } from '@visactor/vgrammar-core';
+import type { IMarkGraphic } from '../../mark/interface';
 import type { BrushInteractiveRangeAttr, IBrush, IBrushSpec } from './interface';
 export declare class Brush<T extends IBrushSpec = IBrushSpec> extends BaseComponent<T> implements IBrush {
     layoutType: 'none';
@@ -23,19 +23,19 @@ export declare class Brush<T extends IBrushSpec = IBrushSpec> extends BaseCompon
     private _linkedItemMap;
     protected _inBrushElementsMap: {
         [brushName: string]: {
-            [elementKey: string]: IElement;
+            [elementKey: string]: IMarkGraphic;
         };
     };
     protected _outOfBrushElementsMap: {
-        [elementKey: string]: IElement;
+        [elementKey: string]: IMarkGraphic;
     };
     protected _linkedInBrushElementsMap: {
         [brushName: string]: {
-            [elementKey: string]: IElement;
+            [elementKey: string]: IMarkGraphic;
         };
     };
     protected _linkedOutOfBrushElementsMap: {
-        [elementKey: string]: IElement;
+        [elementKey: string]: IMarkGraphic;
     };
     private _needInitOutState;
     private _cacheInteractiveRangeAttrs;
@@ -49,12 +49,14 @@ export declare class Brush<T extends IBrushSpec = IBrushSpec> extends BaseCompon
     created(): void;
     protected _extendDataInBrush(elementsMap: {
         [brushName: string]: {
-            [elementKey: string]: IElement;
+            [elementKey: string]: IMarkGraphic;
         };
-    }): any[];
+    }): {
+        [x: string]: any;
+    }[];
     protected _extendDatumOutOfBrush(elementsMap: {
-        [elementKey: string]: IElement;
-    }): any[];
+        [elementKey: string]: IMarkGraphic;
+    }): import("../../typings").Datum[];
     protected _getBrushInteractiveAttr(region: IRegion): BrushInteractiveRangeAttr;
     protected _updateBrushComponent(region: IRegion, componentIndex: number): void;
     protected _createBrushComponent(region: IRegion, componentIndex: number): void;
@@ -83,7 +85,7 @@ export declare class Brush<T extends IBrushSpec = IBrushSpec> extends BaseCompon
         reSize: boolean;
         reCompile: boolean;
     };
-    onLayoutEnd(ctx: any): void;
+    onLayoutEnd(): void;
     clearGraphic(): void;
     clear(): void;
 }

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

@@ -1,7 +1,7 @@
 import type { IBoundsLike } from '@visactor/vutils';
 import { Tag } from '@visactor/vrender-components';
 import type { IGraphic } from '@visactor/vrender-core';
-import type { IModelLayoutOption, IModelRenderOption } from '../../model/interface';
+import type { IModelRenderOption } from '../../model/interface';
 import type { IRegion } from '../../region/interface';
 import { BaseComponent } from '../base/base-component';
 import type { IPoint, StringOrNumber, TooltipActiveType, TooltipData } from '../../typings';
@@ -68,7 +68,7 @@ export declare abstract class BaseCrossHair<T extends ICartesianCrosshairSpec |
     private _handleTooltipHideOrRelease;
     protected _getAxisInfoByField<T = IAxis>(field: 'x' | 'y' | 'category' | 'value'): IAxisInfo<T>;
     changeRegions(regions: IRegion[]): void;
-    onLayoutEnd(ctx: IModelLayoutOption): void;
+    onLayoutEnd(): void;
     onRender(ctx: IModelRenderOption): void;
     protected _releaseEvent(): void;
     protected _parseFieldInfo(): void;

package/types/component/custom-mark/custom-mark.d.ts

@@ -39,6 +39,5 @@ export declare class CustomMark extends BaseComponent<ICustomMarkSpec<EnableMark
         x2: number;
         y2: number;
     };
-    getVRenderComponents(): any[];
 }
 export declare const registerCustomMark: () => void;

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

@@ -115,8 +115,8 @@ export declare abstract class DataFilterBaseComponent<T extends IDataFilterCompo
     protected _initCommonEvent(): void;
     updateLayoutAttribute(): void;
     protected _autoVisible(isShown: boolean): void;
-    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect, ctx: any): void;
-    onLayoutEnd(ctx: any): void;
+    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect): void;
+    onLayoutEnd(): void;
     getBoundsInRect(rect: ILayoutRect): IBoundsLike;
     hide(): void;
     show(): void;

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

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

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

@@ -18,7 +18,7 @@ export declare class ScrollBar<T extends IScrollBarSpec = IScrollBarSpec> extend
     protected _component: ScrollBarComponent;
     constructor(spec: T, options: IComponentOption);
     setAttrFromSpec(): void;
-    onLayoutEnd(ctx: any): void;
+    onLayoutEnd(): void;
     protected _updateScaleRange(): void;
     protected _computeWidth(): number;
     protected _computeHeight(): number;

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

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

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

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

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

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

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

@@ -1,12 +1,11 @@
 import type { BaseLabelAttrs } from '@visactor/vrender-components';
 import type { ConvertToMarkStyleSpec, Datum, IComposedTextMarkSpec, IFormatMethod, ITextMarkSpec } from '../../typings';
 import type { IComponentSpec } from '../base/interface';
-import type { ILabelMark } from '../../mark/interface';
+import type { ILabelMark, IMark } from '../../mark/interface';
 import type { ISeries } from '../../series/interface';
-import type { ICompilableMark } from '../../compile/mark/interface';
 import type { IRegion } from '../../region/interface';
 export interface ILabelInfo {
-    baseMark: ICompilableMark;
+    baseMark: IMark;
     labelMark: ILabelMark;
     series: ISeries;
     labelSpec: TransformedLabelSpec;

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,5 +1,5 @@
 import { ComponentTypeEnum } from '../interface/type';
-import type { IModelLayoutOption, IModelRenderOption } from '../../model/interface';
+import type { IModelRenderOption } from '../../model/interface';
 import type { IRegion } from '../../region/interface';
 import { BaseComponent } from '../base/base-component';
 import type { BaseEventParams, EventCallback, EventQuery, EventType } from '../../event/interface';
@@ -44,8 +44,7 @@ export declare class Tooltip extends BaseComponent<any> implements ITooltip {
     protected _getNeedClearVRenderComponents(): IGraphic[];
     protected _registerEvent(): void;
     protected _releaseEvent(): void;
-    onLayout(ctx: IModelLayoutOption): void;
-    onLayoutEnd(ctx: IModelLayoutOption): void;
+    onLayoutEnd(): void;
     onRender(ctx: IModelRenderOption): void;
     created(): void;
     release(): void;

package/types/constant/data.d.ts

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