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

package/types/layout/interface.d.ts

@@ -1,6 +1,6 @@
 import type { IBoundsLike } from '@visactor/vutils';
 import type { StringOrNumber } from '../typings/common';
-import type { IOrientType, IRect } from '../typings/space';
+import type { IOrientType, IPadding, 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';
@@ -46,6 +46,8 @@ export interface ILayoutConstructor {
 }
 export interface ILayoutItem {
     readonly type: string;
+    readonly willLayoutTag: boolean;
+    readonly lastComputeRect: ILayoutRect;
     directionStr?: 'l2r' | 'r2l' | 't2b' | 'b2t';
     layoutClip: boolean;
     layoutType: ILayoutType;
@@ -82,6 +84,8 @@ export interface ILayoutItem {
     computeBoundsInRect: (rect: ILayoutRect) => ILayoutRect;
     setLayoutStartPosition: (pos: Partial<IPoint>) => void;
     absoluteLayoutInRect: (rect: IRect) => void;
+    clearWillLayoutTag: () => void;
+    setWillLayoutTag: () => void;
 }
 export interface ILayoutItemSpec {
     layoutType?: ILayoutType;
@@ -112,4 +116,5 @@ export interface ILayoutItemInitOption {
     layoutOrient?: IOrientType;
     transformLayoutRect?: (rect: ILayoutRect) => ILayoutRect;
     transformLayoutPosition?: (pos: Partial<IPoint>) => Partial<IPoint>;
+    transformLayoutPadding?: (padding: IPadding) => IPadding;
 }

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

@@ -26,6 +26,7 @@ export declare class LayoutItem implements ILayoutItem {
     get maxHeight(): number;
     set maxHeight(v: number);
     protected _lastComputeRect: ILayoutRect;
+    get lastComputeRect(): ILayoutRect;
     protected _lastComputeOutBounds: IBoundsLike;
     getLastComputeOutBounds(): IBoundsLike;
     getLayoutRect: () => ILayoutRect;
@@ -47,6 +48,8 @@ export declare class LayoutItem implements ILayoutItem {
     get model(): ILayoutModel;
     get type(): string;
     protected _option: ILayoutItemInitOption;
+    protected _willLayoutTag: boolean;
+    get willLayoutTag(): boolean;
     constructor(model: ILayoutModel, option: ILayoutItemInitOption);
     private _setLayoutAttributeFromSpec;
     setAttrFromSpec(spec: ILayoutItemSpec, chartViewRect: ILayoutRect): void;
@@ -68,4 +71,6 @@ export declare class LayoutItem implements ILayoutItem {
     computeBoundsInRect(rect: ILayoutRect): ILayoutRect;
     getModelId(): number;
     getModelVisible(): boolean;
+    setWillLayoutTag(): void;
+    clearWillLayoutTag(): void;
 }

package/types/layout/util.d.ts

@@ -1,6 +1,19 @@
 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;
-export declare function layoutBottomInlineItems(items: ILayoutItem[], layout: Layout, limitWidth: number): void;
+import type { ILayoutRect } from '../typings';
+export type IRecompute = {
+    recomputeWidth: boolean;
+    recomputeHeight: boolean;
+};
+export declare function layoutLeftInlineItems(items: ILayoutItem[], layout: Layout, limitHeight: number, recompute: IRecompute): void;
+export declare function layoutRightInlineItems(items: ILayoutItem[], layout: Layout, limitHeight: number, recompute: IRecompute): void;
+export declare function layoutTopInlineItems(items: ILayoutItem[], layout: Layout, limitWidth: number, recompute: IRecompute): void;
+export declare function layoutBottomInlineItems(items: ILayoutItem[], layout: Layout, limitWidth: number, recompute: IRecompute): void;
+export declare function getItemLayoutWithTag(item: ILayoutItem, layout: Layout, recompute: IRecompute, setRectToItem?: boolean): {
+    layoutRect: import("@visactor/vutils").IBoundsLike | {
+        width: number;
+        height: number;
+    };
+    rect: ILayoutRect;
+    layoutTag: boolean;
+};

package/types/mark/arc.d.ts

@@ -3,7 +3,7 @@ import { BaseMark } from './base/base-mark';
 import type { IArcMark, IMarkOption, IMarkRaw, IMarkStyle } from './interface';
 import { MarkTypeEnum } from './interface/type';
 export declare class BaseArcMark<T extends IArcMarkSpec> extends BaseMark<T> implements IMarkRaw<T> {
-    readonly type: MarkTypeEnum;
+    readonly type: string;
     _unCompileChannel: {
         centerOffset: boolean;
         radiusOffset: boolean;

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

@@ -2,9 +2,9 @@ import type { StateValueType } from '../../compile/mark';
 import type { ConvertToMarkStyleSpec, ILineLikeMarkSpec } from '../../typings/visual';
 import type { IPointLike } from '@visactor/vutils';
 import { BaseMark } from './base-mark';
-import type { IMarkGraphic, IMarkStyle } from '../interface';
+import { type IMarkGraphic, type IMarkStyle } from '../interface';
 import type { Datum } from '../../typings/common';
-import type { ILine } from '@visactor/vrender-core';
+import type { IGroup, ILine } from '@visactor/vrender-core';
 import type { IMarkSpec } from '../../typings/spec/common';
 export declare const LINE_SEGMENT_ATTRIBUTES: string[];
 export declare abstract class BaseLineMark<T extends ILineLikeMarkSpec = ILineLikeMarkSpec> extends BaseMark<T> {
@@ -19,4 +19,13 @@ export declare abstract class BaseLineMark<T extends ILineLikeMarkSpec = ILineLi
     _runPointsEncoder(newStyles: Record<string, (datum: Datum) => any>, g: IMarkGraphic, attrs?: any): any;
     _runEncoderOfGraphic(newStyles: Record<string, (datum: Datum) => any>, g: IMarkGraphic, attrs?: any): any;
     protected _getDataByKey(data: Datum[]): import("../interface").GroupedData<Datum>;
+    protected _runProgressiveJoin(): {
+        graphicsByGroup: {
+            [x: string]: IMarkGraphic[];
+        };
+        graphics: IMarkGraphic[];
+        needUpdate: boolean;
+    };
+    protected _setCommonAttributesToTheme(g: IMarkGraphic): void;
+    protected _addProgressiveGraphic(parent: IGroup, g: IMarkGraphic): void;
 }

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

@@ -2,15 +2,14 @@ import { type IModelMarkAttributeContext } from '../../compile/mark/interface';
 import type { Datum, IMarkSpec, ICommonSpec, ValueType, StringOrNumber, Maybe } from '../../typings';
 import type { DataView } from '@visactor/vdataset';
 import { MarkTypeEnum } from '../interface';
-import type { IMarkRaw, IMarkStateStyle, IMarkStyle, IMark, IMarkOption, StyleConvert, MarkInputStyle, GroupedData, IAttrs, IMarkGraphic, MarkType } from '../interface';
-import { MarkStateManager } from '../../compile/mark';
-import type { ICompilableMark, IMarkCompileOption, IMarkConfig, StateValueType } from '../../compile/mark';
+import type { IMarkRaw, IMarkStateStyle, IMarkStyle, IMark, IMarkOption, StyleConvert, MarkInputStyle, GroupedData, IAttrs, IMarkGraphic, ProgressiveContext, IProgressiveTransformResult, MarkType, AnimationStateValues } from '../interface';
+import type { ICompilableMark, IMarkCompileOption, IMarkConfig, IMarkStateManager, StateValueType } from '../../compile/mark/interface';
 import type { ICompilableInitOption } from '../../compile/interface';
-import type { IGroupGraphicAttribute, IGroup } from '@visactor/vrender-core';
+import type { IGroupGraphicAttribute, IGroup, IGraphic } from '@visactor/vrender-core';
 import { GrammarItem } from '../../compile/grammar-item';
 import type { IModel } from '../../model/interface';
 import type { ICompilableData } from '../../compile/data/interface';
-import type { MarkAnimationSpec } from '../../animation/interface';
+import { type MarkAnimationSpec } from '../../animation/interface';
 export type ExChannelCall = (key: string | number | symbol, datum: Datum, states: StateValueType, baseValue: unknown) => unknown;
 export declare class BaseMark<T extends ICommonSpec> extends GrammarItem implements IMarkRaw<T> {
     readonly type: MarkType;
@@ -36,7 +35,7 @@ export declare class BaseMark<T extends ICommonSpec> extends GrammarItem impleme
     getData(): ICompilableData;
     setData(d?: ICompilableData): void;
     stateStyle: IMarkStateStyle<T>;
-    state: MarkStateManager;
+    state: IMarkStateManager;
     protected _unCompileChannel: {
         [key in string]: boolean;
     };
@@ -52,6 +51,7 @@ export declare class BaseMark<T extends ICommonSpec> extends GrammarItem impleme
     protected _stateSort?: (stateA: string, stateB: string) => number;
     protected _product: Maybe<IGroup>;
     getProduct(): IGroup;
+    protected _lastMark?: IMark;
     protected initMarkData(option: ICompilableInitOption): void;
     protected _compileProduct(option?: IMarkCompileOption): void;
     protected _initProduct(group?: IGroup): void;
@@ -109,11 +109,17 @@ export declare class BaseMark<T extends ICommonSpec> extends GrammarItem impleme
     private _computeBorderAttr;
     protected _dataByGroup: GroupedData<Datum>;
     protected _dataByKey: GroupedData<Datum>;
+    protected _prevDataByKey: GroupedData<Datum>;
     protected _graphicMap: Map<string, IMarkGraphic>;
     protected _graphics: IMarkGraphic[];
     protected _keyGetter: (datum: Datum) => string;
     protected _groupKeyGetter: (datum: Datum) => string;
-    private renderContext?;
+    protected renderContext?: {
+        parameters?: any;
+        progressive?: ProgressiveContext;
+        beforeTransformProgressive?: IProgressiveTransformResult;
+    };
+    protected _attrsByGroup?: Record<string, T>;
     protected _getDataByKey(data: Datum[]): GroupedData<Datum>;
     protected _getCommonContext(): {
         markType: MarkTypeEnum;
@@ -122,35 +128,58 @@ export declare class BaseMark<T extends ICommonSpec> extends GrammarItem impleme
         markUserId: StringOrNumber;
         modelUserId: StringOrNumber;
     };
+    prepareMorph(mark: IMark): void;
     reuse(mark: IMark): void;
+    private _parseProgressiveContext;
     getGraphics(): IMarkGraphic[];
-    protected _createGraphic(attrs?: any): IMarkGraphic;
+    protected _createGraphic(attrs?: any): IGraphic;
     protected _runGroupData(data: Datum[]): void;
+    protected createAnimationStateList(type: string, animationConfig: Partial<MarkAnimationSpec>): any;
+    protected tryRunMorphing(graphics: IMarkGraphic[]): boolean;
+    protected _runStateAnimation(graphics: IMarkGraphic[]): void;
     protected _runJoin(data: Datum[]): void;
     _runEncoderOfGraphic(styles: Record<string, (datum: Datum) => any>, g: IMarkGraphic, attrs?: any): any;
     _runGroupEncoder(groupStyles: Record<string, (datum: Datum) => any>): any;
     protected _transformGraphicAttributes(g: IMarkGraphic, attrs: any, groupAttrs?: any): any;
-    protected _separateNormalStyle(normalStyle: Partial<IAttrs<T>>, splitGroupEncoder?: boolean): {
-        updateStyles: Record<string, (datum: Datum) => any>;
-        groupStyles: Record<string, (datum: Datum) => any>;
+    protected _separateNormalStyle(normalStyle: Partial<IAttrs<T>>): {
+        updateStyles: {};
+        groupStyles: {};
     };
-    protected _getEncoderByState: (stateName: string) => Record<string, (datum: Datum) => any>;
+    protected _getEncoderOfStyle: (stateName: string, style: Partial<IAttrs<T>>) => Record<string, (datum: Datum) => any>;
     protected _setGraphicFromMarkConfig: (g: IMarkGraphic) => void;
     protected _setStateOfGraphic: (g: IMarkGraphic) => void;
-    protected _runEncoder(splitGroupEncoder?: boolean): void;
-    protected _runState(): void;
+    protected _addProgressiveGraphic(parent: IGroup, g: IMarkGraphic): void;
+    protected _runEncoder(graphics: IMarkGraphic[], noGroupEncode?: boolean): void;
+    protected _runApplyGraphic(graphics: IMarkGraphic[]): void;
+    protected _updateEncoderByState(): void;
+    protected _runState(graphics: IMarkGraphic[]): void;
     protected _getAttrsFromConfig(attrs?: IGroupGraphicAttribute): IGroupGraphicAttribute;
     protected _updateAttrsOfGroup(): void;
-    protected runBeforeTransform(data: Datum[]): Datum[];
+    protected _runBeforeTransform(data: Datum[]): Datum[];
+    protected _runEncoderTransform(data: Datum[], isProgressive: boolean): Datum[];
     protected _runMainTasks(): void;
     render(): void;
     updateMarkState(key: string): void;
-    protected _cleanExitGraphics(): void;
+    clearExitGraphics(): void;
     isProgressive(): boolean;
     canAnimateAfterProgressive(): boolean;
     isDoingProgressive(): boolean;
     clearProgressive(): void;
     restartProgressive(): void;
-    protected renderBeforeProgressive(): void;
+    private _runBeforeProgressive;
+    protected _runProgressiveJoin(): {
+        graphicsByGroup?: Record<string, IMarkGraphic[]>;
+        graphics?: IMarkGraphic[];
+        needUpdate?: boolean;
+    };
+    protected _createIncrementalGraphics(): void;
+    protected _setCommonAttributesToTheme(g: IMarkGraphic): void;
+    protected _runProgressiveEncoder(graphics: IMarkGraphic[]): void;
+    protected _runProgressiveApplyGraphic(graphics: IMarkGraphic[]): void;
+    protected _runProgressiveStep(): void;
     renderProgressive(): void;
+    updateAnimationState(callback: (graphic: IMarkGraphic) => AnimationStateValues): void;
+    hasAnimationByState(state: keyof MarkAnimationSpec): boolean;
+    hasAnimation(): boolean;
+    runAnimation(): void;
 }

package/types/mark/cell.d.ts

@@ -1,5 +1,5 @@
 import type { ICellMarkSpec } from '../typings';
-import type { ICellMark, IMarkStyle } from './interface';
+import type { ICellMark, IMarkGraphic, IMarkStyle } from './interface';
 import { MarkTypeEnum } from './interface/type';
 import type { IGraphic } from '@visactor/vrender-core';
 import { BaseMark } from './base';
@@ -8,6 +8,6 @@ export declare class CellMark extends BaseMark<ICellMarkSpec> implements ICellMa
     readonly type = MarkTypeEnum.cell;
     protected _getDefaultStyle(): IMarkStyle<ICellMarkSpec>;
     protected _createGraphic(attrs?: any): IGraphic;
-    protected _transformGraphicAttributes(g: IGraphic, attrs: any, groupAttrs?: any): any;
+    protected _transformGraphicAttributes(g: IMarkGraphic, attrs: any, groupAttrs?: any): any;
 }
 export declare const registerCellMark: () => void;

package/types/mark/component.d.ts

@@ -12,6 +12,7 @@ export declare class ComponentMark extends BaseMark<ICommonSpec> implements ICom
     constructor(name: string, option: IMarkOption);
     protected _getDefaultStyle(): IMarkStyle<ICommonSpec>;
     getComponent(): IGraphic<Partial<import("@visactor/vrender-core").IGraphicAttribute>>;
+    clearComponent(): void;
     protected _getAttrsFromConfig(attrs?: IGroupGraphicAttribute): IGroupGraphicAttribute;
     protected _attributesTransform: (attrs: any) => any;
     setAttributeTransform(t: (attrs: any) => any): void;

package/types/mark/glyph.d.ts

@@ -25,5 +25,6 @@ export declare abstract class GlyphMark<T extends ICommonSpec = ICommonSpec, Cfg
     private _onGlyphAttributeUpdate;
     protected _setStateOfGraphic: (g: IMarkGraphic) => void;
     protected _createGraphic(attrs?: IGlyphGraphicAttribute): IGraphic;
+    protected _runProgressiveEncoder(graphics: IMarkGraphic[]): void;
 }
 export declare const registerGlyphMark: () => void;

package/types/mark/group.d.ts

@@ -1,7 +1,7 @@
 import type { Maybe } from '../typings';
 import type { IGroupMarkSpec } from '../typings/visual';
 import { BaseMark } from './base/base-mark';
-import type { IGroupMark, IMark, IMarkGraphic, MarkType } from './interface';
+import type { AnimationStateValues, IGroupMark, IMark, IMarkGraphic, MarkType } from './interface';
 import { MarkTypeEnum } from './interface/type';
 import { type IMarkCompileOption } from '../compile/mark';
 import type { IGroup, IGroupGraphicAttribute } from '@visactor/vrender-core';
@@ -24,6 +24,7 @@ export declare class GroupMark extends BaseMark<IGroupMarkSpec> implements IGrou
     getGraphics(): IMarkGraphic[];
     protected _renderSelf(): void;
     render(): void;
+    updateAnimationState(callback: (g: IMarkGraphic) => AnimationStateValues): void;
     release(): void;
 }
 export declare const registerGroupMark: () => void;

package/types/mark/index.d.ts

@@ -5,19 +5,20 @@ import { RuleMark, registerRuleMark } from './rule';
 import { TextMark, registerTextMark } from './text';
 import { AreaMark, registerAreaMark } from './area';
 import { RectMark, registerRectMark } from './rect';
-import { Rect3dMark, registerRect3dMark } from './rect-3d';
 import { PathMark, registerPathMark } from './path';
-import { ArcMark, registerArcMark } from './arc';
-import { Arc3dMark, registerArc3dMark } from './arc-3d';
+import { ArcMark, BaseArcMark, registerArcMark } from './arc';
 import { ComponentMark, registerComponentMark } from './component';
 import { RippleMark, registerRippleMark } from './ripple';
 import { BaseMark } from './base';
 import { PolygonMark, registerPolygonMark } from './polygon/polygon';
-import { Pyramid3dMark, registerPyramid3dMark } from './polygon/pyramid-3d';
 import { ImageMark, registerImageMark } from './image';
 import { registerMarkFilterTransform } from './transform/filter';
 import { registerMarkMapTransform } from './transform/map';
-export type { IBoxPlotMarkSpec, ILineMarkSpec, ISymbolMarkSpec, IGroupMarkSpec, IRuleMarkSpec, ITextMarkSpec, IAreaMarkSpec, IRect3dMarkSpec, IRectMarkSpec, IPathMarkSpec, IArcMarkSpec, IArc3dMarkSpec, ICommonSpec, IPolygonMarkSpec, IPyramid3dMarkSpec, ILinkPathMarkSpec, IRippleMarkSpec, ICellMarkSpec, ILiquidMarkSpec, ConvertToMarkStyleSpec } from '../typings/visual';
-export { LineMark, SymbolMark, GroupMark, RuleMark, TextMark, AreaMark, Rect3dMark, RectMark, PathMark, Arc3dMark, ArcMark, ComponentMark, PolygonMark, Pyramid3dMark, RippleMark, ImageMark, BaseMark };
-export { registerLineMark, registerSymbolMark, registerGroupMark, registerRuleMark, registerTextMark, registerAreaMark, registerRectMark, registerRect3dMark, registerPathMark, registerArcMark, registerArc3dMark, registerPolygonMark, registerPyramid3dMark, registerRippleMark, registerImageMark, registerComponentMark, registerMarkMapTransform, registerMarkFilterTransform };
+import { BasePolygonMark } from './polygon/base-polygon';
+import { MarkTypeEnum } from './interface/type';
+export type { IBoxPlotMarkSpec, ILineMarkSpec, ISymbolMarkSpec, IGroupMarkSpec, IRuleMarkSpec, ITextMarkSpec, IAreaMarkSpec, IRectMarkSpec, IPathMarkSpec, IArcMarkSpec, ICommonSpec, IPolygonMarkSpec, ILinkPathMarkSpec, IRippleMarkSpec, ICellMarkSpec, ILiquidMarkSpec, ConvertToMarkStyleSpec } from '../typings/visual';
+export type { IMarkRaw, IMark, IMarkStyle } from './interface/common';
+export type { ITextMark, ILabelMark, IRectMark, IRuleMark, IImageMark, IGroupMark } from './interface/mark';
+export { MarkTypeEnum, LineMark, SymbolMark, GroupMark, RuleMark, TextMark, AreaMark, RectMark, PathMark, BaseArcMark, ArcMark, ComponentMark, BasePolygonMark, PolygonMark, RippleMark, ImageMark, BaseMark };
+export { registerLineMark, registerSymbolMark, registerGroupMark, registerRuleMark, registerTextMark, registerAreaMark, registerRectMark, registerPathMark, registerArcMark, registerPolygonMark, registerRippleMark, registerImageMark, registerComponentMark, registerMarkMapTransform, registerMarkFilterTransform };
 export declare const registerAllMarks: () => void;

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

@@ -7,6 +7,7 @@ import type { ICompilableMark, ICompilableMarkOption, IMarkConfig, IModelMarkAtt
 import type { Datum, StringOrNumber } from '../../typings';
 import type { IGraphic } from '@visactor/vrender-core';
 import type { IGroupMark } from './mark';
+import type { IAnimationConfig } from '../../animation/interface';
 export interface VisualScaleType {
     scale: IBaseScale;
     field: StringOrNumber;
@@ -34,6 +35,7 @@ export type IMarkStyle<T extends ICommonSpec> = {
     [key in keyof T]: MarkInputStyle<T[key]>;
 };
 export type DiffStateValues = 'update' | 'enter' | 'exit';
+export type AnimationStateValues = 'appear' | 'enter' | 'update' | 'exit' | 'disappear';
 export interface IGraphicContext {
     markType: MarkTypeEnum;
     markId: number;
@@ -41,15 +43,29 @@ export interface IGraphicContext {
     markUserId?: number | string;
     modelUserId?: number | string;
     diffState?: DiffStateValues;
+    reusing?: boolean;
+    lastAttrs?: Record<string, any>;
+    indexKey?: string;
+    diffAttrs?: Record<string, any>;
+    finalAttrs?: Record<string, any>;
+    fieldX?: string[];
+    originalFieldX?: string[];
+    fieldY?: string[];
+    originalFieldY?: string[];
+    animationState?: AnimationStateValues;
     data?: Datum[];
     uniqueKey?: string;
     key?: string;
     groupKey?: string;
     states?: string[];
+    graphicCount?: number;
+    graphicIndex?: number;
+    stateAnimateConfig?: IAnimationConfig | IAnimationConfig[];
 }
 export interface IMarkGraphic extends IGraphic {
     runtimeStateCache?: Record<string, any>;
     context?: IGraphicContext;
+    isExiting?: boolean;
 }
 export interface IMarkRaw<T extends ICommonSpec> extends ICompilableMark {
     readonly stateStyle: IMarkStateStyle<T>;
@@ -67,12 +83,16 @@ export interface IMarkRaw<T extends ICommonSpec> extends ICompilableMark {
     render: () => void;
     getGraphics: () => IMarkGraphic[];
     reuse: (mark: IMark) => void;
+    prepareMorph: (mark: IMark) => void;
+    clearExitGraphics: () => void;
     isProgressive: () => boolean;
     isDoingProgressive: () => boolean;
     clearProgressive: () => void;
     restartProgressive: () => void;
     renderProgressive: () => void;
     canAnimateAfterProgressive: () => boolean;
+    updateAnimationState: (callback: (graphic: IMarkGraphic) => AnimationStateValues) => void;
+    runAnimation: () => void;
 }
 export type IMark = IMarkRaw<ICommonSpec>;
 export interface ICompileMarkConfig extends IMarkConfig {

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

@@ -1,11 +1,12 @@
 import type { IGraphic } from '@visactor/vrender-core';
 import type { IMarkSpec } from '../../typings';
-import type { IArc3dMarkSpec, IArcMarkSpec, IAreaMarkSpec, IBoxPlotMarkSpec, ICellMarkSpec, ICommonSpec, IComposedTextMarkSpec, IGroupMarkSpec, IImageMarkSpec, ILineMarkSpec, ILinkPathMarkSpec, IPathMarkSpec, IPolygonMarkSpec, IPyramid3dMarkSpec, IRect3dMarkSpec, IRectMarkSpec, IRippleMarkSpec, IRuleMarkSpec, ISymbolMarkSpec } from '../../typings/visual';
+import type { IArcMarkSpec, IAreaMarkSpec, IBoxPlotMarkSpec, ICellMarkSpec, ICommonSpec, IComposedTextMarkSpec, IGroupMarkSpec, IImageMarkSpec, ILineMarkSpec, ILinkPathMarkSpec, IPathMarkSpec, IPolygonMarkSpec, IRectMarkSpec, IRippleMarkSpec, IRuleMarkSpec, ISymbolMarkSpec } from '../../typings/visual';
 import type { IMark, IMarkRaw } from './common';
 import type { MarkType } from './type';
 export interface IComponentMark extends IMarkRaw<ICommonSpec> {
     renderInner: () => void;
     getComponent: () => IGraphic;
+    clearComponent: () => void;
     setAttributeTransform: (t: (attrs: any) => any) => any;
 }
 export interface IGlyphMark<T extends ICommonSpec = ICommonSpec, C = any> extends IMarkRaw<T> {
@@ -32,9 +33,7 @@ export type ITextMark = IMarkRaw<IComposedTextMarkSpec> & {
 export type ITextSpec<T> = IMarkSpec<T> & {
     textType?: 'rich' | 'text';
 };
-export type IArc3dMark = IMarkRaw<IArc3dMarkSpec>;
 export type IPolygonMark = IMarkRaw<IPolygonMarkSpec>;
-export type IPyramid3dMark = IMarkRaw<IPyramid3dMarkSpec>;
 export type IArcMark = IMarkRaw<IArcMarkSpec>;
 export type IAreaMark = IMarkRaw<IAreaMarkSpec>;
 export type IBoxPlotMark = IMarkRaw<IBoxPlotMarkSpec>;
@@ -43,7 +42,6 @@ export type IImageMark = IMarkRaw<IImageMarkSpec>;
 export type ILineMark = IMarkRaw<ILineMarkSpec>;
 export type ILinkPathMark = IMarkRaw<ILinkPathMarkSpec>;
 export type IPathMark = IMarkRaw<IPathMarkSpec>;
-export type IRect3dMark = IMarkRaw<IRect3dMarkSpec>;
 export type IRectMark = IMarkRaw<IRectMarkSpec>;
 export type IRippleMark = IMarkRaw<IRippleMarkSpec>;
 export type IRuleMark = IMarkRaw<IRuleMarkSpec>;

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

@@ -6,14 +6,11 @@ export declare const enum MarkTypeEnum {
     line = "line",
     text = "text",
     rect = "rect",
-    rect3d = "rect3d",
     image = "image",
     path = "path",
     area = "area",
     arc = "arc",
-    arc3d = "arc3d",
     polygon = "polygon",
-    pyramid3d = "pyramid3d",
     boxPlot = "boxPlot",
     linkPath = "linkPath",
     cell = "cell",

package/types/mark/rule.d.ts

@@ -1,13 +1,13 @@
 import type { IRuleMarkSpec } from '../typings/visual';
 import { BaseMark } from './base/base-mark';
-import type { IMarkStyle, IRuleMark } from './interface';
+import type { IMarkGraphic, IMarkStyle, IRuleMark } from './interface';
 import { MarkTypeEnum } from './interface/type';
 import type { IGraphic, ILineGraphicAttribute } from '@visactor/vrender-core';
 export declare class RuleMark extends BaseMark<IRuleMarkSpec> implements IRuleMark {
     static readonly type = MarkTypeEnum.rule;
     readonly type = MarkTypeEnum.rule;
     protected _getDefaultStyle(): IMarkStyle<IRuleMarkSpec>;
-    protected _transformGraphicAttributes(g: IGraphic, attrs: any, groupAttrs?: any): any;
+    protected _transformGraphicAttributes(g: IMarkGraphic, attrs: any, groupAttrs?: any): any;
     protected _createGraphic(attrs?: ILineGraphicAttribute): IGraphic;
 }
 export declare const registerRuleMark: () => void;

package/types/mark/symbol.d.ts

@@ -1,12 +1,11 @@
 import type { ISymbolMarkSpec } from '../typings/visual';
 import { BaseMark } from './base/base-mark';
-import type { IMarkStyle, ISymbolMark } from './interface';
+import type { IMarkGraphic, IMarkStyle, ISymbolMark } from './interface';
 import { MarkTypeEnum } from './interface/type';
-import type { IGraphic } from '@visactor/vrender-core';
 export declare class SymbolMark extends BaseMark<ISymbolMarkSpec> implements ISymbolMark {
     static readonly type = MarkTypeEnum.symbol;
     readonly type = MarkTypeEnum.symbol;
     protected _getDefaultStyle(): IMarkStyle<ISymbolMarkSpec>;
-    protected _transformGraphicAttributes(g: IGraphic, attrs: any, groupAttrs?: any): any;
+    protected _transformGraphicAttributes(g: IMarkGraphic, attrs: any, groupAttrs?: any): any;
 }
 export declare const registerSymbolMark: () => void;

package/types/mark/text.d.ts

@@ -1,6 +1,6 @@
 import type { IComposedTextMarkSpec } from '../typings/visual';
 import { BaseMark } from './base/base-mark';
-import type { IMarkOption, IMarkStyle } from './interface';
+import type { IMarkGraphic, IMarkOption, IMarkStyle } from './interface';
 import { MarkTypeEnum } from './interface';
 import type { ITextMark, ITextSpec } from './interface/mark';
 import type { IGraphic, IRichTextGraphicAttribute, ITextGraphicAttribute } from '@visactor/vrender-core';
@@ -12,7 +12,7 @@ export declare class TextMark extends BaseMark<IComposedTextMarkSpec> implements
     constructor(name: string, option: IMarkOption);
     protected _getDefaultStyle(): IMarkStyle<IComposedTextMarkSpec>;
     initStyleWithSpec(spec: ITextSpec<IComposedTextMarkSpec>): void;
-    protected _transformGraphicAttributes(g: IGraphic, attrs: any, groupAttrs?: any): any;
+    protected _transformGraphicAttributes(g: IMarkGraphic, attrs: any, groupAttrs?: any): any;
     protected _createGraphic(attrs?: ITextGraphicAttribute | IRichTextGraphicAttribute): IGraphic;
 }
 export declare const registerTextMark: () => void;

package/types/mark/transform/symbol-overlap.d.ts

@@ -4,7 +4,6 @@ export declare const transform: (options: {
     direction: number;
     delta?: number;
     deltaMul?: number;
-    radius?: boolean;
     hideMode?: number;
     forceUpdate?: boolean;
     forceUpdateStamp?: number;

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

@@ -4,6 +4,5 @@ import type { GroupedData } from '../interface/common';
 export declare const MultiDatumMark: string[];
 export declare function isMultiDatumMark(type: MarkTypeEnum): boolean;
 export declare function curveTypeTransform(type: string, direction: string): string;
-export declare function is3DMark(type: MarkTypeEnum): boolean;
 export declare function groupData<T>(data: T[], groupBy: (datum: Datum, index: number) => string, sort?: (a: T, b: T) => number): GroupedData<T>;
 export declare const runEncoder: (styles: Record<string, (datum: Datum) => any>, datum: Datum, attrs?: any) => any;

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

@@ -32,7 +32,7 @@ export declare abstract class BaseModel<T extends IModelSpec> extends Compilable
     getMarks(): IMark[];
     getMarkNameMap(): Record<string, IMark>;
     getMarkSet(): MarkSet;
-    getChart(): import("../chart/interface").IChart;
+    getChart(): import("..").IChart;
     protected get _theme(): any;
     protected _lastLayoutRect: ILayoutRect;
     constructor(spec: T, option: IModelOption);
@@ -48,6 +48,7 @@ export declare abstract class BaseModel<T extends IModelSpec> extends Compilable
     abstract onRender(ctx: IModelRenderOption): void;
     onDataUpdate(): void;
     beforeRelease(): void;
+    clear(): void;
     release(): void;
     updateSpec(spec: T): {
         change: boolean;
@@ -74,7 +75,7 @@ export declare abstract class BaseModel<T extends IModelSpec> extends Compilable
     compileMarks(group?: IGroup): void;
     protected _createMark<T extends IMark>(markInfo: IModelMarkInfo, option?: Partial<IMarkOption>, config?: ICompileMarkConfig): T;
     protected _getDataIdKey(): string | ((datum: Datum) => string) | undefined;
-    getColorScheme(): import("..").IThemeColorScheme;
+    getColorScheme(): any;
     getSpecInfo(): IModelSpecInfo<any>;
     getSpecIndex(): number;
 }

package/types/model/interface.d.ts

@@ -7,7 +7,6 @@ import type { StringOrNumber } from '../typings/common';
 import type { IGroupMarkSpec, ConvertToMarkStyleSpec, ICommonSpec } from '../typings/visual';
 import type { IRect } from '../typings/space';
 import type { IPoint, CoordinateType } from '../typings/coordinate';
-import type { ITheme } from '../theme/interface';
 import type { StateValueType } from '../typings/spec';
 import type { ICompilable, ICompilableInitOption } from '../compile/interface';
 import type { IGlobalScale } from '../scale/interface';
@@ -21,6 +20,8 @@ import type { ITooltipSpec } from '../component/tooltip/interface';
 import type { TooltipActiveType } from '../typings';
 import type { IVChart } from '../core/interface';
 import type { ICompilableData } from '../compile/data/interface';
+import type { IDimensionData, IDimensionInfo } from '../event/events/dimension/interface';
+import type { IAxis } from '../component/axis';
 export interface IModelInitOption {
 }
 export interface IModelLayoutOption {
@@ -107,7 +108,7 @@ export interface IModelOption extends ICompilableInitOption {
     specKey?: string;
     specPath?: Array<string | number>;
     specInfoPath?: Array<string | number>;
-    getTheme?: () => ITheme;
+    getTheme?: (...keys: string[]) => any;
     getSpecInfo?: () => IChartSpecInfo;
     getChartLayoutRect: () => IRect;
     getChartViewRect: () => ILayoutRect;
@@ -117,6 +118,9 @@ export interface IModelOption extends ICompilableInitOption {
     animation: boolean;
     onError: (...args: any[]) => void;
     disableTriggerEvent?: boolean;
+    getDimensionInfo?: (chart: IChart | undefined, pos: ILayoutPoint, isTooltip?: boolean) => IDimensionInfo[] | null;
+    getDimensionInfoByValue?: (axis: IAxis, value: any) => IDimensionInfo | null;
+    getRectByDimensionData?: (dimensionData: IDimensionData, layoutStartPoint: ILayoutPoint) => any;
 }
 export interface IModelSpecInfo<T extends Record<string, unknown> = any> {
     type: string | ComponentTypeEnum | SeriesTypeEnum;
@@ -128,6 +132,7 @@ export interface IModelSpecInfo<T extends Record<string, unknown> = any> {
     seriesIndexes?: number[];
 }
 export interface IModelConstructor {
+    readonly builtInTheme?: any;
     readonly transformerConstructor: new (option: IBaseModelSpecTransformerOption) => IBaseModelSpecTransformer;
 }
 export type ILayoutModelState = {

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

@@ -1,6 +1,6 @@
 import type { IBoundsLike } from '@visactor/vutils';
 import type { ILayoutItem } from '../layout/interface';
-import type { IOrientType, IPolarOrientType, IRect } from '../typings/space';
+import type { IOrientType, IPadding, IPolarOrientType, IRect } from '../typings/space';
 import { BaseModel } from './base-model';
 import type { IModelSpec } from './interface';
 import type { IPoint } from '../typings/coordinate';
@@ -38,4 +38,5 @@ export declare abstract class LayoutModel<T extends IModelSpec> extends BaseMode
     abstract getBoundsInRect(rect: ILayoutRect, fullRect: ILayoutRect): IBoundsLike;
     protected _transformLayoutRect: (rect: ILayoutRect) => ILayoutRect;
     protected _transformLayoutPosition: (rect: Partial<IPoint>) => Partial<IPoint>;
+    protected _transformLayoutPadding: (padding: IPadding) => IPadding;
 }

package/types/plugin/chart/index.d.ts

@@ -1,3 +1,4 @@
 export * from './media-query';
 export * from './formatter';
 export * from './register';
+export * from './interface';

package/types/plugin/components/tooltip-handler/utils/attribute.d.ts

@@ -1,7 +1,6 @@
 import type { TooltipPanelAttrs, TooltipRichTextAttrs } from '@visactor/vrender-components';
 import type { ITooltipActual, MaybeArray } from '../../../../typings';
 import type { ITooltipAttributes, ITooltipTextStyle } from '../interface';
-import type { ITheme } from '../../../../theme';
 import type { ITooltipSpec, ITooltipTextTheme, ITooltipTheme } from '../../../../component/tooltip';
 interface ITooltipTextInfo {
     width: number;
@@ -9,7 +8,7 @@ interface ITooltipTextInfo {
     text: MaybeArray<number> | MaybeArray<string> | TooltipRichTextAttrs;
 }
 export declare const measureTooltipText: (text: string | TooltipRichTextAttrs, style: ITooltipTextStyle) => ITooltipTextInfo;
-export declare function getTextAttributes(style?: ITooltipTextTheme, globalTheme?: ITheme, defaultAttributes?: Partial<ITooltipTextStyle>): ITooltipTextStyle;
+export declare function getTextAttributes(style?: ITooltipTextTheme, globalFontFamily?: string, defaultAttributes?: Partial<ITooltipTextStyle>): ITooltipTextStyle;
 export declare const getPanelAttributes: (style: ITooltipTheme['panel']) => TooltipPanelAttrs;
-export declare const getTooltipAttributes: (actualTooltip: ITooltipActual, spec: ITooltipSpec, globalTheme: ITheme) => ITooltipAttributes;
+export declare const getTooltipAttributes: (actualTooltip: ITooltipActual, spec: ITooltipSpec, globalFontFamily?: string) => ITooltipAttributes;
 export {};

package/types/plugin/components/tooltip-handler/utils/position.d.ts

@@ -1,18 +1,7 @@
-import type { IDimensionData } from '../../../../event';
-import { type ILayoutPoint } from '../../../../typings';
 import type { IFixedTooltipPositionPattern, IGlobalTooltipPositionPattern, TooltipFixedPosition } from '../../../../typings/tooltip/position';
 export declare const getActualTooltipPositionValue: (position: number | ((event: MouseEvent) => number), event: MouseEvent) => number;
-export type TooltipPositionType = -2 | -1 | 0 | 1 | 2;
+export type TooltipPositionType = -2 | -1.5 | -1 | 0 | 1 | 1.5 | 2;
 export declare const positionType: Record<TooltipFixedPosition, [TooltipPositionType, TooltipPositionType]>;
 export declare const getPositionType: (position: TooltipFixedPosition, dim: 'x' | 'y', defaultCase?: TooltipPositionType) => TooltipPositionType;
-export declare const getCartesianCrosshairRect: (dimensionData: IDimensionData, layoutStartPoint: ILayoutPoint) => {
-    visible: boolean;
-    start: {
-        [x: string]: number;
-    };
-    end: {
-        [x: string]: number;
-    };
-};
 export declare const isGlobalTooltipPositionPattern: (obj: any) => obj is IGlobalTooltipPositionPattern;
 export declare const isFixedTooltipPositionPattern: (obj: any) => obj is IFixedTooltipPositionPattern;