@visactor/vchart-types 1.13.1 → 1.13.2

package/types/animation/utils.d.ts

@@ -10,9 +10,9 @@ export declare function animationConfig<Preset extends string>(defaultConfig?: M
     dataIndex: (datum: any, params: any) => number;
     dataCount: () => number;
 }): MarkAnimationSpec;
-export declare function userAnimationConfig<M extends string, Preset extends string>(markName: SeriesMarkNameEnum | string, spec: IAnimationSpec<M, Preset>, ctx: IModelMarkAttributeContext): Partial<Record<"none" | "normal" | "state" | "exit" | "update" | "appear" | "enter" | "disappear", boolean | IAnimationConfig | IAnimationConfig[] | IStateAnimateSpec<Preset>>>;
+export declare function userAnimationConfig<M extends string, Preset extends string>(markName: SeriesMarkNameEnum | string, spec: IAnimationSpec<M, Preset>, ctx: IModelMarkAttributeContext): Partial<Record<"none" | "normal" | "state" | "enter" | "exit" | "update" | "appear" | "disappear", boolean | IAnimationConfig | IAnimationConfig[] | IStateAnimateSpec<Preset>>>;
 export declare function shouldMarkDoMorph(spec: ISeriesSpec & IAnimationSpec<string, string>, markName: string): boolean;
 export declare function isTimeLineAnimation(animationConfig: IAnimationConfig): boolean;
 export declare function isChannelAnimation(animationConfig: IAnimationConfig): boolean;
-export declare function uniformAnimationConfig<Preset extends string>(config: Partial<Record<IAnimationState, boolean | IStateAnimateSpec<Preset> | IAnimationConfig | IAnimationConfig[]>>, ctx: IModelMarkAttributeContext): Partial<Record<"none" | "normal" | "state" | "exit" | "update" | "appear" | "enter" | "disappear", boolean | IAnimationConfig | IAnimationConfig[] | IStateAnimateSpec<Preset>>>;
+export declare function uniformAnimationConfig<Preset extends string>(config: Partial<Record<IAnimationState, boolean | IStateAnimateSpec<Preset> | IAnimationConfig | IAnimationConfig[]>>, ctx: IModelMarkAttributeContext): Partial<Record<"none" | "normal" | "state" | "enter" | "exit" | "update" | "appear" | "disappear", boolean | IAnimationConfig | IAnimationConfig[] | IStateAnimateSpec<Preset>>>;
 export declare function isAnimationEnabledForSeries(series: ISeries): boolean;

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

@@ -7,7 +7,7 @@ import type { IChart, IChartLayoutOption, IChartRenderOption, IChartOption, ICha
 import type { ISeries, ISeriesConstructor } from '../../series/interface';
 import type { IRegion } from '../../region/interface';
 import type { IComponent, IComponentConstructor } from '../../component/interface';
-import type { IMark } from '../../mark/interface';
+import type { IMark, IRectMark } from '../../mark/interface';
 import type { IEvent } from '../../event/interface';
 import type { DataView } from '@visactor/vdataset';
 import type { DataSet } from '@visactor/vdataset';
@@ -16,7 +16,6 @@ import type { IBoundsLike } from '@visactor/vutils';
 import type { IRunningConfig as IMorphConfig, IView } from '@visactor/vgrammar-core';
 import { CompilableBase } from '../../compile/compilable-base';
 import type { IGlobalScale } from '../../scale/interface';
-import type { IRectMark } from '../../mark/rect';
 export declare class BaseChart<T extends IChartSpec> extends CompilableBase implements IChart {
     readonly type: string;
     readonly seriesType: string;

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

@@ -2,8 +2,8 @@ import type { ILineSeriesSpec } from '../../series/line/interface';
 import type { IAreaSeriesSpec } from '../../series/area/interface';
 import type { IChartSpec } from '../../typings/spec/common';
 import type { IBar3dSeriesSpec, IBarSeriesSpec } from '../../series/bar/interface';
-import type { IRangeColumnChartSpec } from '../range-column';
-import type { IRangeAreaChartSpec } from '../range-area';
+import type { IRangeColumnChartSpec } from '../range-column/interface';
+import type { IRangeAreaChartSpec } from '../range-area/interface';
 import type { IDotSeriesSpec } from '../../series/dot/interface';
 import type { IMapSeriesSpec } from '../../series/map/interface';
 import type { IPie3dSeriesSpec, IPieSeriesSpec } from '../../series/pie/interface';
@@ -12,7 +12,7 @@ import type { IRadarSeriesSpec } from '../../series/radar/interface';
 import type { IRoseSeriesSpec } from '../../series/rose/interface';
 import type { IScatterSeriesSpec } from '../../series/scatter/interface';
 import type { IWordCloud3dSeriesSpec, IWordCloudSeriesSpec } from '../../series/word-cloud/interface';
-import type { IGaugePointerSeriesSpec, IGaugeSeriesSpec } from '../../series/gauge';
+import type { IGaugePointerSeriesSpec, IGaugeSeriesSpec } from '../../series/gauge/interface';
 import type { IBoxPlotSeriesSpec } from '../../series/box-plot/interface';
 import type { ICirclePackingSeriesSpec } from '../../series/circle-packing/interface';
 import type { IFunnelSeriesSpec, IFunnel3dSeriesSpec } from '../../series/funnel/interface';
@@ -24,7 +24,8 @@ import type { ISunburstSeriesSpec } from '../../series/sunburst/interface';
 import type { ITreemapSeriesSpec } from '../../series/treemap/interface';
 import type { IWaterfallSeriesSpec } from '../../series/waterfall/interface';
 import type { ICorrelationSeriesSpec } from '../../series/correlation/interface';
-import type { ICartesianAxisSpec, IPolarAxisSpec } from '../../component';
+import type { ICartesianAxisSpec } from '../../component/axis/cartesian/interface';
+import type { IPolarAxisSpec } from '../../component/axis/polar/interface';
 import type { ICartesianCrosshairSpec, IPolarCrosshairSpec } from '../../component/crosshair/interface';
 import type { IMarkLineSpec } from '../../component/marker/mark-line/interface';
 import type { IMarkAreaSpec } from '../../component/marker/mark-area/interface';

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

@@ -1,8 +1,8 @@
 import type { IPolarAxisSpec } from '../../component/axis/polar/interface';
-import type { IGaugePointerSeriesSpec, IGaugeSeriesSpec } from '../../series/gauge';
+import type { IGaugePointerSeriesSpec, IGaugeSeriesSpec } from '../../series/gauge/interface';
 import type { ILinearAxisSpec } from '../../component/axis/interface';
 import type { ICircularProgressSeriesSpec } from '../../series/progress/circular/interface';
-import type { IPolarChartSpec } from '../polar';
+import type { IPolarChartSpec } from '../polar/interface';
 export interface IGaugeChartSpec extends Omit<IPolarChartSpec, 'axes'>, Omit<IGaugePointerSeriesSpec, 'data' | 'type' | 'morph' | 'tooltip'> {
     type: 'gauge';
     gauge?: Omit<IGaugeSeriesSpec, 'data'> | Omit<ICircularProgressSeriesSpec, 'data'>;

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

@@ -3,8 +3,8 @@ import type { IRenderOption } from '../../compile/interface';
 import type { IModelOption, IModelSpecInfo } from '../../model/interface';
 import type { IView } from '@visactor/vgrammar-core';
 import type { IBoundsLike } from '@visactor/vutils';
-import type { ISeriesSpecInfo } from '../../series';
-import type { IRegionSpecInfo } from '../../region';
+import type { ISeriesSpecInfo } from '../../series/interface';
+import type { IRegionSpecInfo } from '../../region/interface';
 export interface ILayoutParams {
     srView?: IView;
     group?: any;

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

@@ -2,7 +2,7 @@ import type { IPointLike } from '@visactor/vutils';
 import type { IPolarAxisSpec } from '../../component/axis/polar/interface';
 import type { IPolarCrosshairSpec } from '../../component/crosshair/interface';
 import type { IChartSpec, ILayoutRect } from '../../typings';
-import type { IIndicatorSpec } from '../../component';
+import type { IIndicatorSpec } from '../../component/indicator/interface';
 export interface IPolarChartSpec extends IChartSpec {
     axes?: IPolarAxisSpec[];
     crosshair?: IPolarCrosshairSpec | IPolarCrosshairSpec[];

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

@@ -1,6 +1,7 @@
 import type { IChartSpec, ISeriesSpec } from '../../typings/spec/common';
 import type { ICartesianAxisSpec } from '../../component/axis/cartesian/interface';
-import type { IDataZoomSpec, IScrollBarSpec } from '../../component/data-zoom';
+import type { IDataZoomSpec } from '../../component/data-zoom/data-zoom/interface';
+import type { IScrollBarSpec } from '../../component/data-zoom/scroll-bar/interface';
 import type { ICartesianCrosshairSpec } from '../../component/crosshair/interface';
 import type { ILayoutSpec } from '../../layout/interface';
 import type { RegionSpec } from '../../region/interface';

package/types/compile/compilable-base.d.ts

@@ -1,9 +1,8 @@
-import type { Compiler } from './compiler';
-import type { ICompilableInitOption, ICompilable } from './interface';
+import type { ICompilableInitOption, ICompilable, ICompiler } from './interface';
 export declare abstract class CompilableBase implements ICompilable {
     protected _option: ICompilableInitOption;
     getOption(): ICompilableInitOption;
-    getCompiler: () => Compiler;
+    getCompiler: () => ICompiler;
     constructor(option: ICompilableInitOption);
     getVGrammarView(): import("@visactor/vgrammar-core").IView;
     abstract compile(): void;

package/types/compile/compiler.d.ts

@@ -1,16 +1,16 @@
 import type { InteractionSpec, IView } from '@visactor/vgrammar-core';
-import type { CompilerListenerParameters, CompilerModel, IGrammarItem, IRenderContainer, IRenderOption } from './interface';
+import type { CompilerListenerParameters, ICompiler, ICompilerModel, IGrammarItem, IRenderContainer, IRenderOption } from './interface';
 import type { IBoundsLike } from '@visactor/vutils';
 import type { EventSourceType } from '../event/interface';
 import type { IChart } from '../chart/interface';
-import type { IColor, Stage } from '@visactor/vrender-core';
+import type { IColor, IStage } from '@visactor/vrender-core';
 import type { IMorphConfig } from '../animation/spec';
 import type { IVChart } from '../core/interface';
 type EventListener = {
     type: string;
     callback: (...args: any[]) => void;
 };
-export declare class Compiler {
+export declare class Compiler implements ICompiler {
     protected _view: IView;
     getVGrammarView(): IView;
     protected _viewListeners: Map<(...args: any[]) => any, EventListener>;
@@ -23,21 +23,21 @@ export declare class Compiler {
     protected _container: IRenderContainer;
     protected _option: IRenderOption;
     private _released;
-    protected _model: CompilerModel;
+    protected _model: ICompilerModel;
     protected _interactions: (InteractionSpec & {
         seriesId?: number;
         regionId?: number;
     })[];
-    getModel(): CompilerModel;
+    getModel(): ICompilerModel;
     private _compileChart;
     constructor(container: IRenderContainer, option: IRenderOption);
     getRenderer(): import("@visactor/vgrammar-core").IRenderer;
     getCanvas(): HTMLCanvasElement | undefined;
-    getStage(): Stage | undefined;
+    getStage(): IStage | undefined;
     initView(): void;
-    handleStageRender: () => void;
+    protected handleStageRender: () => void;
     private _setCanvasStyle;
-    compileInteractions(): void;
+    protected compileInteractions(): void;
     compile(ctx: {
         chart: IChart;
         vChart: IVChart;

package/types/compile/interface/compilable-item.d.ts

@@ -1,8 +1,66 @@
-import type { IGroupMark, IGrammarBase, IView } from '@visactor/vgrammar-core';
-import type { Compiler } from '../compiler';
-import type { Maybe, IPerformanceHook } from '../../typings';
+import type { IGroupMark, IGrammarBase, IView, IRenderer, InteractionSpec } from '@visactor/vgrammar-core';
+import type { Maybe, IPerformanceHook, StringOrNumber } from '../../typings';
+import type { IColor, IStage } from '@visactor/vrender-core';
+import type { IChart } from '../../chart/interface/chart';
+import type { IVChart } from '../../core/interface';
+import type { IMorphConfig } from '../../animation/spec';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { EventSourceType, EventType } from '../../event/interface';
+export type CompilerListenerParameters = {
+    type: EventType;
+    event: Event;
+    source: EventSourceType;
+    item: any | null;
+    datum: any | null;
+    markId: number | null;
+    modelId: number | null;
+    markUserId: StringOrNumber | null;
+    modelUserId: StringOrNumber | null;
+};
+export interface IProductMap<T extends IGrammarItem> {
+    [productId: string]: IGrammarItemMap<T>;
+}
+export interface IGrammarItemMap<T extends IGrammarItem> {
+    [id: number]: T;
+}
+export type ICompilerModel = Record<GrammarType, IProductMap<IGrammarItem>>;
+export interface ICompiler {
+    isInited?: boolean;
+    getVGrammarView: () => IView;
+    getModel: () => ICompilerModel;
+    getRenderer: () => IRenderer;
+    getCanvas: () => HTMLCanvasElement | undefined;
+    getStage: () => IStage | undefined;
+    compile: (ctx: {
+        chart: IChart;
+        vChart: IVChart;
+    }, option: any) => void;
+    clear: (ctx: {
+        chart: IChart;
+        vChart: IVChart;
+    }, removeGraphicItems?: boolean) => void;
+    renderNextTick: (morphConfig?: IMorphConfig) => void;
+    render: (morphConfig?: IMorphConfig) => void;
+    updateViewBox: (viewBox: IBoundsLike, reRender?: boolean) => void;
+    resize: (width: number, height: number, reRender?: boolean) => void;
+    setBackground: (color: IColor) => void;
+    setSize: (width: number, height: number) => void;
+    setViewBox: (viewBox: IBoundsLike, reRender?: boolean) => void;
+    addEventListener: (source: EventSourceType, type: string, callback: (params: CompilerListenerParameters) => void) => void;
+    removeEventListener: (source: EventSourceType, type: string, callback: (params: CompilerListenerParameters) => void) => void;
+    release: () => void;
+    releaseGrammar: (removeGraphicItems: boolean) => void;
+    addGrammarItem: (grammarItem: IGrammarItem) => void;
+    removeGrammarItem: (grammarItem: IGrammarItem, reserveVGrammarModel?: boolean) => void;
+    addInteraction: (interaction: InteractionSpec & {
+        seriesId?: number;
+        regionId?: number;
+    }) => void;
+    removeInteraction: (seriesId: number) => void;
+    updateDepend: (items?: IGrammarItem[]) => boolean;
+}
 export interface ICompilable {
-    getCompiler: () => Compiler;
+    getCompiler: () => ICompiler;
     getVGrammarView: () => IView;
     compile: () => void;
     compileMarks?: (group?: string | IGroupMark) => void;
@@ -13,7 +71,7 @@ export interface ICompilable {
     release: () => void;
 }
 export interface ICompilableInitOption {
-    getCompiler: () => Compiler;
+    getCompiler: () => ICompiler;
     performanceHook?: IPerformanceHook;
 }
 export declare enum GrammarType {

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

@@ -1,8 +1,7 @@
+import type { Hooks } from '@visactor/vgrammar-core';
 import type { IColor, IStageParams, IStage, ILayer } from '@visactor/vrender-core';
-import type { EventSourceType, EventType } from '../../event/interface';
 import type { RenderMode } from '../../typings/spec/common';
 import type { IBoundsLike } from '@visactor/vutils';
-import type { GrammarType, IGrammarItem } from './compilable-item';
 import type { StringOrNumber } from '../../typings';
 export interface IRenderContainer {
     dom?: HTMLElement | 'none';
@@ -52,22 +51,7 @@ export interface IRenderOption {
     supportsTouchEvents?: boolean;
     supportsPointerEvents?: boolean;
     ReactDOM?: any;
-}
-export type CompilerListenerParameters = {
-    type: EventType;
-    event: Event;
-    source: EventSourceType;
-    item: any | null;
-    datum: any | null;
-    markId: number | null;
-    modelId: number | null;
-    markUserId: StringOrNumber | null;
-    modelUserId: StringOrNumber | null;
-};
-export type CompilerModel = Record<GrammarType, IProductMap<IGrammarItem>>;
-export interface IProductMap<T extends IGrammarItem> {
-    [productId: string]: IGrammarItemMap<T>;
-}
-export interface IGrammarItemMap<T extends IGrammarItem> {
-    [id: number]: T;
+    clickInterval?: number;
+    autoPreventDefault?: boolean;
+    performanceHook?: Hooks;
 }

package/types/compile/mark/compilable-mark.d.ts

@@ -5,8 +5,7 @@ import type { Maybe, Datum, StringOrNumber } from '../../typings';
 import type { IMarkStateStyle, MarkType } from '../../mark/interface';
 import type { IModel } from '../../model/interface';
 import { MarkStateManager } from './mark-state-manager';
-import type { ICompilableMark, IMarkDataInitOption, ICompilableMarkOption, StateValueType, IMarkCompileOption, IAttributeOpt } from './interface';
-import { MarkData } from './mark-data';
+import type { ICompilableMark, IMarkDataInitOption, ICompilableMarkOption, StateValueType, IMarkCompileOption, IAttributeOpt, IMarkData } from './interface';
 import { GrammarType } from '../interface/compilable-item';
 import type { IEvent } from '../../event/interface';
 export declare abstract class CompilableMark extends GrammarItem implements ICompilableMark {
@@ -24,11 +23,11 @@ export declare abstract class CompilableMark extends GrammarItem implements ICom
     getUserId(): StringOrNumber;
     setUserId(userId: StringOrNumber): void;
     readonly model: IModel;
-    protected _data: Maybe<MarkData>;
+    protected _data: IMarkData;
     getDataView(): DataView | undefined;
     setDataView(d?: DataView, productId?: string): void;
-    getData(): MarkData;
-    setData(d?: MarkData): void;
+    getData(): IMarkData;
+    setData(d?: IMarkData): void;
     stateStyle: IMarkStateStyle<any>;
     state: MarkStateManager;
     protected _unCompileChannel: {

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

@@ -1,13 +1,25 @@
 import type { IMarkStateStyle, MarkType } from '../../mark/interface';
 import type { IModel } from '../../model/interface';
-import type { GrammarItemCompileOption, GrammarItemInitOption } from '../interface';
-import type { IGrammarItem } from '../interface';
-import type { MarkStateManager } from './mark-state-manager';
+import type { GrammarItemCompileOption, GrammarItemInitOption, IGrammarItem } from '../interface';
 import type { DataView } from '@visactor/vdataset';
 import type { IAnimate, IAnimateArranger, IElement, IGroupMark, IMark, IMarkConfig, MarkAnimationSpec, Nil, TransformSpec } from '@visactor/vgrammar-core';
 import type { Maybe, Datum, StringOrNumber } from '../../typings';
-import type { MarkData } from './mark-data';
 import type { IRegion } from '../../region/interface';
+import type { ICompilableData } from '../data/interface';
+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;
+}
+export interface IMarkData extends ICompilableData {
+    setCompiledProductId: (name: string) => any;
+    generateProductId: () => string;
+}
 export interface ICompilableMarkOption extends GrammarItemInitOption {
     key?: string | ((datum: Datum) => string);
     groupKey?: string;
@@ -21,11 +33,11 @@ export interface ICompilableMark extends IGrammarItem {
     readonly name: string;
     readonly key?: string | ((datum: Datum) => string);
     readonly model: IModel;
-    getData: () => MarkData | undefined;
-    setData: (d: MarkData) => void;
+    getData: () => IMarkData | undefined;
+    setData: (d: IMarkData) => void;
     getDataView: () => DataView | undefined;
     setDataView: (d?: DataView, productId?: string) => void;
-    state: MarkStateManager;
+    state: IMarkStateManager;
     readonly stateStyle: IMarkStateStyle<any>;
     hasState: (state: string) => boolean;
     getState: (state: string) => any;

package/types/compile/mark/mark-data.d.ts

@@ -1,6 +1,6 @@
 import { CompilableData } from '../data/compilable-data';
-import type { ICompilableMark, IMarkDataInitOption } from './interface';
-export declare class MarkData extends CompilableData {
+import type { ICompilableMark, IMarkData, IMarkDataInitOption } from './interface';
+export declare class MarkData extends CompilableData implements IMarkData {
     protected _mark: ICompilableMark;
     constructor(option: IMarkDataInitOption);
     setCompiledProductId(name: string): void;

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

@@ -3,8 +3,8 @@ 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 { IStateInfo, StateValue } from './interface';
-export declare class MarkStateManager extends StateManager {
+import type { IMarkStateManager, IStateInfo, StateValue } from './interface';
+export declare class MarkStateManager extends StateManager implements IMarkStateManager {
     protected _mark: CompilableMark;
     private _stateInfoList;
     getStateInfoList(): IStateInfo[];

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

@@ -9,7 +9,7 @@ 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/component';
+import type { IComponentMark } from '../../mark/interface/mark';
 export declare abstract class AxisComponent<T extends ICommonAxisSpec & Record<string, any> = any> extends BaseComponent<T> implements IAxis {
     static specKey: string;
     specKey: string;

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

@@ -1,4 +1,4 @@
-import type { ContinuousScale, IBaseScale, CustomTicksFunc } from '@visactor/vscale';
+import type { IContinuousScale, IBaseScale, CustomTicksFunc } from '@visactor/vscale';
 import type { CoordinateType, Datum, IPolarOrientType, StringOrNumber } from '../../../typings';
 import type { IComponent } from '../../interface/common';
 import type { ICartesianAxisSpec } from '../cartesian/interface';
@@ -42,7 +42,7 @@ export interface ITickCalculationCfg {
     tickStep?: number;
     tickCount?: number | ((option: ITickCallbackOption) => number);
     forceTickCount?: number;
-    tickMode?: 'average' | 'd3' | CustomTicksFunc<ContinuousScale>;
+    tickMode?: 'average' | 'd3' | CustomTicksFunc<IContinuousScale>;
     noDecimals?: boolean;
 }
 export interface IBandAxisLayer extends Omit<ITickCalculationCfg, 'noDecimals' | 'tickMode'> {

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

@@ -1,7 +1,7 @@
 import type { IBaseScale } from '@visactor/vscale';
 import type { IPoint, IPolarOrientType, IPolarPoint } from '../../../../typings';
 import type { IAxis, IGrid } from '../../interface';
-import type { ICompilableData } from '../../../../compile/data';
+import type { ICompilableData } from '../../../../compile/data/interface';
 export type IPolarGrid = IGrid & {
     smooth?: boolean;
 };

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

@@ -1,5 +1,5 @@
 import type { StringOrNumber } from '../../../typings';
-import type { IAxis } from '../../axis';
+import type { IAxis } from '../../axis/interface';
 export interface ICrosshairLabelInfo {
     visible: boolean;
     text: StringOrNumber;

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

@@ -1,5 +1,5 @@
 import type { StringOrNumber } from '../../../typings';
-import type { IAxis } from '../../axis';
+import type { IAxis } from '../../axis/interface';
 export type AxisCurrentValueMap = Map<number, {
     value: StringOrNumber;
     axis: IAxis;

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

@@ -1,5 +1,5 @@
 import type { IPoint, StringOrNumber } from '../../../typings';
-import type { IPolarAxis } from '../../axis';
+import type { IPolarAxis } from '../../axis/polar/interface';
 export interface IPolarCrosshairInfo {
     x: number;
     y: number;

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

@@ -1,4 +1,4 @@
-import type { ICartesianCrosshairSpec, ICommonCrosshairSpec, ICrosshairCategoryFieldSpec, ICrosshairValueFieldSpec, IPolarCrosshairSpec } from '.';
+import type { ICartesianCrosshairSpec, ICommonCrosshairSpec, ICrosshairCategoryFieldSpec, ICrosshairValueFieldSpec, IPolarCrosshairSpec } from './spec';
 export interface ICrosshairTheme extends ICommonCrosshairSpec {
     bandField?: Partial<ICrosshairCategoryFieldSpec>;
     linearField?: Partial<ICrosshairValueFieldSpec>;

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

@@ -2,8 +2,7 @@ import type { IMarkSpec } from '../../../typings/spec';
 import type { IAreaMarkSpec, ILineMarkSpec, IRectMarkSpec, ISymbolMarkSpec, ITextMarkSpec } from '../../../typings/visual';
 import type { IComponentSpec } from '../../base/interface';
 import type { ComponentThemeWithDirection, IComponent } from '../../interface';
-import type { IFilterMode } from '../interface';
-import type { IDataFilterComponent, IDataFilterComponentSpec } from '../interface';
+import type { IFilterMode, IDataFilterComponent, IDataFilterComponentSpec } from '../interface';
 export type IDataZoom = IComponent & IDataFilterComponent;
 export interface IDataZoomStyle {
     showDetail?: 'auto' | boolean;

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

@@ -2,8 +2,7 @@ import type { ILayoutItemSpec } from '../../../layout/interface';
 import type { IPadding } from '../../../typings';
 import type { IRectMarkSpec } from '../../../typings/visual';
 import type { ComponentThemeWithDirection } from '../../interface';
-import type { IFilterMode } from '../interface';
-import type { IDataFilterComponentSpec } from '../interface';
+import type { IFilterMode, IDataFilterComponentSpec } from '../interface';
 export interface IScrollBarStyle {
     rail?: Omit<IRectMarkSpec, 'width' | 'height'>;
     slider?: Omit<IRectMarkSpec, 'width' | 'height'>;

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

@@ -1,21 +1,25 @@
-import type { IAxisCommonTheme, ICartesianAxisCommonTheme, IPolarAxisCommonTheme } from '../axis';
-import type { IBrushTheme } from '../brush';
+import type { IAxisCommonTheme } from '../axis/interface';
+import type { IBrushTheme } from '../brush/interface';
 import type { ICrosshairTheme } from '../crosshair/interface';
-import type { IDataZoomTheme, IScrollBarTheme } from '../data-zoom';
+import type { IDataZoomTheme } from '../data-zoom/data-zoom/interface';
+import type { IScrollBarTheme } from '../data-zoom/scroll-bar/interface';
 import type { IIndicatorTheme } from '../indicator/interface';
-import type { IDiscreteLegendTheme, IColorLegendTheme, ISizeLegendTheme } from '../legend';
-import type { IMapLabelTheme } from '../map-label';
+import type { IDiscreteLegendTheme } from '../legend/discrete/interface';
+import type { IColorLegendTheme, ISizeLegendTheme } from '../legend/continuous/interface';
+import type { IMapLabelTheme } from '../map-label/interface';
 import type { IMarkAreaTheme } from '../marker/mark-area/interface';
 import type { IMarkLineTheme } from '../marker/mark-line/interface';
 import type { IMarkPointTheme } from '../marker/mark-point/interface';
-import type { IPlayerTheme } from '../player';
-import type { ITitleTheme } from '../title';
+import type { IPlayerTheme } from '../player/interface';
+import type { ITitleTheme } from '../title/interface';
 import type { ITooltipTheme } from '../tooltip/interface';
 import type { ComponentTypeEnum } from './type';
-import type { ITotalLabelTheme } from '../label';
+import type { ITotalLabelTheme } from '../label/interface';
 import type { IPoptipTheme } from '../poptip/interface';
-import type { IColorKey } from '../../theme';
+import type { IColorKey } from '../../theme/color-scheme/interface';
 import type { Direction, IOrientType } from '../../typings';
+import type { ICartesianAxisCommonTheme } from '../axis/cartesian/interface/theme';
+import type { IPolarAxisCommonTheme } from '../axis/polar/interface/theme';
 export interface IComponentTheme {
     axis?: IAxisCommonTheme;
     axisBand?: IAxisCommonTheme;

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

@@ -1,8 +1,20 @@
 import type { BaseLabelAttrs } from '@visactor/vrender-components';
 import type { ConvertToMarkStyleSpec, Datum, IComposedTextMarkSpec, IFormatMethod, ITextMarkSpec } from '../../typings';
 import type { IComponentSpec } from '../base/interface';
-import type { ILabelMark } from '../../mark/label';
-import type { ISeries } from '../../series';
+import type { ILabelMark } from '../../mark/interface';
+import type { ISeries } from '../../series/interface';
+import type { ICompilableMark } from '../../compile/mark/interface';
+import type { IRegion } from '../../region/interface';
+export interface ILabelInfo {
+    baseMark: ICompilableMark;
+    labelMark: ILabelMark;
+    series: ISeries;
+    labelSpec: TransformedLabelSpec;
+}
+export interface ILabelComponentContext {
+    region: IRegion;
+    labelInfo: ILabelInfo[];
+}
 export interface ILabelFormatMethodContext {
     series?: ISeries;
 }

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

@@ -2,27 +2,14 @@ import type { IComponentOption } from '../interface';
 import { ComponentTypeEnum } from '../interface/type';
 import type { IRegion } from '../../region/interface';
 import type { IModelInitOption, IModelSpecInfo } from '../../model/interface';
-import type { ISeries } from '../../series/interface';
+import type { IComponentMark } from '../../mark/interface';
 import type { ILabel, IMark as IVGrammarMark } from '@visactor/vgrammar-core';
-import type { IComponentMark } from '../../mark/component';
 import { BaseLabelComponent } from './base-label';
 import type { Maybe } from '@visactor/vutils';
-import type { TransformedLabelSpec } from './interface';
-import type { ILabelMark } from '../../mark/label';
-import type { ICompilableMark } from '../../compile/mark';
+import type { ILabelInfo } from './interface';
 import type { IChartSpecInfo } from '../../chart/interface';
 import type { IChartSpec } from '../../typings';
 import { LabelSpecTransformer } from './label-transformer';
-export interface ILabelInfo {
-    baseMark: ICompilableMark;
-    labelMark: ILabelMark;
-    series: ISeries;
-    labelSpec: TransformedLabelSpec;
-}
-export interface ILabelComponentContext {
-    region: IRegion;
-    labelInfo: ILabelInfo[];
-}
 export declare class Label<T extends IChartSpec = any> extends BaseLabelComponent<T> {
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;

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

@@ -1,8 +1,7 @@
 import type { WaterfallSeries } from './../../series/waterfall/waterfall';
 import type { Datum } from '../../typings/common';
-import type { ILabelInfo } from './label';
 import type { LabelItem, Strategy } from '@visactor/vrender-components';
-import type { ILabelSpec } from './interface';
+import type { ILabelInfo, ILabelSpec } from './interface';
 export declare const labelRuleMap: {
     rect: typeof barLabel;
     symbol: typeof symbolLabel;

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

@@ -2,13 +2,16 @@ import type { LegendTitle } from '@visactor/vrender-components';
 import type { Datum, IOrientType, IPadding, IRectMarkSpec, ISymbolMarkSpec, ITextMarkSpec, StringOrNumber } from '../../typings';
 import type { IComponent } from '../interface';
 import type { IComponentSpec } from '../base/interface';
-import type { IDiscreteLegendSpec } from './discrete';
-import type { IColorLegendSpec, ISizeLegendSpec } from './continuous';
+import type { IDiscreteLegendSpec } from './discrete/interface';
+import type { IColorLegendSpec, ISizeLegendSpec } from './continuous/interface';
 export type ILegend = IComponent & {
     getLegendData: () => Datum[];
     getSelectedData: () => StringOrNumber[];
     setSelectedData: (d: StringOrNumber[]) => void;
 };
+export interface IDiscreteLegend extends ILegend {
+    getLegendDefaultData: (originalData?: boolean) => StringOrNumber[];
+}
 export type NoVisibleMarkStyle<T> = Omit<T, 'visible'>;
 export type ITitle = {
     textStyle?: NoVisibleMarkStyle<ITextMarkSpec>;

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

@@ -15,9 +15,9 @@ export declare function transformLegendTitleAttributes(title: ITitle): {
         visible?: boolean;
         style?: Omit<import("./interface").NoVisibleMarkStyle<import("../..").IRectMarkSpec>, "width" | "height" | "visible">;
     };
-    text?: string | number | number[] | string[] | {
+    text?: string | number | string[] | number[] | {
         type?: "text";
-        text: string | number | number[] | string[];
+        text: string | number | string[] | number[];
     } | {
         type: "rich";
         text: import("@visactor/vrender-core").IRichTextCharacter[];

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

@@ -6,7 +6,7 @@ import type { CoordinateType, ILayoutRect, ILayoutType, IRect } from '../../typi
 import { BaseComponent } from '../base/base-component';
 import type { IDataPos, IDataPosCallback, IMarkerAttributeContext, IMarkerSpec, IMarkerSupportSeries } from './interface';
 import type { IGraphic, IGroup } from '@visactor/vrender-core';
-import type { IOptionWithCoordinates } from '../../data/transforms/aggregation';
+import type { IOptionWithCoordinates } from '../../data/transforms/interface';
 export declare abstract class BaseMarker<T extends IMarkerSpec> extends BaseComponent<T> {
     layoutType: ILayoutType | 'none';
     static specKey: string;