@visactor/vchart-types 1.8.0-alpha.0 → 1.8.0-beta.0

package/types/model/interface.d.ts

@@ -14,10 +14,13 @@ import type { StateValueType } from '../typings/spec';
 import type { ICompilable, ICompilableInitOption } from '../compile/interface';
 import type { ICompilableData } from '../compile/data';
 import type { IGlobalScale } from '../scale/interface';
-import type { IChart } from '../chart/interface';
+import type { IChart, IChartSpecInfo } from '../chart/interface';
 import type { IThemeColorScheme } from '../theme/color-scheme/interface';
 import type { ILayoutItem, ILayoutItemSpec } from '../layout/interface';
 import type { ILayoutPoint, ILayoutRect } from '../typings/layout';
+import type { ComponentTypeEnum } from '../component/interface';
+import type { SeriesMarkNameEnum, SeriesTypeEnum } from '../series';
+import type { TransformedLabelSpec } from '../component/label';
 export interface IModelInitOption {
 }
 export interface IModelLayoutOption {
@@ -49,6 +52,7 @@ export interface IModel extends ICompilable {
     readonly modelType: string;
     readonly type: string;
     readonly specKey: string;
+    readonly transformerConstructor: new (option: IBaseModelSpecTransformerOption) => IBaseModelSpecTransformer;
     readonly id: number;
     readonly userId?: StringOrNumber;
     readonly event: IEvent;
@@ -64,7 +68,7 @@ export interface IModel extends ICompilable {
     getChart: () => IChart;
     created: () => void;
     init: (option: IModelInitOption) => void;
-    reInit: (theme?: any, lastSpec?: any) => void;
+    reInit: (spec?: any) => void;
     beforeRelease: () => void;
     onEvaluateEnd: (ctx: IModelEvaluateOption) => void;
     onRender: (ctx: IModelRenderOption) => void;
@@ -72,12 +76,13 @@ export interface IModel extends ICompilable {
     updateSpec: (spec: any, totalSpec?: any) => IUpdateSpecResult;
     getSpec?: () => any;
     getSpecIndex: () => number;
+    getSpecPath: () => Array<string | number>;
     onLayoutStart: (layoutRect: IRect, viewRect: ILayoutRect, ctx: IModelLayoutOption) => void;
     onLayoutEnd: (ctx: IModelLayoutOption) => void;
-    setCurrentTheme: () => void;
     getColorScheme: () => IThemeColorScheme | undefined;
     setMarkStyle: <T extends ICommonSpec>(mark?: IMarkRaw<T>, style?: Partial<IMarkStyle<T> | ConvertToMarkStyleSpec<T>>, state?: StateValueType, level?: number) => void;
     initMarkStyleWithSpec: (mark?: IMark, spec?: any, key?: string) => void;
+    getSpecInfo: () => IModelSpecInfo;
 }
 export interface ILayoutModel extends IModel {
     getLayoutStartPoint: () => IPoint;
@@ -97,7 +102,9 @@ export interface IModelOption extends ICompilableInitOption {
     globalInstance: VChart;
     specIndex?: number;
     specKey?: string;
+    specPath?: Array<string | number>;
     getTheme?: () => ITheme;
+    getSpecInfo?: () => IChartSpecInfo;
     getChartLayoutRect: () => IRect;
     getChartViewRect: () => ILayoutRect;
     getChart: () => IChart;
@@ -106,8 +113,15 @@ export interface IModelOption extends ICompilableInitOption {
     animation: boolean;
     onError: (...args: any[]) => void;
 }
+export interface IModelSpecInfo<T extends Record<string, unknown> = any> {
+    type: string | ComponentTypeEnum | SeriesTypeEnum;
+    spec: T;
+    specPath?: Array<string | number>;
+    specIndex?: number;
+    theme?: any;
+}
 export interface IModelConstructor {
-    new (ctx: IModelOption): IModel;
+    readonly transformerConstructor: new (option: IBaseModelSpecTransformerOption) => IBaseModelSpecTransformer;
 }
 export type ILayoutModelState = {
     layoutUpdateRank: number;
@@ -120,3 +134,16 @@ export interface IModelMarkInfo {
     type: MarkTypeEnum | string | (MarkTypeEnum | string)[];
     name: string;
 }
+export interface IBaseModelSpecTransformerOption {
+    type: string;
+    getTheme: () => ITheme;
+}
+export interface IBaseModelSpecTransformerResult<T, K> {
+    spec: T;
+    theme: K;
+    markLabelSpec?: Partial<Record<SeriesMarkNameEnum, TransformedLabelSpec[]>>;
+}
+export interface IBaseModelSpecTransformer {
+    getTheme: (spec: any, chartSpec: any) => any;
+    transformSpec: (spec: any, chartSpec: any, chartSpecInfo?: IChartSpecInfo) => IBaseModelSpecTransformerResult<any, any>;
+}

package/types/plugin/base/base-plugin-service.d.ts

@@ -0,0 +1,13 @@
+import type { IBasePlugin, IBasePluginService } from './interface';
+export declare class BasePluginService<T extends IBasePlugin = IBasePlugin> implements IBasePluginService<T> {
+    protected _plugins: T[];
+    readonly id: number;
+    constructor();
+    add(plugins: T[]): T[] | null;
+    load(plugins: T[]): void;
+    activate(plugins: T[]): void;
+    get(id: number): T | undefined;
+    getAll(): T[];
+    dispose(pluginsId: number): void;
+    disposeAll(): void;
+}

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

@@ -0,0 +1,9 @@
+import type { IBasePlugin, IBasePluginService } from './interface';
+export declare class BasePlugin<T extends IBasePluginService = IBasePluginService> implements IBasePlugin<T> {
+    readonly id: number;
+    readonly name: string;
+    readonly type: string;
+    protected service?: T;
+    constructor(type: string);
+    onAdd(service: T): void;
+}

package/types/plugin/base/interface.d.ts

@@ -0,0 +1,22 @@
+export interface IBasePlugin<T = any> {
+    readonly type: string;
+    id: UniqueId;
+    name: string;
+    onAdd: (service: T) => void;
+    init?: () => void;
+    dispose?: (service: T) => void;
+    onInit?: (service: T, ...params: any) => MaybePromise<void>;
+    onDidCompile?: (service: T, ...params: any) => MaybePromise<void>;
+}
+export interface IBasePluginService<T = any> {
+    id: UniqueId;
+    load: (plugins: T[]) => void;
+    add: (plugins: T[]) => T[] | null;
+    activate: (plugins: T[]) => void;
+    get: (id: UniqueId) => T | undefined;
+    getAll: () => T[];
+    dispose: (pluginsId: UniqueId) => void;
+    disposeAll: () => void;
+}
+export type UniqueId = number;
+export type MaybePromise<T> = T | PromiseLike<T>;

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

@@ -0,0 +1,2 @@
+export * from './media-query';
+export * from './register';

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

@@ -1,6 +1,26 @@
-export interface IChartPlugin {
+import type { IChartSpecInfo } from '../../chart/interface';
+import type { IVChart } from '../../core';
+import type { VChartRenderActionSource } from '../../core/interface';
+import type { IBasePlugin, IBasePluginService, MaybePromise } from '../base/interface';
+export interface IChartPlugin<T extends IChartPluginService = any> extends IBasePlugin<T> {
+    specKey?: string;
+    onInit?: (service: T, chartSpec: any) => MaybePromise<void>;
+    onBeforeResize?: (service: T, width: number, height: number) => MaybePromise<void>;
+    onAfterChartSpecTransform?: (service: T, chartSpec: any, actionSource: VChartRenderActionSource) => MaybePromise<void>;
+    onAfterModelSpecTransform?: (service: T, chartSpec: any, chartSpecInfo: IChartSpecInfo, actionSource: VChartRenderActionSource) => MaybePromise<void>;
+    onBeforeInitChart?: (service: T, chartSpec: any, actionSource: VChartRenderActionSource) => MaybePromise<void>;
 }
 export interface IChartPluginConstructor {
-    readonly type: 'chartPlugin';
+    readonly pluginType: 'chart';
+    readonly specKey?: string;
+    readonly type: string;
     new (): IChartPlugin;
 }
+export interface IChartPluginService<T extends IChartPlugin = any> extends IBasePluginService<T> {
+    globalInstance: IVChart;
+    onInit?: (chartSpec: any) => MaybePromise<void>;
+    onBeforeResize?: (width: number, height: number) => MaybePromise<void>;
+    onAfterChartSpecTransform?: (chartSpec: any, actionSource: VChartRenderActionSource) => MaybePromise<void>;
+    onAfterModelSpecTransform?: (chartSpec: any, chartSpecInfo: IChartSpecInfo, actionSource: VChartRenderActionSource) => MaybePromise<void>;
+    onBeforeInitChart?: (chartSpec: any, actionSource: VChartRenderActionSource) => MaybePromise<void>;
+}

package/types/plugin/chart/media-query/index.d.ts

@@ -0,0 +1,2 @@
+export * from './interface';
+export * from './media-query';

package/types/plugin/chart/media-query/interface/common.d.ts

@@ -0,0 +1,28 @@
+import type { ComponentTypeEnum } from '../../../../component/interface';
+import type { IVChart } from '../../../../core';
+import type { IModelSpecInfo } from '../../../../model/interface';
+import type { SeriesTypeEnum } from '../../../../series';
+import type { IChartSpec } from '../../../../typings';
+export interface IMediaInfo {
+    width: number;
+    height: number;
+}
+export interface IMediaQueryActionFilterResult<T extends Record<string, unknown> = any> {
+    isChart?: boolean;
+    modelType?: 'series' | 'region' | 'component';
+    type?: SeriesTypeEnum | ComponentTypeEnum;
+    specKey?: keyof IChartSpec;
+    modelInfo: IModelSpecInfo<T>[];
+}
+export interface IMediaQueryOption {
+    globalInstance: IVChart;
+    updateSpec: (spec: any, compile?: boolean, render?: boolean) => void;
+}
+export interface IMediaQueryCheckResult {
+    isActive: boolean;
+    hasChanged: boolean;
+}
+export interface IMediaQueryActionResult {
+    chartSpec: any;
+    hasChanged: boolean;
+}

package/types/plugin/chart/media-query/interface/index.d.ts

@@ -0,0 +1,2 @@
+export * from './spec';
+export * from './common';

package/types/plugin/chart/media-query/interface/spec.d.ts

@@ -0,0 +1,25 @@
+import type { ComponentTypeEnum, SimplifiedComponentTypeEnum } from '../../../../component/interface';
+import type { IVChart } from '../../../../core';
+import type { IModelSpecInfo } from '../../../../model/interface';
+import type { SeriesTypeEnum } from '../../../../series';
+import type { IMediaInfo } from './common';
+export type IMediaQuerySpec = IMediaQueryItem[];
+export interface IMediaQueryItem {
+    query: IMediaQueryCondition;
+    action: IMediaQueryAction | IMediaQueryAction[];
+}
+export interface IMediaQueryCondition {
+    minWidth?: number;
+    maxWidth?: number;
+    minHeight?: number;
+    maxHeight?: number;
+    onResize?: (info: IMediaInfo, vchart: IVChart) => boolean;
+}
+export interface IMediaQueryAction<T extends Record<string, unknown> = any> {
+    spec: Partial<T> | ((filteredModelInfo: IModelSpecInfo<T>[], action: IMediaQueryAction<T>, query: IMediaQueryCondition) => Partial<T>);
+    filterType?: MediaQueryActionFilterType;
+    filter?: MediaQueryActionFilter<T>;
+    forceAppend?: boolean;
+}
+export type MediaQueryActionFilterType = 'region' | 'series' | 'chart' | `${SeriesTypeEnum}` | `${ComponentTypeEnum}` | `${SimplifiedComponentTypeEnum}`;
+export type MediaQueryActionFilter<T extends Record<string, unknown> = any> = Partial<T> | ((modelInfo: IModelSpecInfo<T>, action: IMediaQueryAction<T>, query: IMediaQueryCondition) => boolean);

package/types/plugin/chart/media-query/media-query.d.ts

@@ -0,0 +1,28 @@
+import type { IMediaInfo, IMediaQueryCheckResult, IMediaQuerySpec, IMediaQueryOption, IMediaQueryItem, IMediaQueryActionResult } from './interface';
+import type { IChartPlugin, IChartPluginService } from '../interface';
+import type { VChartRenderActionSource } from '../../../core/interface';
+import { BasePlugin } from '../../base/base-plugin';
+export declare class MediaQuery extends BasePlugin implements IChartPlugin {
+    static readonly pluginType: 'chart';
+    static readonly specKey = "media";
+    static readonly type: string;
+    readonly type: string;
+    protected _spec: IMediaQuerySpec;
+    protected _option: IMediaQueryOption;
+    protected _baseChartSpec: any;
+    protected _currentMediaInfo: Partial<IMediaInfo>;
+    readonly currentActiveItems: Set<IMediaQueryItem>;
+    protected _initialized: boolean;
+    constructor();
+    onInit(service: IChartPluginService, chartSpec: any): void;
+    onBeforeResize(service: IChartPluginService, width: number, height: number): void;
+    onAfterChartSpecTransform(service: IChartPluginService, chartSpec: any, actionSource: VChartRenderActionSource): void;
+    onBeforeInitChart(service: IChartPluginService, chartSpec: any, actionSource: VChartRenderActionSource): void;
+    changeSize(width: number, height: number, compile?: boolean, render?: boolean): boolean;
+    protected _applyQueries(compile?: boolean, render?: boolean): boolean;
+    check(item: IMediaQueryItem): IMediaQueryCheckResult;
+    apply(item: IMediaQueryItem, chartSpec: any): IMediaQueryActionResult;
+    reInit(compile?: boolean, render?: boolean): void;
+    dispose(): void;
+}
+export declare const registerMediaQuery: () => void;

package/types/plugin/chart/media-query/util/action.d.ts

@@ -0,0 +1,3 @@
+import type { IVChart } from '../../../../core';
+import type { IMediaQueryAction, IMediaQueryCondition, IMediaQueryActionResult } from '../interface';
+export declare const executeMediaQueryAction: <T extends Record<string, unknown>>(action: IMediaQueryAction<T>, query: IMediaQueryCondition, chartSpec: any, globalInstance: IVChart) => IMediaQueryActionResult;

package/types/plugin/chart/media-query/util/filter.d.ts

@@ -0,0 +1,4 @@
+import type { IVChart } from '../../../../core';
+import type { IMediaQueryAction, IMediaQueryActionFilterResult, IMediaQueryCondition, MediaQueryActionFilter, MediaQueryActionFilterType } from '../interface';
+export declare const executeMediaQueryActionFilter: <T extends Record<string, unknown>>(filterType: MediaQueryActionFilterType, filter: MediaQueryActionFilter<T>, action: IMediaQueryAction<T>, query: IMediaQueryCondition, chartSpec: any, globalInstance: IVChart) => IMediaQueryActionFilterResult;
+export declare const executeMediaQueryActionFilterType: <T extends Record<string, unknown>>(filterType: MediaQueryActionFilterType, chartSpec: any, globalInstance: IVChart) => IMediaQueryActionFilterResult<T>;

package/types/plugin/chart/media-query/util/index.d.ts

@@ -0,0 +1,2 @@
+export * from './query';
+export * from './filter';

package/types/plugin/chart/media-query/util/query.d.ts

@@ -0,0 +1,3 @@
+import type { IVChart } from '../../../../core';
+import type { IMediaInfo, IMediaQueryCondition } from '../interface';
+export declare const checkMediaQuery: (query: IMediaQueryCondition, mediaInfo: IMediaInfo, globalInstance: IVChart) => boolean;

package/types/plugin/chart/plugin-service.d.ts

@@ -0,0 +1,12 @@
+import type { IChartPlugin, IChartPluginService } from './interface';
+import type { IVChart } from '../../core';
+import { BasePluginService } from '../base/base-plugin-service';
+import type { VChartRenderActionSource } from '../../core/interface';
+export declare class ChartPluginService<T extends IChartPlugin = IChartPlugin> extends BasePluginService<T> implements IChartPluginService<T> {
+    globalInstance: IVChart;
+    constructor(globalInstance: IVChart);
+    onInit(chartSpec: any): void;
+    onBeforeResize(width: number, height: number): void;
+    onAfterChartSpecTransform(chartSpec: any, actionSource: VChartRenderActionSource): void;
+    onBeforeInitChart(chartSpec: any, actionSource: VChartRenderActionSource): void;
+}

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

@@ -0,0 +1,2 @@
+import type { IChartPluginConstructor } from './interface';
+export declare const registerChartPlugin: (plugin: IChartPluginConstructor) => void;

package/types/plugin/components/axis-sync-plugin/axis-sync.d.ts

@@ -1,8 +1,10 @@
-import { BasicComponentPlugin } from '../basic-plugin';
 import type { IComponentPlugin, IComponentPluginService } from '../interface';
 import type { CartesianAxis, ILinearAxisSync } from '../../../component/axis/cartesian';
-export declare class AxisSyncPlugin extends BasicComponentPlugin implements IComponentPlugin {
-    Name: string;
+import { BasePlugin } from '../../base/base-plugin';
+export declare class AxisSyncPlugin extends BasePlugin<IComponentPluginService> implements IComponentPlugin<IComponentPluginService> {
+    static readonly pluginType: 'component';
+    static readonly type: string;
+    readonly type: string;
     constructor();
     protected _checkEnableSync(axis: CartesianAxis): ILinearAxisSync | false;
     private _getTargetAxis;

package/types/plugin/components/interface.d.ts

@@ -1,33 +1,23 @@
 import type { IComponent } from '../../component/interface';
-type UniqueId = number;
-type MaybePromise<T> = T | PromiseLike<T>;
+import type { IBasePlugin, IBasePluginService, MaybePromise } from '../base/interface';
 interface IContext {
     skipLayout: boolean;
 }
-export interface IComponentPlugin {
-    id: UniqueId;
-    name: string;
-    onAdd: (service: IComponentPluginService) => void;
-    init?: () => void;
-    dispose?: (service: IComponentPluginService) => void;
-    onInit?: (service: IComponentPluginService, ...params: any) => MaybePromise<void>;
-    onDidCompile?: (service: IComponentPluginService, ...params: any) => MaybePromise<void>;
-    onWillLayout?: (service: IComponentPluginService, ...params: any) => MaybePromise<void>;
-    onDidLayout?: (service: IComponentPluginService, ...params: any) => MaybePromise<void>;
-    onWillLayoutVertical?: (service: IComponentPluginService, context: IContext, ...params: any) => MaybePromise<void>;
-    onWillLayoutHorizontal?: (service: IComponentPluginService, context: IContext, ...params: any) => MaybePromise<void>;
-    onDidLayoutVertical?: (service: IComponentPluginService, ...params: any) => MaybePromise<void>;
-    onDidLayoutHorizontal?: (service: IComponentPluginService, ...params: any) => MaybePromise<void>;
+export interface IComponentPlugin<T extends IComponentPluginService = any> extends IBasePlugin<T> {
+    onWillLayout?: (service: T, ...params: any) => MaybePromise<void>;
+    onDidLayout?: (service: T, ...params: any) => MaybePromise<void>;
+    onWillLayoutVertical?: (service: T, context: IContext, ...params: any) => MaybePromise<void>;
+    onWillLayoutHorizontal?: (service: T, context: IContext, ...params: any) => MaybePromise<void>;
+    onDidLayoutVertical?: (service: T, ...params: any) => MaybePromise<void>;
+    onDidLayoutHorizontal?: (service: T, ...params: any) => MaybePromise<void>;
 }
-export interface IComponentPluginService {
-    id: UniqueId;
+export interface IComponentPluginConstructor {
+    readonly pluginType: 'component';
+    readonly specKey?: string;
+    readonly type: string;
+    new (): IComponentPlugin;
+}
+export interface IComponentPluginService<T extends IComponentPlugin = any> extends IBasePluginService<T> {
     component: IComponent;
-    load: (plugins: IComponentPlugin[]) => void;
-    add: (plugins: IComponentPlugin[]) => IComponentPlugin[] | null;
-    activate: (plugins: IComponentPlugin[]) => void;
-    get: (id: UniqueId) => IComponentPlugin | undefined;
-    getAll: () => IComponentPlugin[];
-    dispose: (pluginsId: UniqueId) => void;
-    disposeAll: () => void;
 }
 export {};

package/types/plugin/components/plugin-service.d.ts

@@ -1,15 +1,7 @@
 import type { IComponentPlugin, IComponentPluginService } from './interface';
 import type { IComponent } from '../../component/interface';
-export declare class ComponentPluginService implements IComponentPluginService {
-    private plugins;
-    readonly id: number;
+import { BasePluginService } from '../base/base-plugin-service';
+export declare class ComponentPluginService<T extends IComponentPlugin = IComponentPlugin> extends BasePluginService<T> implements IComponentPluginService<T> {
     component: IComponent;
     constructor(component: IComponent);
-    add(plugins: IComponentPlugin[]): IComponentPlugin[] | null;
-    load(plugins: IComponentPlugin[]): void;
-    activate(plugins: IComponentPlugin[]): void;
-    get(id: number): IComponentPlugin | undefined;
-    getAll(): IComponentPlugin[];
-    dispose(pluginsId: number): void;
-    disposeAll(): void;
 }

package/types/plugin/index.d.ts

@@ -0,0 +1 @@
+export * from './chart';

package/types/region/index.d.ts

@@ -0,0 +1,3 @@
+export * from './interface';
+export * from './region';
+export * from './region-transformer';

package/types/region/interface.d.ts

@@ -1,5 +1,5 @@
 import type { IMark } from '../mark/interface';
-import type { ILayoutModel, IModelOption } from '../model/interface';
+import type { ILayoutModel, IModelConstructor, IModelOption, IModelSpecInfo } from '../model/interface';
 import type { ISeries, SeriesType } from '../series/interface';
 import type { CoordinateType } from '../typings/coordinate';
 import type { IInteraction } from '../interaction/interface';
@@ -29,6 +29,7 @@ export interface IRegion extends ILayoutModel {
     getMarks: () => IMark[];
     getGroupMark: () => IGroupMark;
     getInteractionMark: () => IGroupMark;
+    getSpecInfo: () => IRegionSpecInfo;
 }
 export type ISeriesFilter = {
     name?: string;
@@ -39,7 +40,7 @@ export type ISeriesFilter = {
     coordinateType?: CoordinateType;
     dataName?: string;
 };
-export interface IRegionConstructor {
+export interface IRegionConstructor extends IModelConstructor {
     new (spec: IRegionSpec, ctx: IModelOption): IRegion;
 }
 export interface IRegionSpec extends ILayoutItemSpec {
@@ -59,3 +60,10 @@ export interface IGeoRegionSpec extends IRegionSpec {
         max?: number;
     };
 }
+export interface IRegionSpecInfo<T extends IRegionSpec = IRegionSpec> extends IModelSpecInfo {
+    type: 'region';
+    spec: T;
+    seriesIndexes?: number[];
+    markLabel?: IModelSpecInfo;
+    geoCoordinate?: IModelSpecInfo;
+}

package/types/region/region-transformer.d.ts

@@ -0,0 +1,8 @@
+import { BaseModelSpecTransformer } from '../model/base-model-transformer';
+import type { IRegionSpec } from './interface';
+export declare class RegionSpecTransformer<T extends IRegionSpec = IRegionSpec, K extends Partial<IRegionSpec> = Partial<IRegionSpec>> extends BaseModelSpecTransformer<T, K> {
+    protected _initTheme(spec: T, chartSpec: any): {
+        spec: T;
+        theme: K;
+    };
+}

package/types/region/region.d.ts

@@ -2,15 +2,18 @@ import type { IGroupMark as IVGrammarGroupMark } from '@visactor/vgrammar-core';
 import type { ISeries } from '../series/interface';
 import type { IModelOption } from '../model/interface';
 import type { CoordinateType } from '../typings/coordinate';
-import type { IRegion, IRegionSpec } from './interface';
+import type { IRegion, IRegionSpec, IRegionSpecInfo } from './interface';
 import type { IGroupMark } from '../mark/group';
 import type { IInteraction, ITrigger } from '../interaction/interface';
 import type { IRectMark } from '../mark/rect';
 import type { IAnimate } from '../animation/interface';
 import type { ILayoutType, StringOrNumber } from '../typings';
 import { LayoutModel } from '../model/layout-model';
+import { RegionSpecTransformer } from './region-transformer';
 export declare class Region<T extends IRegionSpec = IRegionSpec> extends LayoutModel<T> implements IRegion {
     static type: string;
+    static readonly transformerConstructor: typeof RegionSpecTransformer;
+    readonly transformerConstructor: any;
     readonly modelType: string;
     type: string;
     protected _series: ISeries[];
@@ -18,6 +21,7 @@ export declare class Region<T extends IRegionSpec = IRegionSpec> extends LayoutM
     layoutZIndex: number;
     animate?: IAnimate;
     interaction: IInteraction;
+    getSpecInfo: () => IRegionSpecInfo;
     getMaxWidth(): number;
     setMaxWidth(value: number): void;
     getMaxHeight(): number;
@@ -32,21 +36,20 @@ export declare class Region<T extends IRegionSpec = IRegionSpec> extends LayoutM
     protected _trigger: ITrigger;
     constructor(spec: T, ctx: IModelOption);
     protected _getClipDefaultValue(): boolean;
-    _initTheme(): void;
     created(): void;
     private _createGroupMark;
     init(option: any): void;
     initMark(): void;
     protected _initBackgroundMarkStyle(): void;
     protected _initForegroundMarkStyle(): void;
-    _compareSpec(): {
+    _compareSpec(spec: T, prevSpec: T): {
         change: boolean;
         reMake: boolean;
         reRender: boolean;
         reSize: boolean;
         reCompile: boolean;
     };
-    reInit(theme?: any): void;
+    reInit(spec?: T): void;
     addSeries(s: ISeries): void;
     removeSeries(s: ISeries): void;
     getSeries(opt?: {

package/types/series/area/area-transformer.d.ts

@@ -0,0 +1,5 @@
+import { LineLikeSeriesSpecTransformer } from '../mixin/line-mixin-transformer';
+import type { IAreaSeriesSpec, IAreaSeriesTheme } from './interface';
+export declare class AreaSeriesSpecTransformer<T extends IAreaSeriesSpec = IAreaSeriesSpec, K extends IAreaSeriesTheme = IAreaSeriesTheme> extends LineLikeSeriesSpecTransformer<T, K> {
+    protected _transformLabelSpec(spec: T): void;
+}

package/types/series/area/area.d.ts

@@ -2,18 +2,20 @@ import type { DataView } from '@visactor/vdataset';
 import { LineLikeSeriesMixin } from '../mixin/line-mixin';
 import type { IAreaMark } from '../../mark/area';
 import { CartesianSeries } from '../cartesian/cartesian';
-import type { Maybe, Datum } from '../../typings';
+import type { Datum } from '../../typings';
 import type { SeriesMarkMap } from '../interface';
 import { SeriesTypeEnum } from '../interface/type';
-import type { IAreaSeriesSpec, IAreaSeriesTheme } from './interface';
+import type { IAreaSeriesSpec } from './interface';
 import type { IMark } from '../../mark/interface';
+import { AreaSeriesSpecTransformer } from './area-transformer';
 export interface AreaSeries<T extends IAreaSeriesSpec = IAreaSeriesSpec> extends Pick<LineLikeSeriesMixin, 'initLineMark' | 'initSymbolMark' | 'initLabelMarkStyle' | 'initLineMarkStyle' | 'initSymbolMarkStyle' | 'encodeDefined' | '_lineMark' | '_symbolMark' | 'addSamplingCompile' | 'addOverlapCompile' | 'reCompileSampling' | 'initLineLabelMarkStyle'>, CartesianSeries<T> {
 }
 export declare class AreaSeries<T extends IAreaSeriesSpec = IAreaSeriesSpec> extends CartesianSeries<T> {
     static readonly type: string;
     type: SeriesTypeEnum;
     static readonly mark: SeriesMarkMap;
-    protected _theme: Maybe<IAreaSeriesTheme>;
+    static readonly transformerConstructor: any;
+    readonly transformerConstructor: typeof AreaSeriesSpecTransformer;
     protected _areaMark: IAreaMark;
     protected _supportStack: boolean;
     protected _sortDataByAxis: boolean;

package/types/series/bar/bar-transformer.d.ts

@@ -0,0 +1,5 @@
+import { BaseSeriesSpecTransformer } from '../base';
+import type { IBarSeriesSpec, IBarSeriesTheme } from './interface';
+export declare class BarSeriesSpecTransformer<T extends IBarSeriesSpec = IBarSeriesSpec, K extends IBarSeriesTheme = IBarSeriesTheme> extends BaseSeriesSpecTransformer<T, K> {
+    protected _transformLabelSpec(spec: T): void;
+}

package/types/series/bar/bar.d.ts

@@ -1,8 +1,8 @@
 import { CartesianSeries } from '../cartesian/cartesian';
 import type { IMark, IMarkProgressiveConfig } from '../../mark/interface';
 import { MarkTypeEnum } from '../../mark/interface/type';
-import type { Maybe, Datum, DirectionType } from '../../typings';
-import type { IBarSeriesSpec, IBarSeriesTheme } from './interface';
+import type { Datum, DirectionType } from '../../typings';
+import type { IBarSeriesSpec } from './interface';
 import type { IAxisHelper } from '../../component/axis/cartesian/interface';
 import type { IRectMark } from '../../mark/rect';
 import type { IModelInitOption } from '../../model/interface';
@@ -11,6 +11,7 @@ import type { SeriesMarkMap } from '../interface';
 import { SeriesMarkNameEnum, SeriesTypeEnum } from '../interface/type';
 import { SeriesData } from '../base/series-data';
 import { DataView } from '@visactor/vdataset';
+import { BarSeriesSpecTransformer } from './bar-transformer';
 export declare const DefaultBandWidth = 6;
 export declare class BarSeries<T extends IBarSeriesSpec = IBarSeriesSpec> extends CartesianSeries<T> {
     static readonly type: string;
@@ -18,7 +19,8 @@ export declare class BarSeries<T extends IBarSeriesSpec = IBarSeriesSpec> extend
     protected _barMarkName: SeriesMarkNameEnum;
     protected _barMarkType: MarkTypeEnum;
     static readonly mark: SeriesMarkMap;
-    protected _theme: Maybe<IBarSeriesTheme>;
+    static readonly transformerConstructor: any;
+    readonly transformerConstructor: typeof BarSeriesSpecTransformer;
     protected _supportStack: boolean;
     protected _bandPosition: number;
     protected _barMark: IRectMark;

package/types/series/base/base-series-transformer.d.ts

@@ -0,0 +1,18 @@
+import type { IChartSpecInfo } from '../../chart/interface';
+import type { TransformedLabelSpec } from '../../component/label';
+import type { IBaseModelSpecTransformerResult } from '../../model/interface';
+import { BaseModelSpecTransformer } from '../../model/base-model-transformer';
+import type { ISeriesSpec } from '../../typings';
+import type { SeriesMarkNameEnum } from '../interface';
+import type { ISeries } from '../interface';
+export declare class BaseSeriesSpecTransformer<T extends ISeriesSpec, K> extends BaseModelSpecTransformer<T, K> {
+    markLabelSpec: Partial<Record<SeriesMarkNameEnum, TransformedLabelSpec[]>>;
+    getLabelSpec(markName: string): any;
+    setLabelSpec(markName: string, label: TransformedLabelSpec | TransformedLabelSpec[]): void;
+    addLabelSpec(markName: string, label: TransformedLabelSpec, head?: boolean): void;
+    getTheme(spec: T, chartSpec: any): K;
+    transformSpec(spec: T, chartSpec: any, chartSpecInfo?: IChartSpecInfo): IBaseModelSpecTransformerResult<T, K>;
+    protected _transformLabelSpec(spec: T): void;
+    protected _addMarkLabelSpec<V extends ISeries = ISeries>(spec: T, markName: SeriesMarkNameEnum, labelSpecKey?: keyof T, styleHandlerName?: keyof V, hasAnimation?: boolean, head?: boolean): void;
+    protected _getDefaultSpecFromChart(chartSpec: any): any;
+}