@visactor/vchart-types 1.6.2 → 1.7.0-alpha.0

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

@@ -1,13 +1,16 @@
 import { DataView } from '@visactor/vdataset';
 import type { IDiscreteLegendSpec, IDiscreteLegendTheme } from './interface';
 import type { ISeries } from '../../../series/interface';
-import type { IModelInitOption, ILayoutRect } from '../../../model/interface';
+import type { IModelInitOption } from '../../../model/interface';
 import type { IComponentOption } from '../../interface';
 import { ComponentTypeEnum } from '../../interface/type';
 import { DiscreteLegend as LegendComponent } from '@visactor/vrender-components';
 import type { ILegend } from '../interface';
 import { BaseLegend } from '../base-legend';
+import type { ILayoutRect } from '../../../typings/layout';
 export declare class DiscreteLegend extends BaseLegend<IDiscreteLegendSpec> {
+    static specKey: string;
+    specKey: string;
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
     name: string;

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

@@ -1,3 +1,3 @@
-import type { ILayoutRect } from '../../../model/interface';
 import type { IDiscreteLegendSpec } from './interface';
+import type { ILayoutRect } from '../../../typings/layout';
 export declare function getLegendAttributes(spec: IDiscreteLegendSpec, rect: ILayoutRect): any;

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[];
     visible?: boolean;

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

@@ -5,9 +5,8 @@ import { ComponentTypeEnum } from '../interface/type';
 import { LayoutZIndex } from '../../constant';
 import type { IMapLabelSpec, MapLabelSceneNodeMap } from './interface';
 import type { ICartesianSeries, IGeoSeries } from '../../series/interface';
-import type { IPoint, Datum } from '../../typings';
+import type { IPoint, Datum, ILayoutType } from '../../typings';
 import type { IPairInfo } from './layout';
-import type { LayoutItem } from '../../model/layout-item';
 import { MarkPoint } from '@visactor/vrender-components';
 import type { IGraphic } from '@visactor/vrender-core';
 import type { PanEventParam, ZoomEventParam } from '../../event/interface';
@@ -15,8 +14,7 @@ export declare class MapLabelComponent extends BaseComponent<IMapLabelSpec> {
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
     name: string;
-    layoutType: LayoutItem['layoutType'];
-    static speckey: string;
+    layoutType: ILayoutType;
     layoutZIndex: LayoutZIndex;
     protected nameField: string;
     protected valueField?: string;

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

@@ -1,14 +1,13 @@
 import type { DataView } from '@visactor/vdataset';
 import type { IModelRenderOption } from '../../model/interface';
-import type { LayoutItem } from '../../model/layout-item';
 import type { IRegion } from '../../region/interface';
 import type { ICartesianSeries } from '../../series/interface';
-import type { StringOrNumber } from '../../typings';
+import type { ILayoutType, StringOrNumber } from '../../typings';
 import { BaseComponent } from '../base/base-component';
 import type { IAggrType, IDataPos, IDataPosCallback, IMarkerAxisSpec, IMarkerSpec } from './interface';
 import type { IGraphic } from '@visactor/vrender-core';
 export declare abstract class BaseMarker<T extends IMarkerSpec & IMarkerAxisSpec> extends BaseComponent<T> {
-    layoutType: LayoutItem['layoutType'];
+    layoutType: ILayoutType;
     protected _startRelativeSeries: ICartesianSeries;
     protected _endRelativeSeries: ICartesianSeries;
     protected _relativeSeries: ICartesianSeries;

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

@@ -22,7 +22,7 @@ export type IMarkerLabelWithoutRefSpec = {
     labelBackground?: {
         visible?: boolean;
         padding?: IPadding | number[] | number;
-        style: Omit<IRectMarkSpec, 'visible'>;
+        style?: Omit<IRectMarkSpec, 'visible'>;
     };
     text?: string | string[] | number | number[];
     formatMethod?: (markData: Datum[], seriesData: Datum[]) => string | string[] | number | number[];

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

@@ -3,13 +3,11 @@ import type { IComponentOption } from '../../interface';
 import { ComponentTypeEnum } from '../../interface/type';
 import { MarkArea as MarkAreaComponent } from '@visactor/vrender-components';
 import { BaseMarker } from '../base-marker';
-import type { LayoutItem } from '../../../model/layout-item';
 export declare class MarkArea extends BaseMarker<IMarkAreaSpec & IMarkAreaTheme> implements IMarkArea {
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
     name: string;
-    layoutZIndex: LayoutItem['layoutZIndex'];
-    static speckey: string;
+    layoutZIndex: number;
     protected _theme: IMarkAreaTheme;
     protected _markerComponent: MarkAreaComponent;
     static createComponent(spec: any, options: IComponentOption): MarkArea | MarkArea[];

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

@@ -3,13 +3,11 @@ import type { IComponentOption } from '../../interface';
 import { ComponentTypeEnum } from '../../interface/type';
 import { MarkLine as MarkLineComponent } from '@visactor/vrender-components';
 import { BaseMarker } from '../base-marker';
-import type { LayoutItem } from '../../../model/layout-item';
 export declare class MarkLine extends BaseMarker<IMarkLineSpec & IMarkLineTheme> implements IMarkLine {
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
     name: string;
-    layoutZIndex: LayoutItem['layoutZIndex'];
-    static speckey: string;
+    layoutZIndex: number;
     protected _theme: IMarkLineTheme;
     protected _markerComponent: MarkLineComponent;
     static createComponent(spec: any, options: IComponentOption): MarkLine | MarkLine[];

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

@@ -3,13 +3,11 @@ import type { IComponentOption } from '../../interface';
 import { ComponentTypeEnum } from '../../interface/type';
 import { MarkPoint as MarkPointComponent } from '@visactor/vrender-components';
 import { BaseMarker } from '../base-marker';
-import type { LayoutItem } from '../../../model/layout-item';
 export declare class MarkPoint extends BaseMarker<IMarkPointSpec & IMarkPointTheme> implements IMarkPoint {
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
     name: string;
-    layoutZIndex: LayoutItem['layoutZIndex'];
-    static speckey: string;
+    layoutZIndex: number;
     protected _theme: IMarkPointTheme;
     protected _markerComponent: MarkPointComponent;
     static createComponent(spec: any, options: IComponentOption): MarkPoint | MarkPoint[];

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

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

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

@@ -1,20 +1,20 @@
 import type { IGraphic } from '@visactor/vrender-core';
-import type { ILayoutRect, IModelRenderOption } from '../../model/interface';
+import type { IModelRenderOption } from '../../model/interface';
 import type { IRegion } from '../../region/interface';
 import type { IComponentOption } from '../interface';
 import type { IPlayer } from './interface';
 import type { IComponent } from '../interface';
-import type { IPoint, IOrientType } from '../../typings';
+import type { IPoint, IOrientType, ILayoutRect } from '../../typings';
 import { type IChartSpec } from '../..';
 import { ComponentTypeEnum } from '../interface/type';
 import { BaseComponent } from '../base/base-component';
 export declare class Player extends BaseComponent<IPlayer> implements IComponent {
     layoutZIndex: number;
     layoutLevel: number;
+    specKey: string;
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
-    specKey: string;
-    private _orient;
+    protected _orient: IOrientType;
     private _specs;
     private _playerComponent;
     private _cacheAttrs;
@@ -26,12 +26,11 @@ export declare class Player extends BaseComponent<IPlayer> implements IComponent
     private _height;
     private _position;
     get orient(): IOrientType;
-    get layoutOrient(): IOrientType;
     set layoutOrient(v: IOrientType);
     static createComponent: (spec: IChartSpec, options: IComponentOption) => Player;
     setAttrFromSpec(): void;
-    setLayoutStartPosition(pos: Partial<IPoint>): void;
-    _boundsInRect(rect: ILayoutRect, fullSpace: ILayoutRect): {
+    afterSetLayoutStartPoint(pos: IPoint): void;
+    getBoundsInRect(rect: ILayoutRect, fullSpace: ILayoutRect): {
         x1: number;
         y1: number;
         x2: number;

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

@@ -1,4 +1,4 @@
-import type { ILayoutItemSpec } from '../../../model/interface';
+import type { ILayoutItemSpec } from '../../../layout/interface';
 import type { IColorKey } from '../../../theme/color-scheme/interface';
 import type { StringOrNumber } from '../../../typings';
 import type { TextAlign, TextBaseLine } from '../../../typings/visual';

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

@@ -3,24 +3,21 @@ import { ComponentTypeEnum } from '../interface/type';
 import type { IComponentOption } from '../interface';
 import type { ITitle, ITitleSpec, ITitleTheme } from './interface';
 import type { IRegion } from '../../region/interface';
-import type { ILayoutRect } from '../../model/interface';
 import type { IGraphic } from '@visactor/vrender-core';
-import type { IPoint, IOrientType } from '../../typings';
-import type { LayoutItem } from '../../model/layout-item';
+import type { IPoint, IOrientType, ILayoutType, ILayoutRect } from '../../typings';
 export declare class Title extends BaseComponent<ITitleSpec> implements ITitle {
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
-    layoutType: LayoutItem['layoutType'];
-    layoutZIndex: LayoutItem['layoutZIndex'];
+    layoutType: ILayoutType;
+    layoutZIndex: number;
     layoutLevel: number;
     protected _theme: ITitleTheme;
     protected _orient: IOrientType;
     private _titleComponent;
     private _cacheAttrs;
     get orient(): IOrientType;
-    get layoutOrient(): IOrientType;
-    set layoutOrient(v: IOrientType);
     constructor(spec: ITitleSpec, options: IComponentOption);
+    initLayout(): void;
     static createComponent(spec: any, options: IComponentOption): Title | Title[];
     onRender(ctx: any): void;
     _compareSpec(): {
@@ -33,8 +30,8 @@ export declare class Title extends BaseComponent<ITitleSpec> implements ITitle {
     changeRegions(regions: IRegion[]): void;
     update(ctx: IComponentOption): void;
     resize(ctx: IComponentOption): void;
-    setLayoutStartPosition(pos: Partial<IPoint>): void;
-    _boundsInRect(rect: ILayoutRect): {
+    afterSetLayoutStartPoint(pos: IPoint): void;
+    getBoundsInRect(rect: ILayoutRect): {
         x1: number;
         y1: number;
         x2: number;

package/types/component/tooltip/handler/dom/model/shape-model.d.ts

@@ -10,6 +10,7 @@ export interface IShapeSvgOption {
     lineWidth?: number;
     hollow?: boolean;
     marginTop?: string;
+    index?: number;
 }
 export declare class ShapeModel extends BaseTooltipModel {
     svg: SVGElement;

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

@@ -1,11 +1,11 @@
 import type { IComponentOption } from '../interface';
 import { ComponentTypeEnum } from '../interface/type';
-import type { IModelLayoutOption, IModelRenderOption, ILayoutItem } from '../../model/interface';
+import type { IModelLayoutOption, 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';
 import type { ITooltipHandler, IToolTipLineActual, TooltipActiveType } from '../../typings/tooltip';
-import type { Datum, IShowTooltipOption } from '../../typings';
+import type { Datum, ILayoutType, IShowTooltipOption } from '../../typings';
 import type { ITooltip, ITooltipActiveTypeAsKeys, ITooltipSpec, ITooltipTheme, TooltipHandlerParams, TotalMouseEventData } from './interface';
 import { TooltipResult } from './interface/common';
 import { DimensionTooltipProcessor } from './processor/dimension-tooltip';
@@ -16,10 +16,11 @@ export type TooltipActualTitleContent = {
     content?: IToolTipLineActual[];
 };
 export declare class Tooltip extends BaseComponent<any> implements ITooltip {
+    protected layoutZIndex: number;
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
     name: string;
-    layoutType: ILayoutItem['layoutType'];
+    layoutType: ILayoutType;
     protected _spec: ITooltipSpec;
     static createComponent(spec: any, options: IComponentOption): Tooltip | Tooltip[];
     tooltipHandler?: ITooltipHandler;

package/types/constant/layout.d.ts

@@ -1,2 +1,3 @@
 export declare const USER_LAYOUT_RECT_LEVEL = 9;
 export declare const DEFAULT_LAYOUT_RECT_LEVEL = 0;
+export declare const DEFAULT_LAYOUT_RECT_LEVEL_MIN = -1;

package/types/core/factory.d.ts

@@ -26,7 +26,7 @@ export declare class Factory {
     };
     static registerChart(key: string, chart: IChartConstructor): void;
     static registerSeries(key: string, series: ISeriesConstructor): void;
-    static registerComponent(key: string, cmp: IComponentConstructor): void;
+    static registerComponent(key: string, cmp: IComponentConstructor, alwaysCheck?: boolean): void;
     static registerMark(key: string, mark: MarkConstructor): void;
     static registerRegion(key: string, region: IRegionConstructor): void;
     static registerTransform(key: string, transform: Transform): void;
@@ -37,7 +37,10 @@ export declare class Factory {
     static createRegion(regionType: string, spec: any, options: IModelOption): IRegion | null;
     static createSeries(seriesType: string, spec: any, options: ISeriesOption): import("../series/interface").ISeries;
     static createMark(markType: string, name: string, options: IMarkOption): import("../mark/interface").IMark;
-    static getComponents(): IComponentConstructor[];
+    static getComponents(): {
+        cmp: IComponentConstructor;
+        alwaysCheck?: boolean;
+    }[];
     static getComponentInKey(name: string): IComponentConstructor;
     static getLayout(): ILayoutConstructor[];
     static getLayoutInKey(name: string): ILayoutConstructor;

package/types/core/vchart.d.ts

@@ -62,6 +62,7 @@ export declare class VChart implements IVChart {
     private _currentChartLevelTheme;
     private _onError?;
     private _context;
+    private _isReleased;
     constructor(spec: ISpec, options: IInitOption);
     private _setSpec;
     private _initChart;

package/types/event/events/base.d.ts

@@ -0,0 +1,16 @@
+import type { ValueOf } from '@visactor/vgrammar-core';
+import type { EventHandler, EventParamsDefinition, EventType, IComposedEvent, IEventDispatcher } from '../interface';
+import type { Maybe, RenderMode } from '../../typings';
+import type { IChart } from '../../chart/interface';
+export declare abstract class ComposedEvent implements IComposedEvent {
+    protected _eventMap: Map<string, EventHandler<ValueOf<EventParamsDefinition>>>;
+    protected _eventDispatcher: IEventDispatcher;
+    protected _mode: RenderMode;
+    protected _chart: Maybe<IChart>;
+    constructor(eventDispatcher: IEventDispatcher, mode: RenderMode);
+    abstract register<Evt extends EventType>(eType: string, handler: EventHandler<EventParamsDefinition[Evt]>): void;
+    abstract unregister(): void;
+    abstract dispatch(v: unknown, opt: unknown): unknown;
+    protected _registerEvent<Evt extends EventType>(eType: Evt, handler: EventHandler<EventParamsDefinition[Evt]>): IEventDispatcher;
+    protected _unregisterEvent<Evt extends EventType>(eType: Evt, handler?: EventHandler<EventParamsDefinition[Evt]>): IEventDispatcher;
+}

package/types/event/events/dimension/util/cartesian.d.ts

@@ -1,8 +1,8 @@
 import type { IChart } from '../../../../chart/interface';
-import type { ILayoutPoint } from '../../../../model/interface';
 import type { IDimensionInfo } from '../interface';
 import type { CartesianAxis } from '../../../../component/axis/cartesian';
 import type { ICartesianSeries } from '../../../../series/interface';
+import type { ILayoutPoint } from '../../../../typings/layout';
 export declare const getCartesianDimensionInfo: (chart: IChart | undefined, pos: ILayoutPoint) => IDimensionInfo[] | null;
 export declare const getDimensionInfoByPosition: (axis: CartesianAxis, posValue: number, posKey: 'x' | 'y', getDimensionField: (series: ICartesianSeries) => string | string[]) => IDimensionInfo | null;
 export declare const getDimensionInfoByValue: (axis: CartesianAxis, value: any, getDimensionField?: (series: ICartesianSeries) => string | string[]) => IDimensionInfo | null;

package/types/event/events/dimension/util/common.d.ts

@@ -1,8 +1,7 @@
-import type { ILayoutPoint } from '../../../../model/interface';
 import type { IChart } from '../../../../chart/interface';
 import type { IDimensionData, IDimensionInfo } from '../interface';
 import type { AxisComponent } from '../../../../component/axis/base-axis';
-import type { CoordinateType } from '../../../../typings';
+import type { CoordinateType, ILayoutPoint } from '../../../../typings';
 export declare const isInRegionBound: (chart: IChart, axis: AxisComponent, pos: ILayoutPoint) => boolean;
 export declare const isSameDimensionInfo: (a?: IDimensionInfo, b?: IDimensionInfo) => boolean;
 export declare const getDimensionData: (value: any, axis: AxisComponent, coordinate: CoordinateType, getDimensionField: (series: any) => string | string[]) => IDimensionData[];

package/types/event/events/dimension/util/polar.d.ts

@@ -1,4 +1,4 @@
 import type { IChart } from '../../../../chart/interface';
-import type { ILayoutPoint } from '../../../../model/interface';
 import type { IDimensionInfo } from '../interface';
+import type { ILayoutPoint } from '../../../../typings/layout';
 export declare const getPolarDimensionInfo: (chart: IChart | undefined, pos: ILayoutPoint) => IDimensionInfo[] | null;

package/types/event/interface.d.ts

@@ -1,4 +1,3 @@
-import type { ILayoutItem } from './../model/interface';
 import type { IGraphic } from '@visactor/vrender-core';
 import type { IElement } from '@visactor/vgrammar-core';
 import type { IChart } from '../chart/interface';
@@ -10,6 +9,7 @@ import type { Datum, IPoint, StringOrNumber } from '../typings';
 import type { ChartEvent, Event_Bubble_Level, Event_Source_Type, VGRAMMAR_HOOK_EVENT } from '../constant';
 import type { SeriesType } from '../series/interface';
 import type { TooltipEventParams } from '../component/tooltip/interface/event';
+import type { ILayoutItem } from '../layout/interface';
 export type EventType = 'pointerdown' | 'pointerup' | 'pointerupoutside' | 'pointertap' | 'pointerover' | 'pointermove' | 'pointerenter' | 'pointerleave' | 'pointerout' | 'mousedown' | 'mouseup' | 'mouseupoutside' | 'rightdown' | 'rightup' | 'rightupoutside' | 'click' | 'dblclick' | 'mousemove' | 'mouseover' | 'mouseout' | 'mouseenter' | 'mouseleave' | 'wheel' | 'touchstart' | 'touchend' | 'touchendoutside' | 'touchmove' | 'touchcancel' | 'tap' | 'dragstart' | 'drag' | 'dragenter' | 'dragleave' | 'dragover' | 'dragend' | 'drop' | 'pan' | 'panstart' | 'panend' | 'press' | 'pressup' | 'pressend' | 'pinch' | 'pinchstart' | 'pinchend' | 'swipe' | keyof typeof ChartEvent | keyof typeof VGRAMMAR_HOOK_EVENT | string;
 export type EventBubbleLevel = keyof typeof Event_Bubble_Level;
 export type ComponentType = 'axis' | 'dataZoom' | 'indicator' | 'legend' | 'mapLabel' | 'markLine' | 'tooltip' | 'title' | 'label';

package/types/interaction/zoom/zoomable.d.ts

@@ -52,6 +52,7 @@ export declare class Zoomable implements IZoomable {
     initZoomable(evt: IEvent, mode?: RenderMode): void;
     private _getTriggerEvent;
     private _zoomEventDispatch;
+    private _getRegionOrSeriesLayout;
     private _bindZoomEventAsRegion;
     initZoomEventOfSeries(s: ISeries, callback?: (params: {
         zoomDelta: number;

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

@@ -1,10 +1,8 @@
 import type { utilFunctionCtx } from '../typings/params';
 import type { IChart } from '../chart/interface/chart';
 import type { IBoundsLike } from '@visactor/vutils';
-import type { ILayoutItem } from '../model/interface';
-import type { IBaseLayout } from './interface';
+import type { IBaseLayout, ILayoutItem } from './interface';
 import type { IPadding, IRect } from '../typings/space';
-import type { IRegion } from '../region/interface';
 export declare class Layout implements IBaseLayout {
     static type: string;
     leftCurrent: number;
@@ -18,9 +16,9 @@ export declare class Layout implements IBaseLayout {
     layoutItems(_chart: IChart, items: ILayoutItem[], chartLayoutRect: IRect, chartViewBox: IBoundsLike): void;
     protected layoutNormalItems(normalItems: ILayoutItem[]): void;
     protected layoutNormalInlineItems(normalItems: ILayoutItem[]): void;
-    protected layoutRegionItems(regionItems: IRegion[], regionRelativeItems: ILayoutItem[]): void;
+    protected layoutRegionItems(regionItems: ILayoutItem[], regionRelativeItems: ILayoutItem[]): void;
     protected layoutAbsoluteItems(absoluteItems: ILayoutItem[]): void;
-    filterRegionsWithID(regions: IRegion[], id: number): ILayoutItem;
+    filterRegionsWithID(items: ILayoutItem[], id: number): ILayoutItem;
     getItemComputeLayoutRect(item: ILayoutItem): {
         width: number;
         height: number;

package/types/layout/grid-layout/grid-layout.d.ts

@@ -1,8 +1,7 @@
 import type { utilFunctionCtx } from '../../typings/params';
 import type { IChart } from '../../chart/interface/chart';
 import type { IBoundsLike } from '@visactor/vutils';
-import type { ILayoutItem } from '../../model/interface';
-import type { IBaseLayout, IGridLayoutSpec, ElementSpec } from '../interface';
+import type { IBaseLayout, IGridLayoutSpec, ElementSpec, ILayoutItem } from '../interface';
 import type { IRect } from '../../typings/space';
 type GridSize = {
     value: number;

package/types/layout/interface.d.ts

@@ -1,12 +1,13 @@
-import type { utilFunctionCtx } from '../typings/params';
-import type { IRect } from '../typings/space';
-import type { ILayoutItem } from '../model/interface';
 import type { IBoundsLike } from '@visactor/vutils';
-import type { IChart } from '../chart/interface';
+import type { StringOrNumber } from '../typings/common';
+import type { IOrientType, IRect } from '../typings/space';
+import type { IPoint } from '../typings/coordinate';
+import type { ILayoutNumber, ILayoutPaddingSpec, ILayoutPoint, ILayoutRect, ILayoutType } from '../typings/layout';
+import type { ILayoutModel } from '../model/interface';
 export interface IBaseLayout {
     layoutItems: LayoutCallBack;
 }
-export type LayoutCallBack = (chart: IChart, item: ILayoutItem[], chartLayoutRect: IRect, chartViewBox: IBoundsLike) => void;
+export type LayoutCallBack = (chart: any, item: ILayoutItem[], chartLayoutRect: IRect, chartViewBox: IBoundsLike) => void;
 export interface ILayoutSpecBase {
     type: string;
 }
@@ -41,5 +42,72 @@ export interface IBaseLayoutSpec extends ILayoutSpecBase {
 export type ILayoutSpec = IBaseLayoutSpec | IGridLayoutSpec;
 export interface ILayoutConstructor {
     type: string;
-    new (spec: ILayoutSpec | any, ctx?: utilFunctionCtx): IBaseLayout;
+    new (spec: ILayoutSpec | any, ctx?: any): IBaseLayout;
+}
+export interface ILayoutItem {
+    readonly type: string;
+    directionStr?: 'l2r' | 'r2l' | 't2b' | 'b2t';
+    layoutClip: boolean;
+    layoutType: ILayoutType;
+    layoutBindRegionID: number | number[];
+    layoutOrient: IOrientType;
+    autoIndent: boolean;
+    layoutPaddingLeft: number;
+    layoutPaddingTop: number;
+    layoutPaddingRight: number;
+    layoutPaddingBottom: number;
+    layoutOffsetX: number;
+    layoutOffsetY: number;
+    layoutLevel: number;
+    chartLayoutRect: ILayoutRect;
+    readonly layoutRectLevelMap: ILayoutRect;
+    minWidth: number;
+    maxWidth: number;
+    minHeight: number;
+    maxHeight: number;
+    readonly model: ILayoutModel;
+    getModelId: () => StringOrNumber;
+    getModelVisible: () => boolean;
+    getSpec?: () => any;
+    setAttrFromSpec: (spec: ILayoutItemSpec, chartViewRect: ILayoutRect) => void;
+    setRectInSpec: (rect: ILayoutRect) => ILayoutRect;
+    getLayoutStartPoint: () => ILayoutPoint;
+    getLayoutRect: () => ILayoutRect;
+    getLayout: () => IRect;
+    getLastComputeOutBounds: () => IBoundsLike;
+    onLayoutStart: (layoutRect: IRect, viewRect: ILayoutRect, ctx: any) => void;
+    onLayoutEnd: (option: any) => void;
+    setLayoutRect: (rect: Partial<ILayoutRect>, levelMap?: Partial<ILayoutRect>) => void;
+    computeBoundsInRect: (rect: ILayoutRect) => ILayoutRect;
+    setLayoutStartPosition: (pos: Partial<IPoint>) => void;
+    absoluteLayoutInRect: (rect: IRect) => void;
+}
+export interface ILayoutItemSpec {
+    layoutType?: ILayoutType;
+    layoutLevel?: number;
+    orient?: IOrientType;
+    padding?: ILayoutPaddingSpec;
+    noOuterPadding?: boolean;
+    width?: ILayoutNumber;
+    maxWidth?: ILayoutNumber;
+    minWidth?: ILayoutNumber;
+    height?: ILayoutNumber;
+    maxHeight?: ILayoutNumber;
+    minHeight?: ILayoutNumber;
+    offsetX?: ILayoutNumber;
+    offsetY?: ILayoutNumber;
+    zIndex?: number;
+    clip?: boolean;
+    left?: ILayoutNumber;
+    right?: ILayoutNumber;
+    top?: ILayoutNumber;
+    bottom?: ILayoutNumber;
+    center?: boolean;
+}
+export interface ILayoutItemInitOption {
+    layoutType: ILayoutType;
+    layoutLevel: number;
+    layoutOrient?: IOrientType;
+    transformLayoutRect?: (rect: ILayoutRect) => ILayoutRect;
+    transformLayoutPosition?: (pos: Partial<IPoint>) => Partial<IPoint>;
 }

package/types/layout/layout-item.d.ts

@@ -0,0 +1,71 @@
+import type { ILayoutModel } from './../model/interface';
+import type { IRect, IPoint } from '../typings';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { ILayoutItem, ILayoutItemInitOption, ILayoutItemSpec } from './interface';
+import type { IChartLayoutOption } from '../chart/interface/common';
+import type { ILayoutPoint, ILayoutRect } from '../typings/layout';
+export declare class LayoutItem implements ILayoutItem {
+    protected _spec: ILayoutItemSpec;
+    getSpec(): ILayoutItemSpec;
+    layoutClip: boolean;
+    autoIndent: boolean;
+    private _layoutStartPoint;
+    getLayoutStartPoint(): ILayoutPoint;
+    private _layoutRect;
+    protected _layoutRectLevelMap: ILayoutRect;
+    get layoutRectLevelMap(): ILayoutRect;
+    protected _minWidth: number;
+    get minWidth(): number;
+    set minWidth(v: number);
+    protected _maxWidth: number;
+    get maxWidth(): number;
+    set maxWidth(v: number);
+    protected _minHeight: number;
+    get minHeight(): number;
+    set minHeight(v: number);
+    protected _maxHeight: number;
+    get maxHeight(): number;
+    set maxHeight(v: number);
+    protected _lastComputeRect: ILayoutRect;
+    protected _lastComputeOutBounds: IBoundsLike;
+    getLastComputeOutBounds(): IBoundsLike;
+    getLayoutRect: () => ILayoutRect;
+    layoutType: ILayoutItem['layoutType'];
+    layoutBindRegionID: ILayoutItem['layoutBindRegionID'];
+    _layoutOrient: ILayoutItem['layoutOrient'];
+    get layoutOrient(): ILayoutItem['layoutOrient'];
+    set layoutOrient(v: ILayoutItem['layoutOrient']);
+    layoutPaddingLeft: ILayoutItem['layoutPaddingLeft'];
+    layoutPaddingTop: ILayoutItem['layoutPaddingTop'];
+    layoutPaddingRight: ILayoutItem['layoutPaddingRight'];
+    layoutPaddingBottom: ILayoutItem['layoutPaddingBottom'];
+    layoutOffsetX: ILayoutItem['layoutOffsetX'];
+    layoutOffsetY: ILayoutItem['layoutOffsetY'];
+    layoutLevel: ILayoutItem['layoutLevel'];
+    chartLayoutRect: ILayoutRect;
+    protected _model: ILayoutModel;
+    get model(): ILayoutModel;
+    get type(): string;
+    protected _option: ILayoutItemInitOption;
+    constructor(model: ILayoutModel, option: ILayoutItemInitOption);
+    private _setLayoutAttributeFromSpec;
+    setAttrFromSpec(spec: ILayoutItemSpec, chartViewRect: ILayoutRect): void;
+    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect, ctx: any): void;
+    onLayoutEnd(option: IChartLayoutOption): void;
+    private _getAbsoluteSpecValue;
+    absoluteLayoutInRect(layoutRect: IRect): void;
+    setLayoutStartPosition(pos: Partial<IPoint>): void;
+    setLayoutRect({ width, height }: Partial<ILayoutRect>, levelMap?: Partial<ILayoutRect>): void;
+    getLayout(): IRect;
+    mergeLayoutRect({ width, height }: ILayoutRect): ILayoutRect;
+    getOrientPosAttribute(): "x" | "y";
+    getOrientSizeAttribute(): "width" | "height";
+    protected changeBoundsBySetting(bounds: IBoundsLike): IBoundsLike;
+    setRectInSpec(rect: ILayoutRect): {
+        width: number;
+        height: number;
+    };
+    computeBoundsInRect(rect: ILayoutRect): ILayoutRect;
+    getModelId(): number;
+    getModelVisible(): boolean;
+}

package/types/layout/layout3d/index.d.ts

@@ -1,9 +1,7 @@
 import type { IChart } from '../../chart/interface/chart';
 import type { IBoundsLike } from '@visactor/vutils';
-import type { ILayoutItem } from '../../model/interface';
 import type { IRect } from '../../typings/space';
-import type { IRegion } from '../../region/interface';
-import type { IBaseLayout } from '../interface';
+import type { IBaseLayout, ILayoutItem } from '../interface';
 import { Layout } from '../base-layout';
 interface IOffset {
     offsetLeft: number;
@@ -15,7 +13,7 @@ export declare class Layout3d extends Layout implements IBaseLayout {
     static type: string;
     layoutItems(_chart: IChart, items: ILayoutItem[], chartLayoutRect: IRect, chartViewBox: IBoundsLike): void;
     protected layoutZAxisItems(zItems: ILayoutItem[], zRect: IRect): void;
-    protected layoutRegionItems(regionItems: IRegion[], regionRelativeItems: ILayoutItem[], extraOffset?: IOffset): void;
+    protected layoutRegionItems(regionItems: ILayoutItem[], regionRelativeItems: ILayoutItem[], extraOffset?: IOffset): void;
     getItemComputeLayoutRect(item: ILayoutItem, extraOffset?: IOffset): {
         width: number;
         height: number;

package/types/layout/util.d.ts

@@ -1,5 +1,5 @@
-import type { ILayoutItem } from '../model/interface';
 import type { Layout } from './base-layout';
+import type { ILayoutItem } from './interface';
 export declare function layoutLeftInlineItems(items: ILayoutItem[], layout: Layout, limitHeight: number): void;
 export declare function layoutRightInlineItems(items: ILayoutItem[], layout: Layout, limitHeight: number): void;
 export declare function layoutTopInlineItems(items: ILayoutItem[], layout: Layout, limitWidth: number): void;

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

@@ -25,12 +25,12 @@ export declare class BaseMark<T extends ICommonSpec> extends CompilableMark impl
     protected _filterAttribute<U extends keyof T>(attr: U, style: MarkInputStyle<T[U]>, state: StateValueType, level: number, isUserLevel: boolean, stateStyle?: IMarkStateStyle<T>): StyleConvert<T[U]>;
     setReferer<U extends keyof T>(mark: IMarkRaw<T>, styleKey?: U, state?: StateValueType, stateStyle?: IMarkStateStyle<T>): void;
     setPostProcess<U extends keyof T>(key: U, postProcessFunc: any, state?: StateValueType): void;
-    getAttribute<U extends keyof T>(key: U, datum: Datum, state?: StateValueType, opt?: IAttributeOpt): unknown;
+    getAttribute<U extends keyof T>(key: U, datum: Datum, state?: StateValueType, opt?: IAttributeOpt): any;
     setAttribute<U extends keyof T>(attr: U, style: MarkInputStyle<T[U]>, state?: StateValueType, level?: number, stateStyle?: IMarkStateStyle<T>): void;
     protected _getDefaultStyle(): IMarkStyle<T>;
     protected _styleConvert<U extends keyof T>(style?: MarkInputStyle<T[U]>): StyleConvert<T[U]> | undefined;
-    protected _computeAttribute<U extends keyof T>(key: U, state: StateValueType): (datum: Datum, opt: IAttributeOpt) => unknown;
-    protected _computeStateAttribute<U extends keyof T>(stateStyle: any, key: U, state: StateValueType): (datum: Datum, opt: IAttributeOpt) => any;
+    protected _computeAttribute<U extends keyof T>(key: U, datum: Datum, state: StateValueType, opt: IAttributeOpt): any;
+    protected _computeStateAttribute<U extends keyof T>(stateStyle: any, key: U, datum: Datum, state: StateValueType, opt: IAttributeOpt): any;
     private _initStyle;
     private _initSpecStyle;
     private _computeGradientAttr;