@visactor/vchart-types 1.6.0-beta.0

package/types/chart/sankey/sankey.d.ts

@@ -0,0 +1,11 @@
+import { BaseChart } from '../base-chart';
+import type { ISankeyChartSpec } from './interface';
+export declare class SankeyChart extends BaseChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected getDefaultSeriesSpec(spec: ISankeyChartSpec): any;
+    transformSpec(spec: any): void;
+}
+export declare const registerSankeyChart: () => void;

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

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

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

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

package/types/chart/scatter/scatter.d.ts

@@ -0,0 +1,11 @@
+import { CartesianChart } from '../cartesian/cartesian';
+import type { IScatterChartSpec } from './interface';
+export declare class ScatterChart extends CartesianChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    readonly seriesType: string;
+    protected _canStack: boolean;
+    protected _getDefaultSeriesSpec(spec: IScatterChartSpec): any;
+}
+export declare const registerScatterChart: () => void;

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

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

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

@@ -0,0 +1,24 @@
+import type { IChartSpec, ISeriesSpec } from '../../typings/spec/common';
+import type { ICartesianAxisSpec } from '../../component/axis/cartesian/interface';
+import type { IDataZoomSpec, IScrollBarSpec } from '../../component/data-zoom';
+import type { ICartesianCrosshairSpec } from '../../component/crosshair/interface';
+import type { ILayoutSpec } from '../../layout/interface';
+import type { IRegionSpec } from '../../region/interface';
+import type { IPadding } from '../../typings';
+export interface ISequenceChartSpec extends IChartSpec {
+    type: 'sequence';
+    appendPadding?: IPadding;
+    axes?: ICartesianAxisSpec[];
+    dataZooms?: IDataZoomSpec[];
+    scrollBars?: IScrollBarSpec[];
+    crosshair?: ICartesianCrosshairSpec | ICartesianCrosshairSpec[];
+    layout?: ILayoutSpec;
+    region?: IRegionSpec[];
+}
+export interface ISequenceSeriesSpec extends ISeriesSpec {
+    height?: number;
+    padding?: number;
+    dataDot?: any;
+    dotSeriesIndex?: number;
+    dotSeriesSpec?: ISeriesSpec;
+}

package/types/chart/sequence/sequence.d.ts

@@ -0,0 +1,12 @@
+import { BaseChart } from '../base-chart';
+import type { ISequenceChartSpec, ISequenceSeriesSpec } from './interface';
+export declare class SequenceChart extends BaseChart {
+    static readonly type: string;
+    static readonly view: string;
+    readonly type: string;
+    transformSpec(spec: ISequenceChartSpec): void;
+    createSeries(seriesSpec: ISequenceSeriesSpec[]): void;
+    addAttrToComponentSpec(componentSpec: any, attr: string, value: any): any;
+    private _getSeriesDataLength;
+}
+export declare const registerSequenceChart: () => void;

package/types/chart/stack.d.ts

@@ -0,0 +1,11 @@
+import type { IRegion } from '../region/interface';
+import type { IChart } from './interface';
+export declare class Stack {
+    protected _chart: IChart;
+    constructor(chart: IChart);
+    init(): void;
+    stackAll(): void;
+    stackRegion: ({ model }: {
+        model: IRegion;
+    }) => void;
+}

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

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

package/types/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/types/chart/sunburst/sunburst.d.ts

@@ -0,0 +1,12 @@
+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;
+}
+export declare const registerSunburstChart: () => void;

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

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

package/types/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/types/chart/treemap/treemap.d.ts

@@ -0,0 +1,11 @@
+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;
+}
+export declare const registerTreemapChart: () => void;

package/types/chart/util.d.ts

@@ -0,0 +1,12 @@
+import type { ICartesianChartSpec } from './cartesian/interface';
+import type { IChartOption } from './interface/common';
+import type { IUpdateSpecResult } from '../model/interface';
+export declare function setDefaultCrosshairForCartesianChart(spec: ICartesianChartSpec): void;
+export declare function calculateChartSize(spec: {
+    width: number;
+    height: number;
+}, option: Pick<IChartOption, 'canvas' | 'container' | 'mode' | 'modeParams'>): {
+    width: number;
+    height: number;
+};
+export declare function mergeUpdateResult(resultA: IUpdateSpecResult, resultB: IUpdateSpecResult): IUpdateSpecResult;

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

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

package/types/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/types/chart/waterfall/waterfall.d.ts

@@ -0,0 +1,11 @@
+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;
+}
+export declare const registerWaterfallChart: () => void;

package/types/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/types/chart/word-cloud/index.d.ts

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

package/types/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/types/chart/word-cloud/word-cloud-3d.d.ts

@@ -0,0 +1,11 @@
+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;
+}
+export declare const registerWordCloud3dChart: () => void;
+export declare const registerWordCloudShape3dChart: () => void;

package/types/chart/word-cloud/word-cloud.d.ts

@@ -0,0 +1,11 @@
+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;
+}
+export declare const registerWordCloudChart: () => void;
+export declare const registerWordCloudShapeChart: () => void;

package/types/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-core").IView;
+    abstract compile(): void;
+    release(): void;
+}

package/types/compile/compiler.d.ts

@@ -0,0 +1,60 @@
+import type { IView } from '@visactor/vgrammar-core';
+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 { IColor, Stage } from '@visactor/vrender-core';
+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>;
+    protected _canvasListeners: 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;
+    constructor(container: IRenderContainer, option: IRenderOption);
+    getRenderer(): import("@visactor/vgrammar-core").IRenderer;
+    getCanvas(): HTMLCanvasElement | undefined;
+    getStage(): Stage | undefined;
+    initView(): void;
+    private _setCanvasStyle;
+    compile(ctx: {
+        chart: IChart;
+        vChart: VChart;
+    }, option: any): void;
+    clear(ctx: {
+        chart: IChart;
+        vChart: VChart;
+    }): void;
+    renderAsync(morphConfig?: IMorphConfig): Promise<any>;
+    renderSync(morphConfig?: IMorphConfig): void;
+    updateViewBox(viewBox: IBoundsLike, reRender?: boolean): void;
+    resize(width: number, height: number, reRender?: boolean): this | Promise<any>;
+    setBackground(color: IColor): 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/types/compile/data/compilable-data.d.ts

@@ -0,0 +1,23 @@
+import type { DataView } from '@visactor/vdataset';
+import type { IData as IVGrammarData } from '@visactor/vgrammar-core';
+import { GrammarItem } from '../grammar-item';
+import type { Maybe } from '../../typings';
+import type { ICompilableData } from './interface';
+import type { GrammarItemInitOption } from '../interface';
+import { GrammarType } from '../interface/compilable-item';
+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<any>;
+    protected _compileProduct(): void;
+    protected _initProduct(data: any[]): void;
+    generateProductId(): string;
+    protected _lookupGrammar(id: string): IVGrammarData;
+}

package/types/compile/data/index.d.ts

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

package/types/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/types/compile/grammar-item.d.ts

@@ -0,0 +1,24 @@
+import type { IGrammarBase } from '@visactor/vgrammar-core';
+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/types/compile/interface/compilable-item.d.ts

@@ -0,0 +1,36 @@
+import type { IGroupMark, IGrammarBase, IView } from '@visactor/vgrammar-core';
+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;
+    clear?: () => 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/types/compile/interface/compiler.d.ts

@@ -0,0 +1,49 @@
+import type { IColor, IStageParams, IStage, ILayer } from '@visactor/vrender-core';
+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/types/compile/interface/index.d.ts

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

package/types/compile/mark/compilable-mark.d.ts

@@ -0,0 +1,111 @@
+import type { IGroupMark, IMark, MarkAnimationSpec, MarkFunctionCallback, Nil, TransformSpec } from '@visactor/vgrammar-core';
+import type { DataView } from '@visactor/vdataset';
+import { GrammarItem } from '../grammar-item';
+import type { Maybe, Datum, 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/compilable-item';
+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 | ILabelSpec[]): void;
+    addLabelSpec(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;
+    updateStaticEncode(): void;
+    protected _separateStyle(): {
+        enterStyles: Record<string, any>;
+        updateStyles: Record<string, any>;
+    };
+    compileEncode(): void;
+    compileState(): void;
+    compileAnimation(): void;
+    compileContext(): void;
+    compileSignal(): void;
+    protected _computeAttribute(key: string, state: StateValueType): (datum: Datum, opt: IAttributeOpt) => any;
+    protected compileCommonAttributeCallback(key: string, state: string): MarkFunctionCallback<any>;
+    protected compileTransform(): void;
+    protected _lookupGrammar(id: string): IMark;
+    updateState(newState: Record<string, unknown>, noRender?: boolean): Promise<any>;
+    updateLayoutState(noRender?: boolean, recursion?: boolean): Promise<void>;
+    updateMarkState(key: string): void;
+    getMarks(): ICompilableMark[];
+    runAnimationByState(state?: string): import("@visactor/vgrammar-core").IAnimateArranger;
+    stopAnimationByState(state?: string): import("@visactor/vgrammar-core").IAnimate;
+    pauseAnimationByState(state?: string): import("@visactor/vgrammar-core").IAnimate;
+    resumeAnimationByState(state?: string): import("@visactor/vgrammar-core").IAnimate;
+    release(): void;
+}

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

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