@visactor/vchart-types 1.15.5-alpha.8 → 2.0.0-alpha.1

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

@@ -1,20 +1,42 @@
-import type { IMarkStateStyle, MarkType } from '../../mark/interface';
+import type { IMark, IMarkGraphic, IMarkStateStyle, MarkType } from '../../mark/interface';
 import type { IModel } from '../../model/interface';
-import type { GrammarItemCompileOption, GrammarItemInitOption, IGrammarItem } from '../interface';
+import type { GrammarItemCompileOption, GrammarItemInitOption, IGrammarItem, StateValueMap } 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;
+    useSequentialAnimation?: 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: IMarkGraphic, datum: Datum[], state: IStateInfo) => 'in' | 'out' | 'skip';
+    checkState: (renderNode: IMarkGraphic, datum: Datum[]) => StateValue[];
+    getStateMap: () => StateValueMap;
+    updateState: (newState: Partial<StateValueMap>, noRender?: boolean) => void;
+    release: () => void;
 }
 export interface IMarkData extends ICompilableData {
     setCompiledProductId: (name: string) => any;
@@ -33,48 +55,38 @@ 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;
+    setDataLabelType?: () => string;
 }
 export interface IMarkCompileOption extends GrammarItemCompileOption {
-    group?: string | IGroupMark;
-    ignoreChildren?: boolean;
+    group?: IGroup;
     context?: any;
 }
 export interface IStateInfo {
@@ -83,7 +95,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 +132,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 +149,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,25 @@
-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;
+    release(): void;
 }

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/morph.d.ts

@@ -0,0 +1,3 @@
+import type { IMark } from '../mark/interface';
+import type { IMorphConfig } from '../animation/spec';
+export declare const morph: (prevMarks: IMark[], nextMarks: IMark[], morphConfig?: IMorphConfig) => boolean;

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,14 @@ 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';
+import type { ICompilableData } from './../../compile/data/interface';
 export declare abstract class AxisComponent<T extends ICommonAxisSpec & Record<string, any> = any> extends BaseComponent<T> implements IAxis {
     static specKey: string;
     specKey: string;
@@ -50,9 +52,10 @@ 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 _onTickDataChange: (tickData?: ICompilableData) => void;
     protected _initData(): void;
     protected collectData(depth: number, rawData?: boolean): {
         min: number;
@@ -68,8 +71,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;
@@ -102,5 +106,8 @@ export declare abstract class AxisComponent<T extends ICommonAxisSpec & Record<s
     addTransformToTickData(options: ITransformOptions, execute?: boolean): void;
     dataToPosition(values: any[]): number;
     getDatum(childGraphic?: IGraphic): any;
+    scaleRangeFactor(_?: [number, number], slience?: boolean, clear?: boolean): any;
+    scaleRangeFactorEnd(_?: number, slience?: boolean, clear?: boolean): any;
+    scaleRangeFactorStart(_?: number, slience?: boolean, clear?: boolean): any;
 }
 export declare const registerAxis: () => void;

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

@@ -3,13 +3,14 @@ import type { IEffect, IModelInitOption, IModelSpecInfo } from '../../../model/i
 import type { ICartesianSeries } from '../../../series/interface';
 import type { IRegion } from '../../../region/interface';
 import type { ICartesianAxisCommonSpec, IAxisHelper } from './interface';
-import type { IOrientType, IRect } from '../../../typings/space';
+import type { IOrientType, IPadding, IRect } from '../../../typings/space';
 import type { IBaseScale } from '@visactor/vscale';
 import type { StringOrNumber } from '../../../typings/common';
 import type { IPoint } from '../../../typings/coordinate';
 import type { ILayoutRect, ILayoutType } from '../../../typings/layout';
 import type { IComponentOption } from '../../interface';
 import { ComponentTypeEnum } from '../../interface/type';
+import type { LineAxisAttributes } from '@visactor/vrender-components';
 import type { IAxis, ITick } from '../interface';
 import type { ICartesianTickDataOpt } from '@visactor/vrender-components';
 import type { DataSet } from '@visactor/vdataset';
@@ -28,11 +29,6 @@ export declare abstract class CartesianAxis<T extends ICartesianAxisCommonSpec =
     layoutZIndex: number;
     layoutLevel: number;
     protected _dataSet: DataSet;
-    layout3dBox?: {
-        width: number;
-        height: number;
-        length: number;
-    };
     protected _orient: IOrientType;
     getOrient(): IOrientType;
     protected getDefaultInteractive(): boolean;
@@ -42,7 +38,7 @@ export declare abstract class CartesianAxis<T extends ICartesianAxisCommonSpec =
     protected _scales: IBaseScale[];
     getScales(): IBaseScale[];
     protected _tick: ITick | undefined;
-    private _axisStyle;
+    protected _axisStyle: Partial<LineAxisAttributes>;
     private _latestBounds;
     private _verticalLimitSize;
     private _unitText;
@@ -61,11 +57,6 @@ export declare abstract class CartesianAxis<T extends ICartesianAxisCommonSpec =
     static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
     static createComponent(specInfo: IModelSpecInfo, options: IComponentOption): IAxis;
     initLayout(): void;
-    setLayout3dBox(box3d: {
-        width: number;
-        height: number;
-        length: number;
-    }): void;
     effect: IEffect;
     protected abstract computeDomain(data: {
         min: number;
@@ -77,7 +68,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;
@@ -94,9 +85,10 @@ export declare abstract class CartesianAxis<T extends ICartesianAxisCommonSpec =
         y: number;
     };
     _transformLayoutRect: (result: ILayoutRect) => ILayoutRect;
+    _transformLayoutPadding: (padding: IPadding) => IPadding;
     getBoundsInRect(rect: ILayoutRect): IBoundsLike;
     positionToData(pos: number, isViewPos?: boolean): any;
-    private _getTitleLimit;
+    protected _getTitleLimit(isX: boolean): number;
     protected _getUpdateAttribute(ignoreGrid: boolean): any;
     protected getLabelItems(length: number): any[];
     protected initEvent(): void;
@@ -104,6 +96,7 @@ export declare abstract class CartesianAxis<T extends ICartesianAxisCommonSpec =
     protected _getNormalizedValue(values: any[], length: number): number;
     private _fixAxisOnZero;
     protected _layoutCacheProcessing(rect: ILayoutRect): ILayoutRect;
+    reInit(spec?: T): void;
     _clearLayoutCache(): void;
     onDataUpdate(): void;
     private _appendAxisUnit;

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

@@ -10,6 +10,12 @@ export declare class CartesianBandAxis<T extends ICartesianBandAxisSpec = ICarte
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
     static specKey: string;
+    static readonly builtInTheme: {
+        axis: import("../interface").IAxisCommonTheme;
+        axisBand: import("../interface").IBandAxisTheme;
+        axisX: import("./interface").ICartesianAxisCommonTheme;
+        axisY: import("./interface").ICartesianAxisCommonTheme;
+    };
     protected _scale: BandScale;
     protected _scales: BandScale[];
     protected computeDomain(data: {

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

@@ -1,7 +1,7 @@
 import type { LogScale } from '@visactor/vscale';
 import { LinearScale } from '@visactor/vscale';
 import { CartesianAxis } from './axis';
-import type { IAxisHelper, ICartesianLinearAxisSpec } from './interface';
+import type { IAxisHelper, ICartesianAxisCommonTheme, ICartesianLinearAxisSpec } from './interface';
 import { ComponentTypeEnum } from '../../interface/type';
 import { LinearAxisMixin } from '../mixin/linear-axis-mixin';
 import type { ICartesianTickDataOpt } from '@visactor/vrender-components';
@@ -11,6 +11,7 @@ export declare class CartesianLinearAxis<T extends ICartesianLinearAxisSpec = IC
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
     static specKey: string;
+    static readonly builtInTheme: Record<string, ICartesianAxisCommonTheme>;
     protected _zero: boolean;
     protected _nice: boolean;
     protected _extend: {

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

@@ -9,6 +9,12 @@ export declare class CartesianLogAxis<T extends ICartesianLogAxisSpec = ICartesi
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
     static specKey: string;
+    static readonly builtInTheme: {
+        axis: import("../interface").IAxisCommonTheme;
+        axisLinear: import("../interface").IAxisCommonTheme;
+        axisX: import("./interface").ICartesianAxisCommonTheme;
+        axisY: import("./interface").ICartesianAxisCommonTheme;
+    };
     protected _zero: boolean;
     protected _scale: LogScale;
     protected _scales: LogScale[];

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

@@ -9,6 +9,12 @@ export declare class CartesianSymlogAxis<T extends ICartesianSymlogAxisSpec = IC
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
     static specKey: string;
+    static readonly builtInTheme: {
+        axis: import("..").IAxisCommonTheme;
+        axisLinear: import("..").IAxisCommonTheme;
+        axisX: import("./interface").ICartesianAxisCommonTheme;
+        axisY: import("./interface").ICartesianAxisCommonTheme;
+    };
     protected _zero: boolean;
     protected _scale: SymlogScale;
     protected _scales: SymlogScale[];

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

@@ -10,12 +10,18 @@ export declare class CartesianTimeAxis<T extends ICartesianTimeAxisSpec = ICarte
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
     static specKey: string;
+    static readonly builtInTheme: {
+        axis: import("..").IAxisCommonTheme;
+        axisX: import("./interface").ICartesianAxisCommonTheme;
+        axisY: import("./interface").ICartesianAxisCommonTheme;
+    };
     protected _layerTickData: CompilableData;
     protected _zero: boolean;
     effect: IEffect;
     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/cartesian/util/common.d.ts

@@ -1,6 +1,7 @@
 import type { IOrientType } from '../../../../typings';
 import { Direction } from '../../../../typings/space';
 import type { ICartesianAxisCommonSpec } from '../interface';
+import type { AxisType } from '../../interface/common';
 export declare function isXAxis(orient: IOrientType): boolean;
 export declare function isYAxis(orient: IOrientType): boolean;
 export declare function isZAxis(orient: IOrientType): boolean;
@@ -10,6 +11,7 @@ export declare function getDirectionByOrient(orient: IOrientType): Direction;
 export declare function isOrientInSameDirection(orient1: IOrientType, orient2: IOrientType): boolean;
 export declare function transformInverse(spec: ICartesianAxisCommonSpec, isHorizontal: boolean): boolean;
 export declare function getCartesianAxisInfo(spec: ICartesianAxisCommonSpec, isHorizontal?: boolean): {
-    axisType: import("../..").AxisType;
+    axisType: AxisType;
     componentName: string;
 };
+export declare const getCartesianAxisTheme: (orient: IOrientType, type: AxisType, getTheme: (...keys: string[]) => any) => any;

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/axis/interface/spec.d.ts

@@ -4,6 +4,7 @@ import type { Datum, IFormatMethod, IPadding, IRectMarkSpec, IRichTextFormatMeth
 import type { IComponentSpec } from '../../base/interface';
 import type { AxisType, IAxisItem, IBandAxisLayer, ITickCalculationCfg, StyleCallback } from './common';
 import type { IBaseScale } from '@visactor/vscale';
+import type { IVChart } from '../../../core';
 export interface ICommonAxisSpec extends Omit<IComponentSpec, 'orient' | 'center'>, IAnimationSpec<string, string> {
     type?: AxisType;
     visible?: boolean;
@@ -63,7 +64,9 @@ export interface ITick extends IAxisItem<IRuleMarkSpec>, ITickCalculationCfg {
     alignWithLabel?: boolean;
     style?: IRuleMarkSpec | StyleCallback<IRuleMarkSpec | undefined>;
     state?: AxisItemStateStyle<IRuleMarkSpec>;
-    dataFilter?: (data: AxisItem[]) => AxisItem[];
+    dataFilter?: (data: AxisItem[], context: {
+        vchart: IVChart;
+    }) => AxisItem[];
 }
 export interface ISubTick extends IAxisItem<IRuleMarkSpec> {
     tickCount?: number;
@@ -80,7 +83,9 @@ export interface ILabel extends IAxisItem<ITextMarkSpec> {
     minGap?: number;
     style?: ITextMarkSpec | StyleCallback<ITextMarkSpec | undefined>;
     state?: AxisItemStateStyle<ITextMarkSpec>;
-    dataFilter?: (data: AxisItem[], layer: number) => AxisItem[];
+    dataFilter?: (data: AxisItem[], layer: number, context: {
+        vchart: IVChart;
+    }) => AxisItem[];
 }
 export interface IDomainLine extends IAxisItem<IRuleMarkSpec> {
     state?: AxisItemStateStyle<IRuleMarkSpec>;

package/types/component/axis/mixin/band-axis-mixin.d.ts

@@ -32,6 +32,7 @@ export interface BandAxisMixin {
     _tickTransformOption: () => any;
     _forceLayout: () => void;
     _getNormalizedValue: (values: any[], length: number) => number;
+    _onTickDataChange: (compilableData: CompilableData) => void;
 }
 export declare class BandAxisMixin {
     private _tickDataMap;

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

@@ -10,6 +10,12 @@ export declare class PolarBandAxis<T extends IPolarBandAxisSpec = IPolarBandAxis
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
     static specKey: string;
+    static readonly builtInTheme: {
+        axis: import("../interface").IAxisCommonTheme;
+        axisBand: import("../interface").IBandAxisTheme;
+        axisAngle: import("./interface").IPolarAxisCommonTheme;
+        axisRadius: import("./interface").IPolarAxisCommonTheme;
+    };
     protected _scale: BandScale;
     protected _scales: BandScale[];
     protected computeDomain(data: {

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

@@ -9,6 +9,12 @@ export declare class PolarLinearAxis<T extends IPolarLinearAxisSpec = IPolarLine
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
     static specKey: string;
+    static readonly builtInTheme: {
+        axis: import("../interface").IAxisCommonTheme;
+        axisLinear: import("../interface").IAxisCommonTheme;
+        axisAngle: import("./interface").IPolarAxisCommonTheme;
+        axisRadius: import("./interface").IPolarAxisCommonTheme;
+    };
     protected _zero: boolean;
     protected _nice: boolean;
     protected _extend: {

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

@@ -1,8 +1,10 @@
 import type { IPolarAxisCommonSpec } from '../interface';
 import type { ILayoutRect } from '../../../../typings/layout';
 import type { IPoint } from '../../../../typings/coordinate';
+import type { IPolarOrientType } from '../../../../typings/space';
+import type { AxisType } from '../../interface/common';
 export declare const getPolarAxisInfo: (spec: IPolarAxisCommonSpec, chartSpec: any) => {
-    axisType: import("../..").AxisType;
+    axisType: AxisType;
     componentName: string;
     startAngle: any;
     endAngle: any;
@@ -14,3 +16,4 @@ export declare const computeLayoutRadius: (getLayoutRadius: () => number | "auto
     startAngle: number;
     endAngle: number;
 }) => number;
+export declare const getPolarAxisTheme: (orient: IPolarOrientType, type: AxisType, getTheme: (...keys: string[]) => any) => any;

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

@@ -1,8 +1,6 @@
-import type { IOrientType, IPolarOrientType } from '../../typings';
 import type { AxisType, ICommonAxisSpec, ILinearAxisSpec } from './interface';
-import type { ITheme } from '../../theme';
-import type { IAxisHelper } from './cartesian';
-import type { IPolarAxisHelper } from './polar';
+import type { IAxisHelper } from './cartesian/interface/common';
+import type { IPolarAxisHelper } from './polar/interface/common';
 export declare const DEFAULT_TITLE_STYLE: {
     left: {
         textAlign: string;
@@ -26,8 +24,6 @@ export declare function getLinearAxisSpecDomain(axisSpec: ILinearAxisSpec, defau
 };
 export declare function isValidCartesianAxis(spec: any): boolean;
 export declare function isValidPolarAxis(spec: any): boolean;
-export declare const getCartesianAxisTheme: (orient: IOrientType, type: AxisType, chartTheme: ITheme) => any;
-export declare const getPolarAxisTheme: (orient: IPolarOrientType, type: AxisType, chartTheme: ITheme) => any;
 export declare const isDiscreteAxis: (axisType: AxisType) => boolean;
 export declare function getAxisItem(value: any, normalizedValue: number): {
     id: any;

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

@@ -3,8 +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';
 import { LayoutModel } from '../../model/layout-model';
@@ -22,8 +20,6 @@ export declare class BaseComponent<T extends IComponentSpec = IComponentSpec> ex
     getRegions(): IRegion[];
     protected _container: IGroup;
     created(): void;
-    animate?: IAnimate;
-    constructor(spec: T, options: IComponentOption);
     initLayout(): void;
     changeRegions(regions: IRegion[]): void;
     protected _getNeedClearVRenderComponents(): IGraphic[];
@@ -41,7 +37,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/base/util.d.ts

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