@visactor/vchart-types 1.6.0

package/types/model/interface.d.ts

@@ -0,0 +1,188 @@
+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 { IOrientType, IPoint, IGroupMarkSpec, ConvertToMarkStyleSpec, CoordinateType, ICommonSpec, IRect, StringOrNumber } from '../typings';
+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';
+export type ILayoutNumber = number | IPercent | ((layoutRect: ILayoutRect) => number) | IPercentOffset;
+export interface ILayoutPoint {
+    x: number;
+    y: number;
+}
+export interface ILayoutRectLevel {
+    width: number;
+    height: number;
+}
+export interface ILayoutRect {
+    width: number;
+    height: number;
+}
+export type IPercent = `${number}%`;
+export type IPercentOffset = {
+    percent?: number;
+    offset?: number;
+};
+export type ILayoutPercent = IPercent | number;
+type ILayoutType = 'region-relative' | 'region' | 'normal' | 'absolute' | 'normal-inline';
+export type ILayoutOrientPadding = {
+    left?: ILayoutNumber;
+    right?: ILayoutNumber;
+    top?: ILayoutNumber;
+    bottom?: ILayoutNumber;
+};
+export type ILayoutPaddingSpec = ILayoutOrientPadding | ILayoutNumber | ILayoutNumber[];
+export interface ILayoutItem {
+    directionStr?: 'l2r' | 'r2l' | 't2b' | 'b2t';
+    layoutClip: boolean;
+    layoutType: ILayoutType;
+    layoutBindRegionID: number | number[];
+    layoutOrient: IOrientType;
+    layoutPaddingLeft: number;
+    layoutPaddingTop: number;
+    layoutPaddingRight: number;
+    layoutPaddingBottom: number;
+    layoutOffsetX: number;
+    layoutOffsetY: number;
+    layoutLevel: number;
+    layoutZIndex: number;
+    chartLayoutRect: ILayoutRect;
+    getVisible: () => boolean;
+    getSpec?: () => any;
+    getAutoIndent: () => boolean;
+    getLayoutStartPoint: () => ILayoutPoint;
+    getLayoutRect: () => ILayoutRect;
+    getLastComputeOutBounds: () => IBoundsLike;
+    getGraphicBounds: () => IBoundsLike;
+    setLayoutRect: (rect: Partial<ILayoutRect>, levelMap?: Partial<ILayoutRectLevel>) => void;
+    computeBoundsInRect: (rect: ILayoutRect) => ILayoutRect;
+    setLayoutStartPosition: (pos: Partial<IPoint>) => void;
+    absoluteLayoutInRect: (rect: IRect) => void;
+    updateLayoutAttribute: () => void;
+}
+export interface ILayoutItemSpec {
+    layoutType?: ILayoutType;
+    layoutLevel?: number;
+    orient?: IOrientType;
+    padding?: ILayoutPaddingSpec;
+    noOuterPadding?: boolean;
+    width?: ILayoutNumber;
+    maxWidth?: ILayoutNumber;
+    minWidth?: ILayoutNumber;
+    height?: ILayoutNumber;
+    maxHeight?: ILayoutNumber;
+    minHeight?: ILayoutNumber;
+    offsetX?: ILayoutNumber;
+    offsetY?: ILayoutNumber;
+    zIndex?: number;
+    clip?: boolean;
+    left?: ILayoutNumber;
+    right?: ILayoutNumber;
+    top?: ILayoutNumber;
+    bottom?: ILayoutNumber;
+    center?: boolean;
+}
+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, ILayoutItem {
+    readonly modelType: string;
+    readonly type: string;
+    readonly specKey: string;
+    readonly id: number;
+    readonly userId?: StringOrNumber;
+    readonly event: IEvent;
+    readonly effect: IEffect;
+    coordinate?: CoordinateType;
+    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;
+    onLayoutStart: (layoutRect: IRect, viewRect: ILayoutRect, ctx: IModelLayoutOption) => void;
+    onLayoutEnd: (ctx: IModelLayoutOption) => void;
+    onEvaluateEnd: (ctx: IModelEvaluateOption) => void;
+    onRender: (ctx: IModelRenderOption) => void;
+    onDataUpdate: () => void;
+    updateSpec: (spec: any, totalSpec?: any) => IUpdateSpecResult;
+    getSpec?: () => any;
+    getSpecIndex: () => number;
+    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 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;
+}
+export {};

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/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,59 @@
+import type { IMark } from '../mark/interface';
+import type { IModel, IModelOption, ILayoutItem, ILayoutItemSpec } 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';
+export interface IRegion extends IModel, ILayoutItem {
+    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,75 @@
+import type { IGroupMark as IVGrammarGroupMark } from '@visactor/vgrammar-core';
+import { BaseModel } from '../model/base-model';
+import type { ISeries } from '../series/interface';
+import type { IModelOption, ILayoutItem } 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 { StringOrNumber } from '../typings';
+export declare class Region<T extends IRegionSpec = IRegionSpec> extends BaseModel<T> implements IRegion {
+    static type: string;
+    readonly modelType: string;
+    type: string;
+    protected _series: ISeries[];
+    layoutType: ILayoutItem['layoutType'];
+    layoutZIndex: number;
+    animate?: IAnimate;
+    interaction: IInteraction;
+    protected _maxRegionWidth?: number;
+    getMaxWidth(): number;
+    setMaxWidth(value: number): void;
+    protected _maxRegionHeight?: number;
+    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;
+}

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;
+}

package/types/scale/global-scale.d.ts

@@ -0,0 +1,37 @@
+import type { IGlobalScale } from './interface';
+import type { IBaseScale } from '@visactor/vscale';
+import type { IChart } from '../chart/interface';
+import type { IChartSpec } from '../typings/spec';
+import type { IVisualScale, IVisualSpecScale } from '../typings';
+import type { StatisticOperations } from '../data/transforms/dimension-statistics';
+export declare class GlobalScale implements IGlobalScale {
+    private _scaleSpecMap;
+    private _scaleMap;
+    private _modelScaleSpecMap;
+    private _markAttributeScaleMap;
+    private _spec;
+    private readonly _chart;
+    constructor(spec: IChartSpec['scales'], chart: IChart);
+    private _createFromSpec;
+    private _setAttrFromSpec;
+    updateSpec(spec: IChartSpec['scales']): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    registerModelScale(spec: IVisualSpecScale<unknown, unknown>): void;
+    removeModelScale(filter: (spec: IVisualSpecScale<unknown, unknown>) => boolean): void;
+    getScale(user_id: string): IBaseScale | null;
+    getScaleSpec(user_id: string): IVisualSpecScale<unknown, unknown> | null;
+    getStatisticalFields: (dataId: string) => {
+        key: string;
+        operations: StatisticOperations;
+    }[];
+    private _getSeriesByRawDataId;
+    private _getSeriesBySeriesId;
+    updateScaleDomain(defaultDomain: unknown[]): void;
+    private _updateMarkScale;
+    registerMarkAttributeScale(spec: IVisualScale, seriesId: number): IBaseScale;
+}

package/types/scale/interface.d.ts

@@ -0,0 +1,18 @@
+import type { IBaseScale } from '@visactor/vscale';
+import type { StatisticOperations } from '../data/transforms/dimension-statistics';
+import type { IChartSpec, IVisualScale, IVisualSpecScale } from '../typings';
+import type { IUpdateSpecResult } from '../model/interface';
+export interface IGlobalScale {
+    color?: any;
+    getScale: (user_id: string) => IBaseScale | null;
+    getScaleSpec: (user_id: string) => IVisualSpecScale<unknown, unknown> | null;
+    getStatisticalFields: (dataId: string) => {
+        key: string;
+        operations: StatisticOperations;
+    }[];
+    updateScaleDomain: (string: unknown[]) => void;
+    registerMarkAttributeScale: (spec: IVisualScale, seriesId: number) => IBaseScale;
+    registerModelScale: (spec: IVisualSpecScale<unknown, unknown>) => void;
+    removeModelScale: (filter: (spec: IVisualSpecScale<unknown, unknown>) => boolean) => void;
+    updateSpec: (spec: IChartSpec['scales']) => IUpdateSpecResult;
+}

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

@@ -0,0 +1,8 @@
+import type { DirectionType } from '../../typings';
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+export interface IAreaAnimationParams {
+    direction: DirectionType;
+}
+export type AreaAppearPreset = 'clipIn' | 'fadeIn' | 'grow';
+export declare function areaPresetAnimation(params: IAreaAnimationParams, preset: AreaAppearPreset | boolean): IAnimationTypeConfig;
+export declare const registerAreaAnimation: () => void;

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

@@ -0,0 +1,32 @@
+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 { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { IAreaSeriesSpec, IAreaSeriesTheme } from './interface';
+import type { IMark } from '../../mark/interface';
+export interface AreaSeries<T extends IAreaSeriesSpec = IAreaSeriesSpec> extends Pick<LineLikeSeriesMixin, 'initLineMark' | 'initSymbolMark' | 'initLabelMarkStyle' | 'initLineMarkStyle' | 'initSymbolMarkStyle' | 'encodeDefined' | '_lineMark' | '_symbolMark' | 'addSamplingCompile' | 'addOverlapCompile' | 'reCompileSampling'>, 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>;
+    protected _areaMark: IAreaMark;
+    protected _supportStack: boolean;
+    protected _sortDataByAxis: boolean;
+    setAttrFromSpec(): void;
+    initMark(): void;
+    initMarkStyle(): void;
+    initAnimation(): void;
+    protected initTooltip(): void;
+    viewDataStatisticsUpdate(d: DataView): void;
+    compile(): void;
+    getDefaultShapeType(): string;
+    getActiveMarks(): IMark[];
+    onLayoutEnd(ctx: any): void;
+    getSeriesStyle(datum: Datum): (attribute: string) => any;
+}
+export declare const registerAreaSeries: () => void;

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

@@ -0,0 +1,2 @@
+import type { SeriesMarkMap } from '../interface/common';
+export declare const areaSeriesMark: SeriesMarkMap;