@visactor/vchart-types 0.16.17-alpha.2

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

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

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

@@ -0,0 +1,88 @@
+import type { IEvent } from '../event/interface';
+import type { IEffect, IModel, IModelInitOption, IModelOption, IModelRenderOption, IModelEvaluateOption, IModelSpec, IModelMarkInfo } 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';
+export declare abstract class BaseModel<T extends IModelSpec> extends CompilableBase implements IModel {
+    protected _spec: T;
+    getSpec(): T;
+    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;
+    protected _specIndex: number;
+    getSpecIndex(): number;
+    readonly specKey: string;
+    protected _originalSpec: any;
+    protected _option: IModelOption;
+    getOption(): IModelOption;
+    protected _marks: MarkSet;
+    getMarks(): IMark[];
+    getMarkNameMap(): Record<string, IMark>;
+    getMarkSet(): MarkSet;
+    getMarkInfoList(): IModelMarkInfo[];
+    getChart(): import("../chart/interface").IChart;
+    protected _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: any): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    protected _transformSpec(): void;
+    protected _compareSpec(): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    reInit(theme?: any): void;
+    protected _initTheme(theme?: any): void;
+    protected _getTheme(): any;
+    protected _mergeThemeToSpec(): void;
+    protected _getDefaultSpecFromChart(chartSpec: any): Partial<T>;
+    protected _shouldMergeThemeToSpec(): boolean;
+    protected _prepareSpecBeforeMergingTheme(obj?: any): any;
+    protected _prepareSpecAfterMergingTheme(obj?: any): any;
+    setCurrentTheme(noRender?: boolean): Promise<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;
+    protected _getChartLevelTheme(): import("../core/interface").IChartLevelTheme;
+}

package/types/model/interface.d.ts

@@ -0,0 +1,126 @@
+import type { IBoundsLike } from '@visactor/vutils';
+import type { DataSet } 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 } from '../chart/interface';
+import type { IChartLevelTheme } from '../core/interface';
+import type { IThemeColorScheme } from '../theme/color-scheme/interface';
+import type { ILayoutItem, ILayoutItemSpec } from '../layout/interface';
+import type { ILayoutPoint, ILayoutRect } from '../typings/layout';
+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 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: (theme?: any, lastSpec?: any) => void;
+    beforeRelease: () => void;
+    onEvaluateEnd: (ctx: IModelEvaluateOption) => void;
+    onRender: (ctx: IModelRenderOption) => void;
+    onDataUpdate: () => void;
+    updateSpec: (spec: any, totalSpec?: any) => IUpdateSpecResult;
+    getSpec?: () => any;
+    getSpecIndex: () => number;
+    onLayoutStart: (layoutRect: IRect, viewRect: ILayoutRect, ctx: IModelLayoutOption) => void;
+    onLayoutEnd: (ctx: IModelLayoutOption) => void;
+    setCurrentTheme: (noRender?: boolean) => 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;
+}
+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 {
+    eventDispatcher: IEventDispatcher;
+    dataSet: DataSet;
+    map: Map<StringOrNumber, IModel | IMark>;
+    mode: RenderMode;
+    globalInstance: VChart;
+    specIndex?: number;
+    specKey?: string;
+    getThemeConfig?: () => {
+        globalTheme?: string;
+        optionTheme?: string | ITheme;
+        specTheme?: string | ITheme;
+        chartLevelTheme: IChartLevelTheme;
+    };
+    getChartLayoutRect: () => IRect;
+    getChartViewRect: () => ILayoutRect;
+    getChart: () => IChart;
+    globalScale: IGlobalScale;
+    animation: boolean;
+    onError: (...args: any[]) => void;
+}
+export interface IModelConstructor {
+    new (ctx: IModelOption): IModel;
+}
+export type ILayoutModelState = {
+    layoutUpdateRank: number;
+    [key: string]: unknown;
+};
+export type IModelSpec = ILayoutItemSpec & {
+    id?: StringOrNumber;
+};
+export interface IModelMarkInfo {
+    type: MarkTypeEnum | string | (MarkTypeEnum | string)[];
+    name: string;
+}

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

@@ -0,0 +1,6 @@
+export interface IChartPlugin {
+}
+export interface IChartPluginConstructor {
+    readonly type: 'chartPlugin';
+    new (): IChartPlugin;
+}

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

@@ -0,0 +1,11 @@
+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;
+    constructor();
+    protected _checkEnableSync(axis: CartesianAxis): ILinearAxisSync | false;
+    private _getTargetAxis;
+    onInit(service: IComponentPluginService, axis: CartesianAxis): void;
+    onDidCompile(service: IComponentPluginService, axis: CartesianAxis): void;
+}

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

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

package/types/plugin/components/axis-sync-plugin/tick-align-transform.d.ts

@@ -0,0 +1,7 @@
+import type { Datum } from '../../../typings';
+import type { CartesianAxis } from '../../../component';
+export interface ITickAlignOpt {
+    targetAxis: () => CartesianAxis;
+    currentAxis: () => CartesianAxis;
+}
+export declare const tickAlign: (data: Array<Datum>, op: ITickAlignOpt) => Datum[];

package/types/plugin/components/axis-sync-plugin/zero-align-transform.d.ts

@@ -0,0 +1,15 @@
+import type { CartesianAxis } from '../../../component';
+import type { LinearAxisMixin } from '../../../component/axis/mixin/linear-axis-mixin';
+type ScaleInfo = {
+    total: number;
+    negative: number;
+    positive: number;
+    includeZero: boolean;
+    extendable_min: boolean;
+    extendable_max: boolean;
+    domain: number[];
+};
+export declare function isValidAlignDomain(domain: number[]): boolean;
+export declare function getScaleInfo(axis: LinearAxisMixin, domain: number[]): ScaleInfo;
+export declare const zeroAlign: (targetAxis: CartesianAxis, currentAxis: CartesianAxis) => void;
+export {};

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

@@ -0,0 +1,9 @@
+import type { IComponentPlugin, IComponentPluginService } from './interface';
+export declare class BasicComponentPlugin implements IComponentPlugin {
+    readonly id: number;
+    readonly name: string;
+    protected service?: IComponentPluginService;
+    static Name: string;
+    constructor(name?: string);
+    onAdd(service: IComponentPluginService): void;
+}

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

@@ -0,0 +1,5 @@
+import { AxisSyncPlugin } from './axis-sync-plugin/';
+declare const _default: {
+    AxisSyncPlugin: typeof AxisSyncPlugin;
+};
+export default _default;

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

@@ -0,0 +1,33 @@
+import type { IComponent } from '../../component/interface';
+type UniqueId = number;
+type MaybePromise<T> = T | PromiseLike<T>;
+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 IComponentPluginService {
+    id: UniqueId;
+    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

@@ -0,0 +1,15 @@
+import type { IComponentPlugin, IComponentPluginService } from './interface';
+import type { IComponent } from '../../component/interface';
+export declare class ComponentPluginService implements IComponentPluginService {
+    private plugins;
+    readonly id: number;
+    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/interface.d.ts

@@ -0,0 +1,4 @@
+import type { IChartPlugin, IChartPluginConstructor } from './chart/interface';
+import type { ISeriesPlugin, ISeriesPluginConstructor } from './series/interface';
+export type IPlugin = IChartPlugin | ISeriesPlugin;
+export type IPluginConstructor = IChartPluginConstructor | ISeriesPluginConstructor;

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

@@ -0,0 +1,9 @@
+import type { ISeries } from '../../series/interface';
+export interface ISeriesPlugin {
+    afterSeriesDataInit?: (series: ISeries) => void;
+    afterSeriesMarkInit?: (series: ISeries) => void;
+}
+export interface ISeriesPluginConstructor {
+    readonly type: 'seriesPlugin';
+    new (): ISeriesPlugin;
+}

package/types/region/interface.d.ts

@@ -0,0 +1,60 @@
+import type { IMark } from '../mark/interface';
+import type { ILayoutModel, IModelOption } from '../model/interface';
+import type { ISeries, SeriesType } from '../series/interface';
+import type { CoordinateType } from '../typings/coordinate';
+import type { IInteraction } from '../interaction/interface';
+import type { IProjectionSpec } from '../component/geo/interface';
+import type { ConvertToMarkStyleSpec, IRectMarkSpec } from '../typings/visual';
+import type { IAnimate } from '../animation/interface';
+import type { IGroupMark } from '../mark/group';
+import type { StringOrNumber } from '../typings';
+import type { ILayoutItemSpec } from '../layout/interface';
+export interface IRegion extends ILayoutModel {
+    animate?: IAnimate;
+    interaction: IInteraction;
+    getStackInverse: () => boolean;
+    getMaxWidth: () => number | undefined;
+    setMaxWidth: (value: number) => void;
+    getMaxHeight: () => number | undefined;
+    setMaxHeight: (value: number) => void;
+    addSeries: (series: ISeries) => void;
+    removeSeries: (series: ISeries) => void;
+    getSeries: (opt?: ISeriesFilter) => ISeries[];
+    getSeriesInName: (name: string) => ISeries;
+    getSeriesInUserId: (userId: string) => ISeries;
+    getSeriesInId: (id: number) => ISeries;
+    getSeriesInType: (type: SeriesType) => ISeries[];
+    getSeriesInCoordinateType: (type: CoordinateType) => ISeries[];
+    getSeriesInDataName: (dataName: string) => ISeries[];
+    getMarks: () => IMark[];
+    getGroupMark: () => IGroupMark;
+}
+export type ISeriesFilter = {
+    name?: string;
+    userId?: StringOrNumber | StringOrNumber[];
+    specIndex?: number | number[];
+    id?: number;
+    type?: string;
+    coordinateType?: CoordinateType;
+    dataName?: string;
+};
+export interface IRegionConstructor {
+    new (spec: IRegionSpec, ctx: IModelOption): IRegion;
+}
+export interface IRegionSpec extends ILayoutItemSpec {
+    id?: StringOrNumber;
+    coordinate?: CoordinateType;
+    style?: ConvertToMarkStyleSpec<IRectMarkSpec>;
+    stackInverse?: boolean;
+}
+export interface IGeoRegionSpec extends IRegionSpec {
+    coordinate?: 'geo';
+    roam?: boolean;
+    longitudeField?: string;
+    latitudeField?: string;
+    projection?: Partial<Omit<IProjectionSpec, 'name'>>;
+    zoomLimit?: {
+        min?: number;
+        max?: number;
+    };
+}

package/types/region/region.d.ts

@@ -0,0 +1,80 @@
+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 { 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';
+export declare class Region<T extends IRegionSpec = IRegionSpec> extends LayoutModel<T> implements IRegion {
+    static type: string;
+    readonly modelType: string;
+    type: string;
+    protected _series: ISeries[];
+    layoutType: ILayoutType;
+    layoutZIndex: number;
+    animate?: IAnimate;
+    interaction: IInteraction;
+    getMaxWidth(): number;
+    setMaxWidth(value: number): void;
+    getMaxHeight(): number;
+    setMaxHeight(value: number): void;
+    protected _groupMark: IGroupMark;
+    getGroupMark(): IGroupMark;
+    getStackInverse(): boolean;
+    protected _backgroundMark?: IRectMark;
+    protected _foregroundMark?: IRectMark;
+    protected _trigger: ITrigger;
+    constructor(spec: T, ctx: IModelOption);
+    protected _getClipDefaultValue(): boolean;
+    _initTheme(): void;
+    created(): void;
+    init(option: any): void;
+    initMark(): void;
+    protected _initBackgroundMarkStyle(): void;
+    protected _initForegroundMarkStyle(): void;
+    _compareSpec(): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    reInit(theme?: any): void;
+    addSeries(s: ISeries): void;
+    removeSeries(s: ISeries): void;
+    getSeries(opt?: {
+        name?: string;
+        userId?: StringOrNumber | StringOrNumber[];
+        specIndex?: number | number[];
+        id?: StringOrNumber;
+        type?: string;
+        coordinateType?: CoordinateType;
+        dataName?: string;
+    }): ISeries[];
+    getSeriesInName(name: string): ISeries;
+    getSeriesInUserId(userId: string): ISeries;
+    getSeriesInId(id: number): ISeries;
+    getSeriesInType(type: string): ISeries[];
+    getSeriesInCoordinateType(coordinateType: CoordinateType): ISeries[];
+    getSeriesInDataName(dataName: string): ISeries[];
+    onRender(ctx: any): void;
+    initSeriesDataflow(): void;
+    seriesDataFilterOver: () => void;
+    release(): void;
+    createTrigger(): void;
+    initTrigger(): void;
+    initInteraction(): void;
+    compileMarks(group?: string | IVGrammarGroupMark): void;
+    compile(): void;
+    getBoundsInRect: () => {
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+    };
+    onLayoutEnd(ctx: any): void;
+}

package/types/scale/color-ordinal-scale.d.ts

@@ -0,0 +1,8 @@
+import { OrdinalScale } from '@visactor/vscale';
+import type { ColorSchemeItem, ProgressiveDataScheme } from '../theme/color-scheme/interface';
+export declare class ColorOrdinalScale extends OrdinalScale {
+    protected _range: Array<ColorSchemeItem> | ProgressiveDataScheme<ColorSchemeItem>;
+    range(value?: Array<ColorSchemeItem> | ProgressiveDataScheme<ColorSchemeItem>): this | any;
+    domain(value?: any[]): this | any;
+    protected _resetRange(): void;
+}