@visactor/vchart-types 1.15.5-alpha.8 → 2.0.0-alpha.0

package/types/animation/animate-manager.d.ts

@@ -1,12 +1,10 @@
-import { StateManager } from '../compile/signal/state-manager';
-import type { StateValueMap } from '../compile/signal/interface';
+import { StateManager } from '../compile/state-manager';
 import type { IAnimate, IAnimateState } from './interface';
 import { AnimationStateEnum } from './interface';
+import type { StateValueMap } from '../compile/interface/compilable-item';
 export declare class AnimateManager extends StateManager implements IAnimate {
     protected _stateMap: IAnimateState & StateValueMap;
     readonly id: number;
-    protected stateKeyToSignalName: (key: string) => string;
-    getAnimationStateSignalName(): string;
     updateAnimateState(state: AnimationStateEnum, noRender?: boolean): void;
     protected _getDefaultStateMap(): IAnimateState & StateValueMap;
 }

package/types/animation/interface.d.ts

@@ -1,5 +1,6 @@
-export type { MarkAnimationSpec } from '@visactor/vgrammar-core';
+import type { ACustomAnimate, EasingType, IGraphic } from '@visactor/vrender-core';
 import type { ICompilable } from '../compile/interface';
+import type { IMark } from '../mark/interface/common';
 export declare enum AnimationStateEnum {
     appear = "appear",
     disappear = "disappear",
@@ -19,7 +20,6 @@ export interface IAnimateState {
 export interface IAnimate extends ICompilable {
     id: number;
     updateAnimateState: (state: AnimationStateEnum, noRender?: boolean) => void;
-    getAnimationStateSignalName: () => string;
 }
 export interface ICartesianGroupAnimationParams {
     direction: () => 'x' | 'y';
@@ -27,3 +27,87 @@ export interface ICartesianGroupAnimationParams {
     width: () => number;
     height: () => number;
 }
+export interface IAnimationParameters {
+    width: number;
+    height: number;
+    mark: IMark;
+    group: IMark | null;
+    elementIndex: number;
+    elementCount: number;
+    view: any;
+}
+export type IAnimationChannelInterpolator = (ratio: number, from: any, to: any, nextAttributes: any, datum: any, g: IGraphic, parameters: IAnimationParameters) => boolean | void;
+export type GraphicFunctionCallback<T> = (datum: any, g: IGraphic, params: any) => T;
+export type GraphicFunctionValueType<T> = GraphicFunctionCallback<T> | T;
+export interface IStateAnimationConfig {
+    duration?: number;
+    easing?: EasingType;
+}
+export interface IAnimationControlOptions {
+    stopWhenStateChange?: boolean;
+    immediatelyApply?: boolean;
+    ignoreLoopFinalAttributes?: boolean;
+}
+export interface CommonAnimationConfigItem {
+    custom?: IAnimationChannelInterpolator | IAnimationCustomConstructor;
+    customParameters?: GraphicFunctionValueType<any>;
+    easing?: EasingType;
+    duration?: GraphicFunctionValueType<number>;
+    delay?: GraphicFunctionValueType<number>;
+    delayAfter?: GraphicFunctionValueType<number>;
+    oneByOne?: GraphicFunctionValueType<boolean | number>;
+    startTime?: GraphicFunctionValueType<number>;
+    totalTime?: GraphicFunctionValueType<number>;
+    loop?: boolean | number;
+    options?: GraphicFunctionValueType<any>;
+    controlOptions?: IAnimationControlOptions;
+}
+export interface TypeAnimationConfig extends CommonAnimationConfigItem {
+    type: string;
+}
+export type IAnimationChannelFunction = (datum: any, g: IGraphic, mark: IMark) => any;
+export type IAnimationChannelAttrs = Record<string, {
+    from?: any | IAnimationChannelFunction;
+    to?: any | IAnimationChannelFunction;
+}>;
+export interface ChannelAnimationConfig extends CommonAnimationConfigItem {
+    channel: IAnimationChannelAttrs | string[];
+}
+export type IAnimationTypeConfig = TypeAnimationConfig | ChannelAnimationConfig | CommonAnimationConfigItem;
+export interface IAnimationCustomConstructor {
+    new (from: any, to: any, duration: number, ease: EasingType, parameters?: any): ACustomAnimate<any>;
+}
+export type IAnimationEffect = {
+    type?: string;
+    channel?: IAnimationChannelAttrs | string[];
+    custom?: IAnimationChannelInterpolator | IAnimationCustomConstructor;
+    customParameters?: GraphicFunctionValueType<any>;
+    easing?: EasingType;
+    options?: GraphicFunctionValueType<any>;
+};
+export interface IAnimationTimeSlice {
+    effects: IAnimationEffect | IAnimationEffect[];
+    duration?: GraphicFunctionValueType<number>;
+    delay?: GraphicFunctionValueType<number>;
+    delayAfter?: GraphicFunctionValueType<number>;
+}
+export interface IAnimationTimeline {
+    id?: string;
+    timeSlices: IAnimationTimeSlice | IAnimationTimeSlice[];
+    startTime?: GraphicFunctionValueType<number>;
+    totalTime?: GraphicFunctionValueType<number>;
+    oneByOne?: GraphicFunctionValueType<number | boolean>;
+    loop?: GraphicFunctionValueType<number | boolean>;
+    partitioner?: GraphicFunctionCallback<boolean>;
+    sort?: (datumA: any, datumB: any, graphicA: IGraphic, graphicB: IGraphic) => number;
+    controlOptions?: IAnimationControlOptions;
+}
+export type IAnimationConfig = IAnimationTimeline | IAnimationTypeConfig;
+export interface MarkAnimationSpec {
+    appear?: IAnimationConfig | IAnimationConfig[];
+    enter?: IAnimationConfig | IAnimationConfig[];
+    exit?: IAnimationConfig | IAnimationConfig[];
+    update?: IAnimationConfig | IAnimationConfig[];
+    normal?: IAnimationConfig | IAnimationConfig[];
+    state?: IStateAnimationConfig;
+}

package/types/animation/spec.d.ts

@@ -1,6 +1,5 @@
-import type { IAnimationConfig, IStateAnimationConfig } from '@visactor/vgrammar-core';
-import type { EasingType } from '@visactor/vrender-core';
-export type { IRunningConfig as IMorphConfig, IMorphAnimationConfig } from '@visactor/vgrammar-core';
+import type { EasingType, IGraphic } from '@visactor/vrender-core';
+import type { IAnimationConfig, IStateAnimationConfig } from './interface';
 export interface ICommonStateAnimateSpec {
     duration?: number;
     delay?: number;
@@ -25,3 +24,28 @@ export interface IMorphSeriesSpec {
     morphKey?: string;
     morphElementKey?: string;
 }
+export type MorphData = {
+    prev: any[];
+    next: any[];
+};
+export type MorphElements = {
+    prev: IGraphic[];
+    next: IGraphic[];
+};
+export type MorphFunctionCallback<T> = (datum: MorphData, element: MorphElements, parameters: any) => T;
+export type MorphFunctionType<T> = T | MorphFunctionCallback<T>;
+export type MorphFunctionValueType<T> = MorphFunctionType<T> | T;
+export interface IMorphAnimationConfig {
+    easing?: EasingType;
+    delay?: MorphFunctionValueType<number>;
+    duration?: MorphFunctionValueType<number>;
+    oneByOne?: MorphFunctionValueType<boolean | number>;
+    splitPath?: MorphFunctionValueType<'clone' | null | undefined>;
+}
+export interface IMorphConfig {
+    reuse?: boolean;
+    morph?: boolean;
+    morphAll?: boolean;
+    animation?: IMorphAnimationConfig;
+    enableExitAnimation?: boolean;
+}

package/types/animation/utils.d.ts

@@ -1,5 +1,4 @@
-import type { IAnimationConfig } from '@visactor/vgrammar-core';
-import type { MarkAnimationSpec, IAnimationState } from './interface';
+import type { MarkAnimationSpec, IAnimationState, IAnimationConfig } from './interface';
 import type { IStateAnimateSpec, IAnimationSpec } from './spec';
 import type { SeriesMarkNameEnum } from '../series/interface/type';
 import type { ISeries } from '../series';
@@ -10,9 +9,9 @@ export declare function animationConfig<Preset extends string>(defaultConfig?: M
     dataIndex: (datum: any, params: any) => number;
     dataCount: () => number;
 }): MarkAnimationSpec;
-export declare function userAnimationConfig<M extends string, Preset extends string>(markName: SeriesMarkNameEnum | string, spec: IAnimationSpec<M, Preset>, ctx: IModelMarkAttributeContext): Partial<Record<"none" | "normal" | "state" | "enter" | "exit" | "update" | "appear" | "disappear", boolean | IAnimationConfig | IAnimationConfig[] | IStateAnimateSpec<Preset>>>;
+export declare function userAnimationConfig<M extends string, Preset extends string>(markName: SeriesMarkNameEnum | string, spec: IAnimationSpec<M, Preset>, ctx: IModelMarkAttributeContext): Partial<Record<"none" | "normal" | "state" | "enter" | "update" | "exit" | "disappear" | "appear", boolean | IAnimationConfig | IAnimationConfig[] | IStateAnimateSpec<Preset>>>;
 export declare function shouldMarkDoMorph(spec: ISeriesSpec & IAnimationSpec<string, string>, markName: string): boolean;
 export declare function isTimeLineAnimation(animationConfig: IAnimationConfig): boolean;
 export declare function isChannelAnimation(animationConfig: IAnimationConfig): boolean;
-export declare function uniformAnimationConfig<Preset extends string>(config: Partial<Record<IAnimationState, boolean | IStateAnimateSpec<Preset> | IAnimationConfig | IAnimationConfig[]>>, ctx: IModelMarkAttributeContext): Partial<Record<"none" | "normal" | "state" | "enter" | "exit" | "update" | "appear" | "disappear", boolean | IAnimationConfig | IAnimationConfig[] | IStateAnimateSpec<Preset>>>;
+export declare function uniformAnimationConfig<Preset extends string>(config: Partial<Record<IAnimationState, boolean | IStateAnimateSpec<Preset> | IAnimationConfig | IAnimationConfig[]>>, ctx: IModelMarkAttributeContext): Partial<Record<"none" | "normal" | "state" | "enter" | "update" | "exit" | "disappear" | "appear", boolean | IAnimationConfig | IAnimationConfig[] | IStateAnimateSpec<Preset>>>;
 export declare function isAnimationEnabledForSeries(series: ISeries): boolean;

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

@@ -3,7 +3,7 @@ import { ChartData } from '../chart-meta/data';
 import type { Datum, IMarkStateSpec, IRegionQuerier, MaybeArray, IPadding, IRect, StringOrNumber, IChartSpec, IDataValues, ILayoutRect, ILayoutOrientPadding } from '../../typings';
 import type { ILayoutItem, LayoutCallBack } from '../../layout/interface';
 import type { ILayoutModelState, IModel, IModelOption, IModelSpecInfo, IUpdateSpecResult } from '../../model/interface';
-import type { IChart, IChartLayoutOption, IChartRenderOption, IChartOption, IChartEvaluateOption, ILayoutParams, DimensionIndexOption, IChartSpecTransformerOption, IChartSpecTransformer } from '../interface';
+import type { IChart, IChartRenderOption, IChartOption, IChartEvaluateOption, DimensionIndexOption, IChartSpecTransformerOption, IChartSpecTransformer } from '../interface';
 import type { ISeries, ISeriesConstructor } from '../../series/interface';
 import type { IRegion } from '../../region/interface';
 import type { IComponent, IComponentConstructor } from '../../component/interface';
@@ -13,9 +13,10 @@ import type { DataView } from '@visactor/vdataset';
 import type { DataSet } from '@visactor/vdataset';
 import type { IParserOptions } from '@visactor/vdataset';
 import type { IBoundsLike, Maybe } from '@visactor/vutils';
-import type { IRunningConfig as IMorphConfig, IView } from '@visactor/vgrammar-core';
 import { CompilableBase } from '../../compile/compilable-base';
 import type { IGlobalScale } from '../../scale/interface';
+import type { IMorphConfig } from '../../animation/spec';
+import type { IInteraction } from '../../interaction/interface/common';
 export declare class BaseChart<T extends IChartSpec> extends CompilableBase implements IChart {
     readonly type: string;
     readonly seriesType: string;
@@ -52,8 +53,10 @@ export declare class BaseChart<T extends IChartSpec> extends CompilableBase impl
     protected _paddingSpec: ILayoutOrientPadding;
     protected _canvasRect: ILayoutRect;
     protected _backgroundMark: IRectMark;
+    protected _interaction: IInteraction;
     constructor(spec: T, option: IChartOption);
     created(transformer: Maybe<IChartSpecTransformer>): void;
+    _initInteractions(): void;
     init(): void;
     reDataFlow(): void;
     onResize(width: number, height: number, reRender?: boolean): void;
@@ -73,9 +76,9 @@ export declare class BaseChart<T extends IChartSpec> extends CompilableBase impl
     private _createLayout;
     setLayout(layout: LayoutCallBack): void;
     private _initLayoutFunc;
-    layout(params: ILayoutParams): void;
-    onLayoutStart(option: IChartLayoutOption): void;
-    onLayoutEnd(option: IChartLayoutOption): void;
+    layout(): void;
+    onLayoutStart(): void;
+    onLayoutEnd(): void;
     onEvaluateEnd(option: IChartEvaluateOption): void;
     getLayoutElements(): ILayoutItem[];
     getRegionsInIndex: (index?: number[]) => IRegion[];
@@ -135,7 +138,7 @@ export declare class BaseChart<T extends IChartSpec> extends CompilableBase impl
     compileSeries(): void;
     compileComponents(): void;
     release(): void;
-    onLayout(srView: IView): void;
+    onLayout(): void;
     updateState(state: Record<string, Omit<IMarkStateSpec<unknown>, 'style'>>, filter?: (series: ISeries, mark: IMark, stateKey: string) => boolean): void;
     setSelected(datum: MaybeArray<any> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier): void;
     setHovered(datum: MaybeArray<Datum> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier): void;
@@ -146,7 +149,7 @@ export declare class BaseChart<T extends IChartSpec> extends CompilableBase impl
     private _initEvent;
     protected _enableMarkAnimation(states: string | string[]): void;
     protected _disableMarkAnimation(states: string | string[]): void;
-    protected _setStateInDatum(stateKey: string, checkReverse: boolean, datum: MaybeArray<Datum> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier): void;
+    protected _setStateInDatum(stateKey: string, d: MaybeArray<Datum> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier): void;
     setDimensionIndex(value: StringOrNumber, opt: DimensionIndexOption): void;
     getColorScheme(): import("../..").IThemeColorScheme;
 }

package/types/chart/funnel/util.d.ts

@@ -0,0 +1,2 @@
+import type { IMark } from '../../mark/interface';
+export declare const modifyOuterLabels: (marks: IMark[]) => void;

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

@@ -1,13 +1,12 @@
 import type { IEvent } from '../../event/interface';
 import type { LayoutCallBack } from '../../layout/interface';
-import type { IView } from '@visactor/vgrammar-core';
 import type { IParserOptions } from '@visactor/vdataset';
 import type { IComponent, IComponentConstructor } from '../../component/interface';
 import type { IMark } from '../../mark/interface';
 import type { IModel, IModelConstructor, IModelSpecInfo, IUpdateSpecResult } from '../../model/interface';
 import type { IRegion, IRegionConstructor } from '../../region/interface';
 import type { ISeries, ISeriesConstructor } from '../../series/interface';
-import type { IChartEvaluateOption, IChartLayoutOption, IChartOption, IChartRenderOption, IChartSpecInfo, IChartSpecTransformerOption, ILayoutParams } from './common';
+import type { IChartEvaluateOption, IChartLayoutOption, IChartOption, IChartRenderOption, IChartSpecInfo, IChartSpecTransformerOption } from './common';
 import type { IBoundsLike, IPadding, Maybe } from '@visactor/vutils';
 import type { ICompilable } from '../../compile/interface';
 import type { IRegionQuerier, MaybeArray, Datum, IMarkStateSpec, StringOrNumber, IShowTooltipOption, IDataValues, ILayoutRect, IData } from '../../typings';
@@ -40,7 +39,7 @@ export interface IChart extends ICompilable {
     getEvent: () => IEvent;
     getGlobalScale: () => IGlobalScale;
     setLayout: (layout: LayoutCallBack) => void;
-    layout: (context: ILayoutParams) => void;
+    layout: () => void;
     getLayoutTag: () => boolean;
     setLayoutTag: (tag: boolean, morphConfig?: IMorphConfig, renderNextTick?: boolean) => boolean;
     updateData: (id: StringOrNumber, data: unknown, updateGlobalScale?: boolean, options?: IParserOptions) => void;
@@ -53,7 +52,7 @@ export interface IChart extends ICompilable {
     onEvaluateEnd: (ctx: IChartEvaluateOption) => void;
     onRender: (ctx: IChartRenderOption) => void;
     onResize: (width: number, height: number, reRender: boolean) => void;
-    onLayout: (view: IView) => void;
+    onLayout: () => void;
     reInit: () => void;
     getAllSeries: () => ISeries[];
     getRegionsInIndex: (index?: number[]) => IRegion[];

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

@@ -1,18 +1,10 @@
 import type { LayoutCallBack } from '../../layout/interface';
 import type { IRenderOption } from '../../compile/interface';
 import type { IModelOption, IModelSpecInfo } from '../../model/interface';
-import type { IView } from '@visactor/vgrammar-core';
 import type { IBoundsLike } from '@visactor/vutils';
 import type { ISeriesSpecInfo } from '../../series/interface';
 import type { IRegionSpecInfo } from '../../region/interface';
-export interface ILayoutParams {
-    srView?: IView;
-    group?: any;
-}
-export interface IAttributeParams {
-    srView?: IView;
-    group?: any;
-}
+import type { IPerformanceHook } from '../../typings';
 export interface IChartOption extends Omit<IModelOption, 'getChartViewRect' | 'getChartLayoutRect' | 'globalScale' | 'getChart' | 'getSeriesData'> {
     container: HTMLElement | null;
     canvas?: HTMLCanvasElement | OffscreenCanvas | string;
@@ -20,6 +12,7 @@ export interface IChartOption extends Omit<IModelOption, 'getChartViewRect' | 'g
     viewBox?: IBoundsLike;
     layout?: LayoutCallBack;
     disableTriggerEvent?: boolean;
+    performanceHook?: IPerformanceHook;
 }
 export interface IChartSpecTransformerOption extends Partial<IChartOption> {
     seriesType?: string;

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

@@ -12,6 +12,6 @@ export declare class SankeyChart<T extends ISankeyChartSpec = ISankeyChartSpec>
     readonly transformerConstructor: typeof SankeyChartSpecTransformer;
     readonly type: string;
     readonly seriesType: string;
-    protected _setStateInDatum(stateKey: string, checkReverse: boolean, datum: MaybeArray<Datum> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier): void;
+    protected _setStateInDatum(stateKey: string, datum: MaybeArray<Datum> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier): void;
 }
 export declare const registerSankeyChart: () => void;

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

@@ -4,7 +4,7 @@ export declare abstract class CompilableBase implements ICompilable {
     getOption(): ICompilableInitOption;
     getCompiler: () => ICompiler;
     constructor(option: ICompilableInitOption);
-    getVGrammarView(): import("@visactor/vgrammar-core").IView;
     abstract compile(): void;
+    getStage(): import("@visactor/vrender-core").IStage;
     release(): void;
 }

package/types/compile/compiler.d.ts

@@ -1,18 +1,26 @@
-import type { InteractionSpec, IView } from '@visactor/vgrammar-core';
-import type { CompilerListenerParameters, ICompiler, ICompilerModel, IGrammarItem, IRenderContainer, IRenderOption } from './interface';
+import type { CompilerListenerParameters, ICompiler, IRenderContainer, IRenderOption } from './interface';
+import { LayoutState } from './interface';
 import type { IBoundsLike } from '@visactor/vutils';
 import type { EventSourceType } from '../event/interface';
 import type { IChart } from '../chart/interface';
-import type { IColor, IStage } from '@visactor/vrender-core';
+import type { IColor, IGroup, IStage } from '@visactor/vrender-core';
 import type { IMorphConfig } from '../animation/spec';
-import type { IVChart } from '../core/interface';
+import type { IVChart, IVChartRenderOption } from '../core/interface';
+import { type IMark } from '../mark/interface';
+import type { Gesture } from '@visactor/vrender-kits';
 type EventListener = {
     type: string;
     callback: (...args: any[]) => void;
 };
 export declare class Compiler implements ICompiler {
-    protected _view: IView;
-    getVGrammarView(): IView;
+    private _count;
+    private _cachedMarks;
+    private _progressiveMarks?;
+    private _progressiveRafId?;
+    protected _rootMarks: IMark[];
+    protected _stage: IStage;
+    protected _rootGroup: IGroup;
+    getRootGroup(): IGroup;
     protected _viewListeners: Map<(...args: any[]) => any, EventListener>;
     protected _windowListeners: Map<(...args: any[]) => any, EventListener>;
     protected _canvasListeners: Map<(...args: any[]) => any, EventListener>;
@@ -23,31 +31,34 @@ export declare class Compiler implements ICompiler {
     protected _container: IRenderContainer;
     protected _option: IRenderOption;
     private _released;
-    protected _model: ICompilerModel;
-    protected _interactions: (InteractionSpec & {
-        seriesId?: number;
-        regionId?: number;
-    })[];
-    getModel(): ICompilerModel;
+    private _layoutState?;
     private _compileChart;
     constructor(container: IRenderContainer, option: IRenderOption);
-    getRenderer(): import("@visactor/vgrammar-core").IRenderer;
     getCanvas(): HTMLCanvasElement | undefined;
+    _gestureController?: Gesture;
     getStage(): IStage | undefined;
     initView(): void;
+    getLayoutState(): LayoutState;
+    updateLayoutTag(): void;
+    protected handleLayoutEnd: () => void;
     protected handleStageRender: () => void;
     private _setCanvasStyle;
-    protected compileInteractions(): void;
     compile(ctx: {
         chart: IChart;
         vChart: IVChart;
-    }, option: any): void;
+    }, option?: IVChartRenderOption): void;
     protected clearNextRender(): boolean;
     clear(ctx: {
         chart: IChart;
         vChart: IVChart;
-    }, removeGraphicItems?: boolean): void;
+    }): void;
     renderNextTick(morphConfig?: IMorphConfig): void;
+    protected _commitedAll(): boolean;
+    protected _hasCommitedMark(): boolean;
+    private _handleAfterNextRender;
+    private _doRender;
+    renderMarks(): void;
+    reuseOrMorphing(morphConfig?: IMorphConfig): void;
     render(morphConfig?: IMorphConfig): void;
     updateViewBox(viewBox: IBoundsLike, reRender?: boolean): void;
     resize(width: number, height: number, reRender?: boolean): void;
@@ -59,15 +70,14 @@ export declare class Compiler implements ICompiler {
     protected releaseEvent(): void;
     release(): void;
     releaseGrammar(removeGraphicItems?: boolean): void;
-    protected _releaseModel(): void;
-    addGrammarItem(grammarItem: IGrammarItem): void;
-    removeGrammarItem(grammarItem: IGrammarItem, reserveVGrammarModel?: boolean): void;
-    addInteraction(interaction: InteractionSpec & {
-        seriesId?: number;
-        regionId?: number;
-    }): void;
-    removeInteraction(seriesId: number): void;
-    updateDepend(items?: IGrammarItem[]): boolean;
+    addRootMark(mark: IMark): void;
+    getRootMarks(): IMark[];
+    removeRootMark(mark: IMark): boolean;
     private _getGlobalThis;
+    private _combineIncrementalLayers;
+    private findProgressiveMarks;
+    private doPreProgressive;
+    private handleProgressiveFrame;
+    private clearProgressive;
 }
 export {};

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

@@ -1,23 +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';
+import type { ICompilableMark } from '../mark';
 export declare class CompilableData extends GrammarItem implements ICompilableData {
-    readonly grammarType = GrammarType.data;
-    protected _product: Maybe<IVGrammarData>;
-    getProduct: () => Maybe<IVGrammarData>;
+    protected _product: Maybe<any>;
+    protected _prevProduct: Maybe<any>;
+    getProduct(): any;
     protected _data: Maybe<DataView>;
     getDataView(): DataView;
     setDataView(d?: DataView): void;
     getLatestData(): any;
     constructor(option: GrammarItemInitOption, dataView?: DataView);
+    removeProduct(): void;
     release(): void;
+    protected _relatedMarks?: Record<string, ICompilableMark>;
+    addRelatedMark(mark: ICompilableMark): void;
     updateData(noRender?: boolean): void;
     protected _compileProduct(): void;
-    protected _initProduct(data: any[]): void;
     generateProductId(): string;
-    protected _lookupGrammar(id: string): IVGrammarData;
 }

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

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

package/types/compile/grammar-item.d.ts

@@ -1,24 +1,18 @@
-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';
+import type { GrammarItemCompileOption, IGrammarItem, GrammarItemInitOption, ITransformSpec } 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 _product: Maybe<any>;
+    abstract getProduct(): Maybe<any>;
     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;
+    abstract removeProduct(): void;
+    protected _transform: ITransformSpec[];
+    setTransform(transform: ITransformSpec[]): void;
+    runTransforms<T = any>(transforms: ITransformSpec[], data: T): T;
 }

package/types/compile/interface/compilable-item.d.ts

@@ -1,16 +1,17 @@
-import type { IGroupMark, IGrammarBase, IView, IRenderer, InteractionSpec } from '@visactor/vgrammar-core';
-import type { Maybe, IPerformanceHook, StringOrNumber } from '../../typings';
-import type { IColor, IStage } from '@visactor/vrender-core';
+import type { StringOrNumber } from '../../typings';
+import type { IColor, IGroup, IStage } from '@visactor/vrender-core';
 import type { IChart } from '../../chart/interface/chart';
-import type { IVChart } from '../../core/interface';
+import type { IVChart, IVChartRenderOption } from '../../core/interface';
 import type { IMorphConfig } from '../../animation/spec';
 import type { IBoundsLike } from '@visactor/vutils';
 import type { EventSourceType, EventType } from '../../event/interface';
+import type { IMark, IMarkGraphic } from '../../mark/interface';
+import type { LayoutState } from '../interface/compiler';
 export type CompilerListenerParameters = {
     type: EventType;
     event: Event;
     source: EventSourceType;
-    item: any | null;
+    item: IMarkGraphic | null;
     datum: any | null;
     markId: number | null;
     modelId: number | null;
@@ -26,15 +27,12 @@ export interface IGrammarItemMap<T extends IGrammarItem> {
 export type ICompilerModel = Record<GrammarType, IProductMap<IGrammarItem>>;
 export interface ICompiler {
     isInited?: boolean;
-    getVGrammarView: () => IView;
-    getModel: () => ICompilerModel;
-    getRenderer: () => IRenderer;
     getCanvas: () => HTMLCanvasElement | undefined;
     getStage: () => IStage | undefined;
     compile: (ctx: {
         chart: IChart;
         vChart: IVChart;
-    }, option: any) => void;
+    }, option?: IVChartRenderOption) => void;
     clear: (ctx: {
         chart: IChart;
         vChart: IVChart;
@@ -50,45 +48,41 @@ export interface ICompiler {
     removeEventListener: (source: EventSourceType, type: string, callback: (params: CompilerListenerParameters) => void) => void;
     release: () => void;
     releaseGrammar: (removeGraphicItems: boolean) => void;
-    addGrammarItem: (grammarItem: IGrammarItem) => void;
-    removeGrammarItem: (grammarItem: IGrammarItem, reserveVGrammarModel?: boolean) => void;
-    addInteraction: (interaction: InteractionSpec & {
-        seriesId?: number;
-        regionId?: number;
-    }) => void;
-    removeInteraction: (seriesId: number) => void;
-    updateDepend: (items?: IGrammarItem[]) => boolean;
+    addRootMark: (mark: IMark) => any;
+    removeRootMark: (mark: IMark) => any;
+    getRootMarks: () => IMark[];
+    updateLayoutTag: () => void;
+    getLayoutState: () => LayoutState;
+    getRootGroup: () => IGroup;
 }
 export interface ICompilable {
     getCompiler: () => ICompiler;
-    getVGrammarView: () => IView;
+    getStage: () => IStage;
     compile: () => void;
-    compileMarks?: (group?: string | IGroupMark) => void;
+    compileMarks?: (group?: IGroup) => void;
     compileData?: () => void;
-    compileSignal?: () => void;
     clear?: () => void;
     afterCompile?: () => void;
     release: () => void;
 }
 export interface ICompilableInitOption {
     getCompiler: () => ICompiler;
-    performanceHook?: IPerformanceHook;
 }
 export declare enum GrammarType {
     data = "data",
-    signal = "signal",
     mark = "mark"
 }
+export interface ITransformSpec {
+    type: string;
+    [key: string]: any;
+}
 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;
+    removeProduct: () => void;
+    setTransform: (transform: ITransformSpec[]) => void;
 }
 export type GrammarItemInitOption = ICompilableInitOption;
 export type GrammarItemCompileOption = Record<string, any>;
+export type StateValueMap = Record<string, unknown>;

package/types/compile/interface/compiler.d.ts

@@ -1,8 +1,13 @@
-import type { Hooks } from '@visactor/vgrammar-core';
-import type { IColor, IStageParams, IStage, ILayer } from '@visactor/vrender-core';
-import type { RenderMode } from '../../typings/spec/common';
+import type { IColor, IStageParams, IStage, ILayer, IOption3D } from '@visactor/vrender-core';
+import type { IPerformanceHook, RenderMode } from '../../typings/spec/common';
 import type { IBoundsLike } from '@visactor/vutils';
 import type { StringOrNumber } from '../../typings';
+export declare enum LayoutState {
+    before = "before",
+    layouting = "layouting",
+    reevaluate = "reevaluate",
+    after = "after"
+}
 export interface IRenderContainer {
     dom?: HTMLElement | 'none';
     canvas?: HTMLCanvasElement | string;
@@ -53,5 +58,9 @@ export interface IRenderOption {
     ReactDOM?: any;
     clickInterval?: number;
     autoPreventDefault?: boolean;
-    performanceHook?: Hooks;
+    performanceHook?: IPerformanceHook;
+    options3d?: {
+        enable?: boolean;
+        enableView3dTranform?: boolean;
+    } & IOption3D;
 }

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

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