@visactor/vchart 1.2.0-beta.6 → 1.2.0-beta.7

package/build/es5/chart/sunburst/index.d.ts

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

package/build/es5/chart/sunburst/interface.d.ts

@@ -0,0 +1,6 @@
+import type { ISunburstSeriesSpec } from '../../series/sunburst/interface';
+import type { IChartExtendsSeriesSpec, IChartSpec } from '../../typings/spec/common';
+export interface ISunburstChartSpec extends IChartSpec, IChartExtendsSeriesSpec<ISunburstSeriesSpec> {
+    type: 'sunburst';
+    series?: ISunburstSeriesSpec[];
+}

package/build/es5/chart/sunburst/sunburst.d.ts

@@ -0,0 +1,11 @@
+import type { ISunburstSeriesSpec } from '../../series/sunburst/interface';
+import { BaseChart } from '../base-chart';
+import type { ISunburstChartSpec } from './interface';
+export declare class SunburstChart extends BaseChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected getDefaultSeriesSpec(spec: ISunburstChartSpec): ISunburstSeriesSpec;
+    transformSpec(spec: ISunburstChartSpec): void;
+}

package/build/es5/chart/treemap/index.d.ts

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

package/build/es5/chart/treemap/interface.d.ts

@@ -0,0 +1,6 @@
+import type { ITreemapSeriesSpec } from '../../series/treemap/interface';
+import type { IChartSpec } from '../../typings/spec/common';
+export interface ITreemapChartSpec extends Omit<IChartSpec, 'data' | 'series'>, ITreemapSeriesSpec {
+    type: 'treemap';
+    series?: ITreemapSeriesSpec[];
+}

package/build/es5/chart/treemap/treemap.d.ts

@@ -0,0 +1,10 @@
+import { BaseChart } from '../base-chart';
+import type { ITreemapChartSpec } from './interface';
+export declare class TreeMapChart extends BaseChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected getDefaultSeriesSpec(spec: ITreemapChartSpec): any;
+    transformSpec(spec: any): void;
+}

package/build/es5/chart/util.d.ts

@@ -0,0 +1,2 @@
+import type { ICartesianChartSpec } from './cartesian/interface';
+export declare function setDefaultCrosshairForCartesianChart(spec: ICartesianChartSpec): void;

package/build/es5/chart/waterfall/index.d.ts

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

package/build/es5/chart/waterfall/interface.d.ts

@@ -0,0 +1,7 @@
+import type { IWaterfallSeriesSpec } from '../../series/waterfall/interface';
+import type { IChartExtendsSeriesSpec } from '../../typings/spec';
+import type { ICartesianChartSpec } from '../cartesian/interface';
+export interface IWaterfallChartSpec extends ICartesianChartSpec, IChartExtendsSeriesSpec<IWaterfallSeriesSpec> {
+    type: 'waterfall';
+    series?: IWaterfallSeriesSpec[];
+}

package/build/es5/chart/waterfall/waterfall.d.ts

@@ -0,0 +1,10 @@
+import { BarChart } from '../bar';
+import type { IWaterfallChartSpec } from './interface';
+export declare class WaterfallChart extends BarChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    transformSpec(spec: IWaterfallChartSpec): void;
+    protected _getDefaultSeriesSpec(spec: IWaterfallChartSpec): any;
+}

package/build/es5/chart/word-cloud/base.d.ts

@@ -0,0 +1,6 @@
+import { BaseChart } from '../base-chart';
+export declare class BaseWordCloudChart extends BaseChart {
+    readonly type: string;
+    readonly seriesType: string;
+    transformSpec(spec: any): void;
+}

package/build/es5/chart/word-cloud/index.d.ts

@@ -0,0 +1,3 @@
+export * from './word-cloud';
+export * from './word-cloud-3d';
+export * from './interface';

package/build/es5/chart/word-cloud/interface.d.ts

@@ -0,0 +1,10 @@
+import type { IWordCloud3dSeriesSpec, IWordCloudSeriesSpec } from '../../series/word-cloud/interface';
+import type { IChartExtendsSeriesSpec, IChartSpec } from '../../typings/spec/common';
+export interface IWordCloudChartSpec extends IChartSpec, IChartExtendsSeriesSpec<IWordCloudSeriesSpec> {
+    type: 'wordCloud';
+    series?: IWordCloudSeriesSpec[];
+}
+export interface IWordCloud3dChartSpec extends IChartSpec, IChartExtendsSeriesSpec<IWordCloud3dSeriesSpec> {
+    type: 'wordCloud3d';
+    series?: IWordCloud3dSeriesSpec[];
+}

package/build/es5/chart/word-cloud/word-cloud-3d.d.ts

@@ -0,0 +1,9 @@
+import type { IWordCloud3dChartSpec } from './interface';
+import { BaseWordCloudChart } from './base';
+export declare class WordCloud3dChart extends BaseWordCloudChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _getDefaultSeriesSpec(spec: IWordCloud3dChartSpec): any;
+}

package/build/es5/chart/word-cloud/word-cloud.d.ts

@@ -0,0 +1,9 @@
+import type { IWordCloudChartSpec } from './interface';
+import { BaseWordCloudChart } from './base';
+export declare class WordCloudChart extends BaseWordCloudChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _getDefaultSeriesSpec(spec: IWordCloudChartSpec): any;
+}

package/build/es5/compile/compilable-base.d.ts

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

package/build/es5/compile/compiler.d.ts

@@ -0,0 +1,56 @@
+import type { IView } from '@visactor/vgrammar';
+import type { CompilerListenerParameters, CompilerModel, IGrammarItem, IRenderContainer, IRenderOption } from './interface';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { EventSourceType } from '../event/interface';
+import type { IChart } from '../chart/interface';
+import type { VChart } from '../core/vchart';
+import type { Stage } from '@visactor/vrender';
+import type { IMorphConfig } from '../animation/spec';
+type EventListener = {
+    type: string;
+    callback: (...args: any[]) => void;
+};
+export declare class Compiler {
+    protected _view: IView;
+    getVGrammarView(): IView;
+    protected _viewListeners: Map<(...args: any[]) => any, EventListener>;
+    protected _windowListeners: Map<(...args: any[]) => any, EventListener>;
+    isInited: boolean;
+    isReleased: boolean;
+    protected _width: number;
+    protected _height: number;
+    protected _container: IRenderContainer;
+    protected _option: IRenderOption;
+    protected _model: CompilerModel;
+    getModel(): CompilerModel;
+    private _compileChart;
+    private _rafId;
+    constructor(container: IRenderContainer, option: IRenderOption);
+    getRenderer(): import("@visactor/vgrammar/es/types/renderer").IRenderer;
+    getCanvas(): HTMLCanvasElement | undefined;
+    getStage(): Stage | undefined;
+    initView(): void;
+    private _setCanvasStyle;
+    compile(ctx: {
+        chart: IChart;
+        vChart: VChart;
+    }, option: any): void;
+    renderAsync(morphConfig?: IMorphConfig): Promise<any>;
+    renderSync(morphConfig?: IMorphConfig): void;
+    updateViewBox(viewBox: IBoundsLike, reRender?: boolean): void;
+    resize(width: number, height: number): Promise<void>;
+    reRenderAsync(morphConfig?: IMorphConfig): Promise<void>;
+    setSize(width: number, height: number): void;
+    setViewBox(viewBox: IBoundsLike, reRender?: boolean): void;
+    addEventListener(source: EventSourceType, type: string, callback: (params: CompilerListenerParameters) => void): void;
+    removeEventListener(source: EventSourceType, type: string, callback: (params: CompilerListenerParameters) => void): void;
+    protected releaseEvent(): void;
+    release(): void;
+    releaseGrammar(): void;
+    protected _releaseModel(): void;
+    addGrammarItem(grammarItem: IGrammarItem): void;
+    removeGrammarItem(grammarItem: IGrammarItem, reserveVGrammarModel?: boolean): void;
+    updateDepend(items?: IGrammarItem[]): boolean;
+    private _getGlobalThis;
+}
+export {};

package/build/es5/compile/data/compilable-data.d.ts

@@ -0,0 +1,23 @@
+import type { DataView } from '@visactor/vdataset';
+import type { IData as IVGrammarData } from '@visactor/vgrammar';
+import { GrammarItem } from '../grammar-item';
+import type { Maybe } from '../../typings';
+import type { ICompilableData } from './interface';
+import type { GrammarItemInitOption } from '../interface';
+import { GrammarType } from '../interface';
+export declare class CompilableData extends GrammarItem implements ICompilableData {
+    readonly grammarType = GrammarType.data;
+    protected _product: Maybe<IVGrammarData>;
+    getProduct: () => Maybe<IVGrammarData>;
+    protected _data: Maybe<DataView>;
+    getDataView(): DataView;
+    setDataView(d?: DataView): void;
+    getLatestData(): any;
+    constructor(option: GrammarItemInitOption, dataView?: DataView);
+    release(): void;
+    updateData(noRender?: boolean): Promise<void>;
+    protected _compileProduct(): void;
+    protected _initProduct(data: any[]): void;
+    generateProductId(): string;
+    protected _lookupGrammar(id: string): IVGrammarData;
+}

package/build/es5/compile/data/index.d.ts

@@ -0,0 +1,2 @@
+export * from './compilable-data';
+export * from './interface';

package/build/es5/compile/data/interface.d.ts

@@ -0,0 +1,8 @@
+import type { DataView } from '@visactor/vdataset';
+import type { IGrammarItem } from '../interface';
+export interface ICompilableData extends IGrammarItem {
+    getDataView: () => DataView;
+    setDataView: (d?: DataView) => void;
+    getLatestData: () => any[];
+    updateData: (noRender?: boolean) => Promise<any>;
+}

package/build/es5/compile/grammar-item.d.ts

@@ -0,0 +1,24 @@
+import type { IGrammarBase } from '@visactor/vgrammar';
+import type { Maybe } from '../typings';
+import { CompilableBase } from './compilable-base';
+import type { GrammarItemCompileOption, GrammarType, IGrammarItem, GrammarItemInitOption } from './interface';
+export declare abstract class GrammarItem extends CompilableBase implements IGrammarItem {
+    grammarType: GrammarType;
+    protected _option: GrammarItemInitOption;
+    readonly id: number;
+    protected _product: Maybe<IGrammarBase>;
+    getProduct(): IGrammarBase;
+    protected abstract _lookupGrammar(id: string): IGrammarBase;
+    protected _compiledProductId: string;
+    abstract generateProductId(): string;
+    getProductId(): string;
+    protected _depend: IGrammarItem[];
+    getDepend(): IGrammarItem[];
+    setDepend(...depend: IGrammarItem[]): void;
+    compile(option?: GrammarItemCompileOption): void;
+    protected abstract _compileProduct(option?: GrammarItemCompileOption): void;
+    protected _afterCompile(option?: GrammarItemCompileOption): void;
+    updateDepend(): boolean;
+    release(): void;
+    removeProduct(reserveVGrammarModel?: boolean): void;
+}

package/build/es5/compile/interface/compilable-item.d.ts

@@ -0,0 +1,35 @@
+import type { IGroupMark, IGrammarBase, IView } from '@visactor/vgrammar';
+import type { Compiler } from '../compiler';
+import type { Maybe, IPerformanceHook } from '../../typings';
+export interface ICompilable {
+    getCompiler: () => Compiler;
+    getVGrammarView: () => IView;
+    compile: () => void;
+    compileMarks?: (group?: string | IGroupMark) => void;
+    compileData?: () => void;
+    compileSignal?: () => void;
+    afterCompile?: () => void;
+    release: () => void;
+}
+export interface ICompilableInitOption {
+    getCompiler: () => Compiler;
+    performanceHook?: IPerformanceHook;
+}
+export declare enum GrammarType {
+    data = "data",
+    signal = "signal",
+    mark = "mark"
+}
+export interface IGrammarItem extends ICompilable {
+    id: number;
+    grammarType: GrammarType;
+    getProduct: () => Maybe<IGrammarBase>;
+    generateProductId: () => string;
+    getProductId: () => string;
+    removeProduct: (reserveVGrammarModel?: boolean) => void;
+    getDepend: () => IGrammarItem[];
+    setDepend: (...depend: IGrammarItem[]) => void;
+    updateDepend: () => boolean;
+}
+export type GrammarItemInitOption = ICompilableInitOption;
+export type GrammarItemCompileOption = Record<string, any>;

package/build/es5/compile/interface/compiler.d.ts

@@ -0,0 +1,49 @@
+import type { IColor, IStageParams, IStage, ILayer } from '@visactor/vrender';
+import type { EventSourceType, EventType } from '../../event/interface';
+import type { RenderMode } from '../../typings/spec/common';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { GrammarType, IGrammarItem } from './compilable-item';
+import type { StringOrNumber } from '../../typings';
+export interface IRenderContainer {
+    dom?: HTMLElement | 'none';
+    canvas?: HTMLCanvasElement | string;
+}
+export interface IRenderOption {
+    mode?: RenderMode;
+    modeParams?: {
+        tooltipCanvasId?: StringOrNumber;
+        [key: string]: any;
+    } | unknown;
+    dpr?: number;
+    interactive?: boolean;
+    viewBox?: IBoundsLike;
+    canvasControled?: boolean;
+    stage?: IStage;
+    layer?: ILayer;
+    beforeRender?: IStageParams['beforeRender'];
+    afterRender?: IStageParams['afterRender'];
+    background?: IColor;
+    logLevel?: number;
+    onError?: (...args: any[]) => void;
+    disableDirtyBounds?: boolean;
+    enableView3dTransform?: boolean;
+    pluginList?: string[];
+}
+export type CompilerListenerParameters = {
+    type: EventType;
+    event: Event;
+    source: EventSourceType;
+    item: any | null;
+    datum: any | null;
+    markId: number | null;
+    modelId: number | null;
+    markUserId: StringOrNumber | null;
+    modelUserId: StringOrNumber | null;
+};
+export type CompilerModel = Record<GrammarType, IProductMap<IGrammarItem>>;
+export interface IProductMap<T extends IGrammarItem> {
+    [productId: string]: IGrammarItemMap<T>;
+}
+export interface IGrammarItemMap<T extends IGrammarItem> {
+    [id: number]: T;
+}

package/build/es5/compile/interface/index.d.ts

@@ -0,0 +1,2 @@
+export * from './compilable-item';
+export * from './compiler';

package/build/es5/compile/mark/compilable-mark.d.ts

@@ -0,0 +1,104 @@
+import type { IGroupMark, IMark, MarkAnimationSpec, MarkFunctionCallback, Nil, TransformSpec } from '@visactor/vgrammar';
+import type { DataView } from '@visactor/vdataset';
+import { GrammarItem } from '../grammar-item';
+import type { Maybe, StringOrNumber } from '../../typings';
+import type { IMarkProgressiveConfig, IMarkStateStyle, MarkType } from '../../mark/interface';
+import type { IModel } from '../../model/interface';
+import { MarkStateManager } from './mark-state-manager';
+import type { ICompilableMark, IMarkDataInitOption, ICompilableMarkOption, StateValueType, IMarkCompileOption, IAttributeOpt } from './interface';
+import { MarkData } from './mark-data';
+import { GrammarType } from '../interface';
+import type { IEvent } from '../../event/interface';
+import type { ILabelSpec } from '../../component/label';
+export declare abstract class CompilableMark extends GrammarItem implements ICompilableMark {
+    readonly grammarType = GrammarType.mark;
+    readonly type: MarkType;
+    readonly name: string;
+    readonly key: ICompilableMark['key'];
+    protected _support3d?: boolean;
+    getSupport3d(): boolean;
+    setSupport3d(support3d: boolean): void;
+    protected _facet?: string;
+    getFacet(): string;
+    setFacet(facet: string): void;
+    protected _interactive: boolean;
+    getInteractive(): boolean;
+    setInteractive(interactive: boolean): void;
+    protected _zIndex: number;
+    getZIndex(): number;
+    setZIndex(zIndex: number): void;
+    protected _visible: boolean;
+    getVisible(): boolean;
+    setVisible(visible: boolean): void;
+    protected _userId: StringOrNumber;
+    getUserId(): StringOrNumber;
+    setUserId(userId: StringOrNumber): void;
+    readonly model: IModel;
+    protected _data: Maybe<MarkData>;
+    getDataView(): DataView | undefined;
+    setDataView(d?: DataView, productId?: string): void;
+    getData(): MarkData;
+    setData(d?: MarkData): void;
+    stateStyle: IMarkStateStyle<any>;
+    state: MarkStateManager;
+    protected _unCompileChannel: {
+        [key in string]: boolean;
+    };
+    hasState(state: string): boolean;
+    getState(state: string): unknown;
+    protected _event: IEvent;
+    protected _animationConfig: Partial<MarkAnimationSpec>;
+    getAnimationConfig(): Partial<MarkAnimationSpec>;
+    setAnimationConfig(config: Partial<MarkAnimationSpec>): void;
+    private _skipBeforeLayouted;
+    setSkipBeforeLayouted(skip: boolean): void;
+    getSkipBeforeLayouted(): boolean;
+    protected _morph: boolean;
+    getMorph(): boolean;
+    setMorph(morph: boolean): void;
+    protected _morphKey?: string;
+    getMorphKey(): string;
+    setMorphKey(morphKey: string): void;
+    protected _morphElementKey?: string;
+    getMorphElementKey(): string;
+    setMorphElementKey(key: string): void;
+    protected _groupKey?: string;
+    getGroupKey(): string;
+    setGroupKey(groupKey: string): void;
+    protected _label?: ILabelSpec;
+    getLabelSpec(): ILabelSpec;
+    setLabelSpec(label: ILabelSpec): void;
+    protected _progressiveConfig: IMarkProgressiveConfig;
+    getProgressiveConfig(): IMarkProgressiveConfig;
+    setProgressiveConfig(config: IMarkProgressiveConfig): void;
+    protected _option: ICompilableMarkOption;
+    constructor(option: ICompilableMarkOption, name: string, model: IModel);
+    protected _product: Maybe<IMark>;
+    getProduct: () => Maybe<IMark>;
+    protected _transform: TransformSpec[] | Nil;
+    setTransform(transform: TransformSpec[] | Nil): void;
+    protected initMarkData(option: IMarkDataInitOption): void;
+    protected stateKeyToSignalName(key: string): string;
+    getAttribute(key: any, datum: any, state: StateValueType, opt?: IAttributeOpt): void;
+    protected _compileProduct(option?: IMarkCompileOption): void;
+    protected _initProduct(group?: string | IGroupMark): void;
+    generateProductId(): string;
+    compileData(): void;
+    compileEncode(): void;
+    compileState(): void;
+    compileAnimation(): void;
+    compileContext(): void;
+    compileSignal(): void;
+    protected compileCommonAttributeCallback(key: string, state: string): MarkFunctionCallback<any>;
+    protected compileTransform(): void;
+    protected _lookupGrammar(id: string): IMark;
+    updateState(newState: Record<string, unknown>, noRender?: boolean): Promise<void>;
+    updateLayoutState(noRender?: boolean, recursion?: boolean): Promise<void>;
+    updateMarkState(key: string): void;
+    getMarks(): ICompilableMark[];
+    runAnimationByState(state?: string): import("@visactor/vgrammar").IAnimateArranger;
+    stopAnimationByState(state?: string): import("@visactor/vgrammar").IAnimate;
+    pauseAnimationByState(state?: string): import("@visactor/vgrammar").IAnimate;
+    resumeAnimationByState(state?: string): import("@visactor/vgrammar").IAnimate;
+    release(): void;
+}

package/build/es5/compile/mark/index.d.ts

@@ -0,0 +1,3 @@
+export * from './interface';
+export * from './compilable-mark';
+export * from './mark-state-manager';

package/build/es5/compile/mark/interface.d.ts

@@ -0,0 +1,149 @@
+import type { IMarkProgressiveConfig, IMarkStateStyle, MarkType } from '../../mark/interface';
+import type { IModel } from '../../model/interface';
+import type { GrammarItemCompileOption, GrammarItemInitOption } from '../interface';
+import type { IGrammarItem } from '../interface';
+import type { MarkStateManager } from './mark-state-manager';
+import type { DataView } from '@visactor/vdataset';
+import type { IAnimate, IAnimateArranger, IElement, IGroupMark, IMark, MarkAnimationSpec, Nil, TransformSpec } from '@visactor/vgrammar';
+import type { Maybe, Datum, StringOrNumber } from '../../typings';
+import type { MarkData } from './mark-data';
+import type { ILabelSpec } from '../../component/label';
+export interface ICompilableMarkOption extends GrammarItemInitOption {
+    key?: string | ((datum: Datum) => string);
+    groupKey?: string;
+    skipBeforeLayouted?: boolean;
+    support3d?: boolean;
+    mode?: '2d' | '3d';
+}
+export interface ICompilableMark extends IGrammarItem {
+    readonly type: MarkType;
+    readonly id: number;
+    readonly name: string;
+    readonly key?: string | ((datum: Datum) => string);
+    readonly model: IModel;
+    getData: () => MarkData | undefined;
+    setData: (d: MarkData) => void;
+    getDataView: () => DataView | undefined;
+    setDataView: (d?: DataView, productId?: string) => void;
+    getFacet: () => string | undefined;
+    setFacet: (facet: string) => void;
+    getLabelSpec: () => ILabelSpec;
+    setLabelSpec: (label: ILabelSpec) => void;
+    state: MarkStateManager;
+    readonly stateStyle: IMarkStateStyle<any>;
+    hasState: (state: string) => boolean;
+    getState: (state: string) => any;
+    updateState: (newState: Record<string, unknown>) => Promise<void>;
+    updateLayoutState: (noRender?: boolean, recursion?: boolean) => Promise<void>;
+    updateMarkState: (key: string) => void;
+    setTransform: (transform: TransformSpec[] | Nil) => void;
+    getInteractive: () => boolean;
+    setInteractive: (interactive: boolean) => void;
+    setAnimationConfig: (config: Partial<MarkAnimationSpec>) => void;
+    getAnimationConfig: () => Partial<MarkAnimationSpec>;
+    getZIndex: () => number;
+    setZIndex: (zIndex: number) => void;
+    getVisible: () => boolean;
+    setVisible: (visible: boolean) => void;
+    getMorph: () => boolean;
+    setMorph: (morph: boolean) => void;
+    getProgressiveConfig: () => IMarkProgressiveConfig;
+    setProgressiveConfig: (config: IMarkProgressiveConfig) => void;
+    getMorphKey: () => string | undefined;
+    setMorphKey: (morphKey: string) => void;
+    getMorphElementKey: () => string | undefined;
+    setMorphElementKey: (morphKey: string) => void;
+    getGroupKey: () => string | undefined;
+    setGroupKey: (groupKey: string) => void;
+    getUserId: () => StringOrNumber | undefined;
+    setUserId: (id: StringOrNumber) => void;
+    compile: (option?: IMarkCompileOption) => void;
+    getProduct: () => Maybe<IMark>;
+    getMarks: () => ICompilableMark[];
+    setSkipBeforeLayouted: (skip: boolean) => void;
+    getSkipBeforeLayouted: () => boolean;
+    runAnimationByState: (animationState?: string) => IAnimateArranger;
+    stopAnimationByState: (animationState?: string) => IAnimate;
+    pauseAnimationByState: (animationState: string) => IAnimate;
+    resumeAnimationByState: (animationState: string) => IAnimate;
+}
+export interface IMarkDataInitOption extends ICompilableMarkOption {
+    mark: ICompilableMark;
+}
+export interface IMarkCompileOption extends GrammarItemCompileOption {
+    group?: string | IGroupMark;
+    ignoreChildren?: boolean;
+}
+export interface IStateInfo {
+    stateValue: StateValue;
+    fields?: any | null | undefined;
+    datums?: any[] | null | undefined;
+    datumKeys?: string[] | null | undefined;
+    items?: any[] | null | undefined;
+    filter?: ((datum: any, options: Record<string, any>) => boolean) | null | undefined;
+    cache?: {
+        [key: string]: {
+            [key: string]: boolean;
+        };
+    };
+    level?: number | undefined;
+}
+export interface IStateSpec {
+    stateValue: StateValue;
+    datums?: any[] | null | undefined;
+    datumKeys?: string[] | null | undefined;
+    level?: number | undefined;
+}
+export interface IMarkState {
+    readonly id: number;
+    getStates: () => IStateInfo[];
+    getState: (stateValue: StateValue) => IStateInfo | undefined;
+    addState: (stateInfo: IStateInfo) => void;
+    changeState: (stateInfo: Partial<IStateInfo>, update?: boolean) => void;
+    checkState: (item: any, datum: any) => string[];
+    clearState: (stateValues: StateValue[], update?: boolean) => void;
+    update: () => void;
+}
+export declare enum STATE_VALUE_ENUM {
+    STATE_NORMAL = "normal",
+    STATE_HOVER = "hover",
+    STATE_HOVER_REVERSE = "hover_reverse",
+    STATE_DIMENSION_HOVER = "dimension_hover",
+    STATE_DIMENSION_HOVER_REVERSE = "dimension_hover_reverse",
+    STATE_SELECTED = "selected",
+    STATE_SELECTED_REVERSE = "selected_reverse"
+}
+export declare enum STATE_VALUE_ENUM_REVERSE {
+    STATE_HOVER_REVERSE = "hover_reverse",
+    STATE_DIMENSION_HOVER_REVERSE = "dimension_hover_reverse",
+    STATE_SELECTED_REVERSE = "selected_reverse"
+}
+export type STATE_NORMAL = typeof STATE_VALUE_ENUM.STATE_NORMAL;
+export type STATE_HOVER = typeof STATE_VALUE_ENUM.STATE_HOVER;
+export type STATE_HOVER_REVERSE = typeof STATE_VALUE_ENUM.STATE_HOVER_REVERSE;
+export type STATE_CUSTOM = string;
+export type StateValueNot = STATE_HOVER_REVERSE | STATE_CUSTOM;
+export type StateValue = STATE_NORMAL | STATE_HOVER | STATE_CUSTOM;
+export type StateValueType = StateValue | StateValueNot;
+export declare enum STATE_LEVEL {
+    NORMAL = 0,
+    DIMENSION_SELECTED = 1,
+    RELATIONAL_SELECTED = 2,
+    SELECTED = 3,
+    DIMENSION_HOVER = 4,
+    RELATIONAL_HOVER = 5,
+    HOVER = 6
+}
+export interface IAttributeOpt {
+    element: IElement;
+    mark: IElement['mark'];
+    parent: IElement['mark']['group'];
+    states: string[];
+}
+export interface IModelMarkAttributeContext {
+    [key: string]: unknown;
+}
+export interface ISeriesMarkAttributeContext extends IModelMarkAttributeContext {
+    globalScale: (scaleKey: string, value: string | number) => unknown;
+    seriesColor: (seriesValue?: string | number) => string;
+}

package/build/es5/compile/mark/mark-data.d.ts

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

package/build/es5/compile/mark/mark-state-manager.d.ts

@@ -0,0 +1,26 @@
+import type { IElement, IMark as IVGrammarMark } from '@visactor/vgrammar';
+import type { Datum, StringOrNumber } from '../../typings';
+import type { IStateManagerOption } from '../signal/interface';
+import { StateManager } from '../signal/state-manager';
+import type { CompilableMark } from './compilable-mark';
+import type { IStateInfo, StateValue } from './interface';
+export declare class MarkStateManager extends StateManager {
+    protected _mark: CompilableMark;
+    private _stateInfoList;
+    getStateInfoList(): IStateInfo[];
+    constructor(option: IStateManagerOption, mark: CompilableMark);
+    protected _getDefaultStateMap(): Record<string, unknown>;
+    getStateInfo(stateValue: StateValue): IStateInfo;
+    addStateInfo(stateInfo: IStateInfo): void;
+    private _clearStateBeforeSet;
+    changeStateInfo(stateInfo: Partial<IStateInfo>): void;
+    clearStateInfo(stateValues: StateValue[]): void;
+    checkOneState(renderNode: IElement, datum: Datum | Datum[], state: IStateInfo, isMultiMark?: boolean): 'in' | 'out' | 'skip';
+    checkState(renderNode: IElement, datum: Datum | Datum[]): StateValue[];
+    checkDatumState(state: IStateInfo, datum: Datum | Datum[], isMultiMark: boolean): boolean;
+    checkItemsState(state: IStateInfo, item: any): boolean | undefined;
+    checkFieldsState(state: IStateInfo, datum: Datum | Datum[], item: any, isMultiMark: boolean): boolean;
+    checkLinearFieldState(domain: StringOrNumber[], key: string, datum: any, item: any, isMultiMark: boolean): boolean;
+    updateLayoutState(noRender?: boolean): Promise<void>;
+    compileState(product: IVGrammarMark): void;
+}

package/build/es5/compile/mark/util.d.ts

@@ -0,0 +1,6 @@
+import type { IAttrs, IMarkStateStyle, MarkType } from '../../mark/interface';
+export declare function isAttrChangeable<T>(key: string, stateStyle: IMarkStateStyle<T>): boolean;
+export declare function isStateAttrChangeable<T>(key: string, stateStyle: Partial<IAttrs<T>>): boolean;
+export declare function attrTransform(type: MarkType, attr: string, value: any): any;
+export declare function stateInDefaultEnum(state: string): boolean;
+export declare function stateToReverse(state: string): any;