@visactor/vchart-types 0.10.0-alpha.2

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

@@ -0,0 +1,6 @@
+import type { ICommonSpec } from '../../typings/visual';
+import { BaseMark } from '../base/base-mark';
+import type { IMarkStyle } from '../interface';
+export declare class BasePolygonMark<T extends ICommonSpec> extends BaseMark<T> {
+    protected _getDefaultStyle(): IMarkStyle<T>;
+}

package/types/mark/polygon/polygon.d.ts

@@ -0,0 +1,11 @@
+import type { IPolygonMarkSpec } from '../../typings/visual';
+import { BasePolygonMark } from './base-polygon';
+import type { IMarkRaw, IMarkStyle } from '../interface';
+import { MarkTypeEnum } from '../interface/type';
+export type IPolygonMark = IMarkRaw<IPolygonMarkSpec>;
+export declare class PolygonMark extends BasePolygonMark<IPolygonMarkSpec> implements IPolygonMark {
+    static readonly type = MarkTypeEnum.polygon;
+    readonly type = MarkTypeEnum.polygon;
+    protected _getDefaultStyle(): IMarkStyle<IPolygonMarkSpec>;
+}
+export declare const registerPolygonMark: () => void;

package/types/mark/polygon/pyramid-3d.d.ts

@@ -0,0 +1,10 @@
+import type { IPyramid3dMarkSpec } from '../../typings/visual';
+import type { IMarkRaw } from '../interface';
+import { MarkTypeEnum } from '../interface/type';
+import { BasePolygonMark } from './base-polygon';
+export type IPyramid3dMark = IMarkRaw<IPyramid3dMarkSpec>;
+export declare class Pyramid3dMark extends BasePolygonMark<IPyramid3dMarkSpec> implements IPyramid3dMark {
+    static readonly type = MarkTypeEnum.pyramid3d;
+    readonly type = MarkTypeEnum.pyramid3d;
+}
+export declare const registerPyramid3dMark: () => void;

package/types/mark/progress-arc.d.ts

@@ -0,0 +1,14 @@
+import type { StateValueType } from '../typings/spec';
+import type { ConvertToMarkStyleSpec, IProgressArcMarkSpec } from '../typings/visual';
+import type { IMarkRaw, IMarkStateStyle, IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface/type';
+import { BaseArcMark } from './arc';
+export type IProgressArcMark = IMarkRaw<IProgressArcMarkSpec>;
+export declare class ProgressArcMark extends BaseArcMark<IProgressArcMarkSpec> implements IProgressArcMark {
+    static readonly type = MarkTypeEnum.arc;
+    static readonly constructorType = MarkTypeEnum.progressArc;
+    protected _cacheStateStyle: IMarkStateStyle<IProgressArcMarkSpec>;
+    protected _getDefaultStyle(): IMarkStyle<IProgressArcMarkSpec>;
+    protected _filterStyle(style: Partial<IMarkStyle<IProgressArcMarkSpec>>, state: StateValueType, level: number, stateStyle?: IMarkStateStyle<IProgressArcMarkSpec>): Partial<ConvertToMarkStyleSpec<IProgressArcMarkSpec>> | Partial<IMarkStyle<IProgressArcMarkSpec>>;
+}
+export declare const registerProgressArcMark: () => void;

package/types/mark/rect-3d.d.ts

@@ -0,0 +1,11 @@
+import type { IRect3dMarkSpec } from '../typings/visual';
+import { BaseMark } from './base/base-mark';
+import type { IMarkRaw, IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface/type';
+export type IRect3dMark = IMarkRaw<IRect3dMarkSpec>;
+export declare class Rect3dMark extends BaseMark<IRect3dMarkSpec> implements IRect3dMark {
+    static readonly type = MarkTypeEnum.rect3d;
+    readonly type = MarkTypeEnum.rect3d;
+    protected _getDefaultStyle(): IMarkStyle<IRect3dMarkSpec>;
+}
+export declare const registerRect3dMark: () => void;

package/types/mark/rect.d.ts

@@ -0,0 +1,11 @@
+import type { IRectMarkSpec } from '../typings/visual';
+import { BaseMark } from './base/base-mark';
+import type { IMarkRaw, IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface/type';
+export type IRectMark = IMarkRaw<IRectMarkSpec>;
+export declare class RectMark extends BaseMark<IRectMarkSpec> implements IRectMark {
+    static readonly type = MarkTypeEnum.rect;
+    readonly type = MarkTypeEnum.rect;
+    protected _getDefaultStyle(): IMarkStyle<IRectMarkSpec>;
+}
+export declare const registerRectMark: () => void;

package/types/mark/ripple.d.ts

@@ -0,0 +1,13 @@
+import { BaseMark } from './base/base-mark';
+import type { IRippleMarkSpec } from '../typings/visual';
+import type { IMarkRaw, IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface/type';
+import type { IGroupMark } from '@visactor/vgrammar-core';
+export type IRippleMark = IMarkRaw<IRippleMarkSpec>;
+export declare class RippleMark extends BaseMark<IRippleMarkSpec> implements IRippleMark {
+    static readonly type = MarkTypeEnum.ripple;
+    readonly type = MarkTypeEnum.ripple;
+    protected _getDefaultStyle(): IMarkStyle<IRippleMarkSpec>;
+    protected _initProduct(group?: string | IGroupMark): void;
+}
+export declare const registerRippleMark: () => void;

package/types/mark/rule.d.ts

@@ -0,0 +1,11 @@
+import type { IRuleMarkSpec } from '../typings/visual';
+import { BaseMark } from './base/base-mark';
+import type { IMarkRaw, IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface/type';
+export type IRuleMark = IMarkRaw<IRuleMarkSpec>;
+export declare class RuleMark extends BaseMark<IRuleMarkSpec> implements IRuleMark {
+    static readonly type = MarkTypeEnum.rule;
+    readonly type = MarkTypeEnum.rule;
+    protected _getDefaultStyle(): IMarkStyle<IRuleMarkSpec>;
+}
+export declare const registerRuleMark: () => void;

package/types/mark/symbol.d.ts

@@ -0,0 +1,13 @@
+import type { ISymbolMarkSpec } from '../typings/visual';
+import { BaseMark } from './base/base-mark';
+import type { IMarkRaw, IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface/type';
+export type ISymbolMark = IMarkRaw<ISymbolMarkSpec>;
+export declare class BaseSymbolMark<T extends ISymbolMarkSpec> extends BaseMark<T> {
+    protected _getDefaultStyle(): IMarkStyle<T>;
+}
+export declare class SymbolMark extends BaseSymbolMark<ISymbolMarkSpec> implements ISymbolMark {
+    static readonly type = MarkTypeEnum.symbol;
+    readonly type = MarkTypeEnum.symbol;
+}
+export declare const registerSymbolMark: () => void;

package/types/mark/text.d.ts

@@ -0,0 +1,13 @@
+import type { ITextMarkSpec } from '../typings/visual';
+import { BaseMark } from './base/base-mark';
+import type { IMarkRaw, IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface';
+import type { IGroupMark } from '@visactor/vgrammar-core';
+export type ITextMark = IMarkRaw<ITextMarkSpec>;
+export declare class TextMark extends BaseMark<ITextMarkSpec> implements ITextMark {
+    static readonly type = MarkTypeEnum.text;
+    readonly type = MarkTypeEnum.text;
+    protected _getDefaultStyle(): IMarkStyle<ITextMarkSpec>;
+    protected _initProduct(group?: string | IGroupMark): void;
+}
+export declare const registerTextMark: () => void;

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

@@ -0,0 +1,3 @@
+import { MarkTypeEnum } from '../interface/type';
+export declare const MultiDatumMark: string[];
+export declare function isMultiDatumMark(type: MarkTypeEnum): boolean;

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

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

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

@@ -0,0 +1,25 @@
+import type { IChartSpecInfo } from '../chart/interface';
+import type { IBaseModelSpecTransformer, IBaseModelSpecTransformerOption, IModelSpec } from './interface';
+export declare class BaseModelSpecTransformer<T extends IModelSpec, K> implements IBaseModelSpecTransformer {
+    readonly type: string;
+    protected _option: IBaseModelSpecTransformerOption;
+    protected _theme?: K;
+    constructor(option: IBaseModelSpecTransformerOption);
+    protected _initTheme(spec: T, chartSpec: any): {
+        spec: T;
+        theme: K;
+    };
+    getTheme(spec: T, chartSpec: any): K;
+    transformSpec(spec: T, chartSpec: any, chartSpecInfo?: IChartSpecInfo): {
+        spec: T;
+        theme: K;
+    };
+    protected _transformSpecBeforeMergingTheme(spec: T, chartSpec: any, chartSpecInfo?: IChartSpecInfo): void;
+    protected _transformSpecAfterMergingTheme(spec: T, chartSpec: any, chartSpecInfo?: IChartSpecInfo): void;
+    protected _mergeThemeToSpec(spec: T, chartSpec: any): {
+        spec: T;
+        theme: K;
+    };
+    protected _shouldMergeThemeToSpec(): boolean;
+    protected _getDefaultSpecFromChart(chartSpec: any): Partial<T> | undefined;
+}

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

@@ -0,0 +1,81 @@
+import type { IEvent } from '../event/interface';
+import type { IEffect, IModel, IModelInitOption, IModelOption, IModelRenderOption, IModelEvaluateOption, IModelSpec, IModelMarkInfo, IModelSpecInfo } from './interface';
+import type { CoordinateType } from '../typings/coordinate';
+import type { IMark, IMarkOption, IMarkRaw, IMarkStyle } from '../mark/interface';
+import type { Datum, StateValueType, ConvertToMarkStyleSpec, ICommonSpec, StringOrNumber, IRect, ILayoutRect } from '../typings';
+import type { CompilableData } from '../compile/data/compilable-data';
+import type { IGroupMark } from '@visactor/vgrammar-core';
+import { MarkSet } from '../mark/mark-set';
+import type { ILayoutItem } from '../layout/interface';
+import { CompilableBase } from '../compile/compilable-base';
+import { BaseModelSpecTransformer } from './base-model-transformer';
+export declare abstract class BaseModel<T extends IModelSpec> extends CompilableBase implements IModel {
+    readonly transformerConstructor: typeof BaseModelSpecTransformer;
+    protected _spec: T;
+    getSpec(): T;
+    getSpecPath(): (string | number)[];
+    getSpecInfoPath(): (string | number)[];
+    readonly type: string;
+    readonly modelType: string;
+    readonly id: number;
+    userId: StringOrNumber | undefined;
+    readonly event: IEvent;
+    readonly effect: IEffect;
+    protected _data: CompilableData;
+    getData(): CompilableData;
+    protected _layout?: ILayoutItem;
+    get layout(): ILayoutItem;
+    readonly specKey: string;
+    protected _option: IModelOption;
+    getOption(): IModelOption;
+    protected _marks: MarkSet;
+    getMarks(): IMark[];
+    getMarkNameMap(): Record<string, IMark>;
+    getMarkSet(): MarkSet;
+    getMarkInfoList(): IModelMarkInfo[];
+    getChart(): import("../chart/interface").IChart;
+    protected get _theme(): any;
+    protected _lastLayoutRect: ILayoutRect;
+    constructor(spec: T, option: IModelOption);
+    coordinate?: CoordinateType;
+    protected _releaseEvent(): void;
+    created(): void;
+    init(option: IModelInitOption): void;
+    afterInit(): void;
+    getVisible(): boolean;
+    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect, ctx: any): void;
+    onLayoutEnd(ctx: any): void;
+    onEvaluateEnd(ctx: IModelEvaluateOption): void;
+    abstract onRender(ctx: IModelRenderOption): void;
+    onDataUpdate(): void;
+    beforeRelease(): void;
+    release(): void;
+    updateSpec(spec: T): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    protected _compareSpec(spec: T, prevSpec: T): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    reInit(spec?: T): void;
+    updateLayoutAttribute(): void;
+    setAttrFromSpec(): void;
+    protected _convertMarkStyle<T extends ICommonSpec = ICommonSpec>(style: Partial<IMarkStyle<T> | ConvertToMarkStyleSpec<T>>): Partial<IMarkStyle<T> | ConvertToMarkStyleSpec<T>>;
+    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;
+    protected stateKeyToSignalName(key: string, opt?: string): string;
+    compileData(): void;
+    compileMarks(group?: string | IGroupMark): void;
+    protected _createMark<T extends IMark>(markInfo: IModelMarkInfo, option?: Partial<IMarkOption>): T;
+    protected _getDataIdKey(): string | ((datum: Datum) => string) | undefined;
+    getColorScheme(): import("..").IThemeColorScheme;
+    getSpecInfo(): IModelSpecInfo<any>;
+    getSpecIndex(): number;
+}

package/types/model/index.d.ts

@@ -0,0 +1,3 @@
+export * from './base-model';
+export * from './layout-model';
+export * from './base-model-transformer';

package/types/model/interface.d.ts

@@ -0,0 +1,153 @@
+import type { IBoundsLike } from '@visactor/vutils';
+import type { DataSet, DataView } from '@visactor/vdataset';
+import type { IEvent, IEventDispatcher } from '../event/interface';
+import type { IMark, IMarkRaw, IMarkStyle, MarkTypeEnum } from '../mark/interface';
+import type { RenderMode } from '../typings/spec/common';
+import type { VChart } from '../vchart-all';
+import type { IData } from '@visactor/vgrammar-core';
+import type { StringOrNumber } from '../typings/common';
+import type { IGroupMarkSpec, ConvertToMarkStyleSpec, ICommonSpec } from '../typings/visual';
+import type { IRect } from '../typings/space';
+import type { IPoint, CoordinateType } from '../typings/coordinate';
+import type { ITheme } from '../theme';
+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, 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 {
+}
+export interface IModelEvaluateOption {
+}
+export interface IModelRenderOption {
+}
+export interface IEffect {
+    [key: string]: (e?: any) => any;
+}
+export interface IMarkTreeGroup extends Partial<IMarkStyle<IGroupMarkSpec>> {
+    type: 'group';
+    name: string;
+    marks: (IMarkTreeGroup | IMark)[];
+}
+export type IMarkTree = IMarkTreeGroup | IMark | (IMarkTreeGroup | IMark)[];
+export interface IUpdateSpecResult {
+    change: boolean;
+    reMake: boolean;
+    reRender?: boolean;
+    reSize?: boolean;
+    reCompile?: boolean;
+}
+export interface IModelProduct {
+    srData: IData;
+}
+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;
+    readonly effect: IEffect;
+    coordinate?: CoordinateType;
+    layout?: ILayoutItem;
+    getVisible: () => boolean;
+    getOption: () => IModelOption;
+    getMarks: () => IMark[];
+    getMarkNameMap: () => Record<string, IMark>;
+    getMarkInfoList: () => IModelMarkInfo[];
+    getData: () => ICompilableData;
+    getChart: () => IChart;
+    created: () => void;
+    init: (option: IModelInitOption) => void;
+    reInit: (spec?: any) => void;
+    beforeRelease: () => void;
+    onEvaluateEnd: (ctx: IModelEvaluateOption) => void;
+    onRender: (ctx: IModelRenderOption) => void;
+    onDataUpdate: () => void;
+    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;
+    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;
+    setLayoutStartPosition: (pos: Partial<IPoint>) => void;
+    getLayoutRect: () => ILayoutRect;
+    setLayoutRect: (rect: Partial<ILayoutRect>, levelMap?: Partial<ILayoutRect>) => void;
+    getLastComputeOutBounds: () => IBoundsLike;
+    getBoundsInRect: (rect: ILayoutRect, fullRect: ILayoutRect) => IBoundsLike;
+    afterSetLayoutStartPoint: (pos: ILayoutPoint) => void;
+}
+export interface IModelOption extends ICompilableInitOption {
+    type: string;
+    eventDispatcher: IEventDispatcher;
+    dataSet: DataSet;
+    map: Map<StringOrNumber, IModel | IMark>;
+    mode: RenderMode;
+    globalInstance: VChart;
+    regionIndexes?: Array<number>;
+    specKey?: string;
+    specPath?: Array<string | number>;
+    specInfoPath?: Array<string | number>;
+    getTheme?: () => ITheme;
+    getSpecInfo?: () => IChartSpecInfo;
+    getChartLayoutRect: () => IRect;
+    getChartViewRect: () => ILayoutRect;
+    getChart: () => IChart;
+    getSeriesData: (id: StringOrNumber | undefined, index: number | undefined) => DataView | undefined;
+    globalScale: IGlobalScale;
+    animation: boolean;
+    onError: (...args: any[]) => void;
+    disableTriggerEvent?: boolean;
+}
+export interface IModelSpecInfo<T extends Record<string, unknown> = any> {
+    type: string | ComponentTypeEnum | SeriesTypeEnum;
+    spec: T;
+    specPath?: Array<string | number>;
+    specInfoPath?: Array<string | number>;
+    theme?: any;
+    regionIndexes?: number[];
+    seriesIndexes?: number[];
+}
+export interface IModelConstructor {
+    readonly transformerConstructor: new (option: IBaseModelSpecTransformerOption) => IBaseModelSpecTransformer;
+}
+export type ILayoutModelState = {
+    layoutUpdateRank: number;
+    [key: string]: unknown;
+};
+export type IModelSpec = ILayoutItemSpec & {
+    id?: StringOrNumber;
+};
+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/model/layout-item.d.ts

@@ -0,0 +1,59 @@
+import type { IRect, IPoint } from '../typings';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { ILayoutItem, ILayoutItemSpec, ILayoutPoint, ILayoutRect, ILayoutRectLevel } from './interface';
+import { CompilableBase } from '../compile/compilable-base';
+export declare class LayoutItem<T extends ILayoutItemSpec = ILayoutItemSpec> extends CompilableBase implements ILayoutItem {
+    protected _spec: T;
+    getSpec(): T;
+    layoutClip: boolean;
+    protected _autoIndent: boolean;
+    getAutoIndent(): boolean;
+    private _layoutStartPoint;
+    getLayoutStartPoint(): ILayoutPoint;
+    private _layoutRect;
+    protected _minWidth: number | null;
+    protected _maxWidth: number | null;
+    protected _minHeight: number | null;
+    protected _maxHeight: number | null;
+    protected _layoutRectLevelMap: ILayoutRectLevel;
+    protected _lastComputeRect: ILayoutRect;
+    protected _lastComputeOutBounds: IBoundsLike;
+    getLastComputeOutBounds(): IBoundsLike;
+    protected _forceLayoutTag: boolean;
+    getLayoutRect: () => ILayoutRect;
+    layoutType: ILayoutItem['layoutType'];
+    layoutBindRegionID: ILayoutItem['layoutBindRegionID'];
+    _layoutOrient: ILayoutItem['layoutOrient'];
+    get layoutOrient(): ILayoutItem['layoutOrient'];
+    set layoutOrient(v: ILayoutItem['layoutOrient']);
+    layoutPaddingLeft: ILayoutItem['layoutPaddingLeft'];
+    layoutPaddingTop: ILayoutItem['layoutPaddingTop'];
+    layoutPaddingRight: ILayoutItem['layoutPaddingRight'];
+    layoutPaddingBottom: ILayoutItem['layoutPaddingBottom'];
+    layoutOffsetX: ILayoutItem['layoutOffsetX'];
+    layoutOffsetY: ILayoutItem['layoutOffsetY'];
+    layoutLevel: ILayoutItem['layoutLevel'];
+    layoutZIndex: ILayoutItem['layoutZIndex'];
+    chartLayoutRect: ILayoutRect;
+    getVisible(): boolean;
+    private _setLayoutAttributeFromSpec;
+    setAttrFromSpec(spec: ILayoutItemSpec, chartViewRect: ILayoutRect): void;
+    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect, _ctx: any): void;
+    private _getAbsoluteSpecValue;
+    absoluteLayoutInRect(layoutRect: IRect): void;
+    setLayoutStartPosition({ x, y }: Partial<IPoint>): void;
+    setLayoutRect({ width, height }: Partial<ILayoutRect>, levelMap?: Partial<ILayoutRectLevel>): void;
+    mergeLayoutRect({ width, height }: ILayoutRect): ILayoutRect;
+    getOrientPosAttribute(): "x" | "y";
+    getOrientSizeAttribute(): "width" | "height";
+    protected changeBoundsBySetting(bounds: IBoundsLike): IBoundsLike;
+    protected _setRectInSpec(rect: ILayoutRect): {
+        width: number;
+        height: number;
+    };
+    computeBoundsInRect(rect: ILayoutRect): ILayoutRect;
+    protected _boundsInRect(rect: ILayoutRect, fullSpace: ILayoutRect): IBoundsLike;
+    updateLayoutAttribute(): void;
+    compile(): void;
+    getGraphicBounds(): IBoundsLike;
+}

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

@@ -0,0 +1,41 @@
+import type { IBoundsLike } from '@visactor/vutils';
+import type { ILayoutItem } from '../layout/interface';
+import type { IOrientType, IPolarOrientType, IRect } from '../typings/space';
+import { BaseModel } from './base-model';
+import type { IModelSpec } from './interface';
+import type { IPoint } from '../typings/coordinate';
+import type { ILayoutType, ILayoutPoint, ILayoutRect } from '../typings/layout';
+export declare abstract class LayoutModel<T extends IModelSpec> extends BaseModel<T> {
+    protected layoutType: ILayoutType | 'none';
+    protected layoutLevel?: number;
+    protected layoutZIndex: number;
+    layoutClip: boolean;
+    get layoutOrient(): IOrientType;
+    set layoutOrient(v: IOrientType);
+    protected _forceLayoutTag: boolean;
+    protected _layout: ILayoutItem;
+    protected _orient?: IPolarOrientType | IOrientType;
+    protected _layoutRect: ILayoutRect;
+    protected _layoutStartPos: IPoint;
+    protected _isLayout: boolean;
+    initLayout(): void;
+    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect, ctx: any): void;
+    onLayoutEnd(ctx: any): void;
+    afterSetLayoutStartPoint(_pos: ILayoutPoint): void;
+    protected _forceLayout(): void;
+    getLayoutStartPoint(): IPoint;
+    setLayoutStartPosition(pos: Partial<IPoint>): any;
+    getLayoutRect(): ILayoutRect;
+    setLayoutRect(rect: Partial<ILayoutRect>, levelMap?: Partial<ILayoutRect>): any;
+    getLastComputeOutBounds(): IBoundsLike;
+    getGraphicBounds: () => {
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+    };
+    setAttrFromSpec(): void;
+    abstract getBoundsInRect(rect: ILayoutRect, fullRect: ILayoutRect): IBoundsLike;
+    protected _transformLayoutRect: (rect: ILayoutRect) => ILayoutRect;
+    protected _transformLayoutPosition: (rect: Partial<IPoint>) => Partial<IPoint>;
+}

package/types/model/tooltip-helper.d.ts

@@ -0,0 +1,25 @@
+import type { ITooltipActiveTypeAsKeys, ITooltipSpec } from '../component/tooltip/interface';
+import type { TooltipActiveType } from '../typings';
+import type { IModel } from './interface';
+import type { IMark } from '../mark/interface';
+export type TooltipTrigger = IModel | IMark;
+export interface ITooltipHelper {
+    spec: ITooltipSpec | undefined;
+    activeType: TooltipActiveType[];
+    activeTriggerSet: ITooltipActiveTypeAsKeys<Set<TooltipTrigger>, Set<TooltipTrigger>>;
+    ignoreTriggerSet: ITooltipActiveTypeAsKeys<Set<TooltipTrigger>, Set<TooltipTrigger>>;
+    updateTooltipSpec: () => void;
+}
+export declare abstract class BaseTooltipHelper implements ITooltipHelper {
+    spec: ITooltipSpec | undefined;
+    activeType: TooltipActiveType[];
+    activeTriggerSet: {
+        mark: Set<TooltipTrigger>;
+        dimension: Set<TooltipTrigger>;
+    };
+    ignoreTriggerSet: {
+        mark: Set<TooltipTrigger>;
+        dimension: Set<TooltipTrigger>;
+    };
+    abstract updateTooltipSpec(): void;
+}

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

@@ -0,0 +1,26 @@
+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 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,24 @@
+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 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 '../../../../typings/spec/media-query';
+export * from './common';