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

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

@@ -1,19 +1,19 @@
 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 { IModel, IModelConstructor, IModelOption, 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';
 import type { DataView } from '@visactor/vdataset';
 import type { IGlobalScale } from '../../scale/interface';
 import type { IMorphConfig } from '../../animation/spec';
+import type { IMarkGraphic } from '../../mark/interface/common';
 export type DimensionIndexOption = {
     filter?: (cmp: IComponent) => boolean;
     tooltip?: boolean;
@@ -37,12 +37,14 @@ export interface IChart extends ICompilable {
     getCanvasRect: () => ILayoutRect;
     getViewRect: () => ILayoutRect;
     getOption: () => IChartOption;
+    getModelOption: () => IModelOption;
     getEvent: () => IEvent;
     getGlobalScale: () => IGlobalScale;
     setLayout: (layout: LayoutCallBack) => void;
-    layout: (context: ILayoutParams) => void;
+    layout: () => void;
     getLayoutTag: () => boolean;
     setLayoutTag: (tag: boolean, morphConfig?: IMorphConfig, renderNextTick?: boolean) => boolean;
+    resetLayoutItemTag: () => void;
     updateData: (id: StringOrNumber, data: unknown, updateGlobalScale?: boolean, options?: IParserOptions) => void;
     updateFullData: (data: IDataValues | IDataValues[]) => void;
     updateGlobalScaleDomain: () => void;
@@ -53,7 +55,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[];
@@ -93,6 +95,13 @@ export interface IChart extends ICompilable {
     setCurrentTheme: () => void;
     getSeriesData: (id: StringOrNumber | undefined, index: number | undefined) => DataView | undefined;
     setDimensionIndex: (value: StringOrNumber, opt: DimensionIndexOption) => void;
+    filterGraphicsByDatum: (datum: MaybeArray<Datum> | null, opt?: {
+        filter?: (series: ISeries, mark: IMark) => boolean;
+        region?: IRegionQuerier;
+        getDatum?: (el: IMarkGraphic, mark: IMark, s: ISeries, r: IRegion) => Datum;
+        callback?: (el: IMarkGraphic, mark: IMark, s: ISeries, r: IRegion) => void;
+        regionCallback?: (pickElements: IMarkGraphic[], r: IRegion) => void;
+    }) => IMarkGraphic[];
 }
 export interface IChartSpecTransformer {
     readonly type: string;

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

@@ -4,15 +4,11 @@ export declare const enum ChartTypeEnum {
     area = "area",
     line = "line",
     bar = "bar",
-    bar3d = "bar3d",
     histogram = "histogram",
-    histogram3d = "histogram3d",
     rangeColumn = "rangeColumn",
-    rangeColumn3d = "rangeColumn3d",
     rangeArea = "rangeArea",
     map = "map",
     pie = "pie",
-    pie3d = "pie3d",
     radar = "radar",
     rose = "rose",
     scatter = "scatter",
@@ -20,9 +16,7 @@ export declare const enum ChartTypeEnum {
     circularProgress = "circularProgress",
     linearProgress = "linearProgress",
     wordCloud = "wordCloud",
-    wordCloud3d = "wordCloud3d",
     funnel = "funnel",
-    funnel3d = "funnel3d",
     waterfall = "waterfall",
     boxPlot = "boxPlot",
     gauge = "gauge",
@@ -34,6 +28,5 @@ export declare const enum ChartTypeEnum {
     correlation = "correlation",
     liquid = "liquid",
     venn = "venn",
-    mosaic = "mosaic",
-    pictogram = "pictogram"
+    mosaic = "mosaic"
 }

package/types/chart/line/line.d.ts

@@ -8,5 +8,6 @@ export declare class LineChart<T extends ILineChartSpec> extends BaseChart<T> {
     readonly transformerConstructor: typeof LineChartSpecTransformer;
     readonly type: string;
     readonly seriesType: string;
+    protected _setModelOption(): void;
 }
 export declare const registerLineChart: () => void;

package/types/chart/mosaic/mosaic.d.ts

@@ -17,5 +17,6 @@ export declare class MosaicChart<T extends IMosaicChartSpec = IMosaicChartSpec>
     handleAfterStackRegion: (region: IRegion, stackValueGroup: {
         [key: string]: IStackCacheRoot;
     }) => void;
+    protected _setModelOption(): void;
 }
 export declare const registerMosaicChart: () => void;

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

@@ -1,4 +1,4 @@
-import { IPictogramSeriesSpec } from '../../series/pictogram/interface';
+import type { IPictogramSeriesSpec } from '../../series/pictogram/interface';
 import type { IChartExtendsSeriesSpec, IChartSpec } from '../../typings/spec/common';
 export interface IPictogramChartSpec extends IChartSpec, IChartExtendsSeriesSpec<any> {
     type: 'pictogram';

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

@@ -1,4 +1,3 @@
 export * from './pie';
-export * from './3d';
 export * from './base';
 export * from './interface';

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

@@ -1,11 +1,7 @@
-import type { IPieSeriesSpec, IPie3dSeriesSpec } from '../../series/pie/interface';
+import type { IPieSeriesSpec } from '../../series/pie/interface';
 import type { IIndicatorSpec } from '../../component/indicator/interface';
 import type { IChartExtendsSeriesSpec, IChartSpec } from '../../typings/spec/common';
 export interface IPieChartSpec extends IChartSpec, IChartExtendsSeriesSpec<IPieSeriesSpec> {
     type: 'pie';
     indicator?: IIndicatorSpec | IIndicatorSpec[];
 }
-export interface IPie3dChartSpec extends IChartSpec, IChartExtendsSeriesSpec<IPie3dSeriesSpec> {
-    type: 'pie3d';
-    indicator?: IIndicatorSpec | IIndicatorSpec[];
-}

package/types/chart/progress/circular/circular.d.ts

@@ -9,5 +9,6 @@ export declare class CircularProgressChart<T extends ICircularProgressChartSpec
     readonly transformerConstructor: typeof CircularProgressChartSpecTransformer;
     readonly type: string;
     readonly seriesType: string;
+    protected _setModelOption(): void;
 }
 export declare const registerCircularProgressChart: () => void;

package/types/chart/progress/linear/linear.d.ts

@@ -8,5 +8,6 @@ export declare class LinearProgressChart<T extends ILinearProgressChartSpec = IL
     readonly transformerConstructor: typeof LinearProgressChartSpecTransformer;
     readonly type: string;
     readonly seriesType: string;
+    protected _setModelOption(): void;
 }
 export declare const registerLinearProgressChart: () => void;

package/types/chart/radar/radar.d.ts

@@ -8,5 +8,6 @@ export declare class RadarChart<T extends IRoseChartSpec = IRoseChartSpec> exten
     readonly transformerConstructor: typeof RadarChartSpecTransformer;
     readonly type: string;
     readonly seriesType: string;
+    protected _setModelOption(): void;
 }
 export declare const registerRadarChart: () => void;

package/types/chart/range-area/range-area.d.ts

@@ -8,5 +8,6 @@ export declare class RangeAreaChart<T extends IRangeAreaChartSpec = IRangeAreaCh
     readonly transformerConstructor: typeof RangeAreaChartSpecTransformer;
     readonly type: string;
     readonly seriesType: string;
+    protected _setModelOption(): void;
 }
 export declare const registerRangeAreaChart: () => void;

package/types/chart/range-column/index.d.ts

@@ -1,4 +1,3 @@
 export * from './range-column';
-export * from './3d';
 export * from './interface';
 export * from './range-column-transformer';

package/types/chart/range-column/interface.d.ts

@@ -1,11 +1,7 @@
 import type { IChartExtendsSeriesSpec } from '../../typings/spec/common';
-import type { IRangeColumnSeriesSpec, IRangeColumn3dSeriesSpec } from '../../series/range-column/interface';
+import type { IRangeColumnSeriesSpec } from '../../series/range-column/interface';
 import type { ICartesianChartSpec } from '../cartesian/interface';
 export interface IRangeColumnChartSpec extends ICartesianChartSpec, IChartExtendsSeriesSpec<IRangeColumnSeriesSpec> {
     type: 'rangeColumn';
     series?: IRangeColumnSeriesSpec[];
 }
-export interface IRangeColumn3dChartSpec extends ICartesianChartSpec, IChartExtendsSeriesSpec<IRangeColumn3dSeriesSpec> {
-    type: 'rangeColumn3d';
-    series?: IRangeColumn3dSeriesSpec[];
-}

package/types/chart/range-column/range-column.d.ts

@@ -8,5 +8,6 @@ export declare class RangeColumnChart<T extends IRangeColumnChartSpec = IRangeCo
     readonly transformerConstructor: typeof RangeColumnChartSpecTransformer;
     readonly type: string;
     readonly seriesType: string;
+    protected _setModelOption(): void;
 }
 export declare const registerRangeColumnChart: () => void;

package/types/chart/rose/rose.d.ts

@@ -8,5 +8,6 @@ export declare class RoseChart<T extends IRoseChartSpec = IRoseChartSpec> extend
     readonly transformerConstructor: typeof RoseChartSpecTransformer;
     readonly type: string;
     readonly seriesType: string;
+    protected _setModelOption(): void;
 }
 export declare const registerRoseChart: () => void;

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

@@ -8,5 +8,6 @@ export declare class ScatterChart<T extends IScatterChartSpec = IScatterChartSpe
     readonly transformerConstructor: typeof ScatterChartSpecTransformer;
     readonly type: string;
     readonly seriesType: string;
+    protected _setModelOption(): void;
 }
 export declare const registerScatterChart: () => void;

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

@@ -9,5 +9,6 @@ export declare class WaterfallChart<T extends IWaterfallChartSpec = IWaterfallCh
     readonly transformerConstructor: typeof WaterfallChartSpecTransformer;
     readonly type: string;
     readonly seriesType: string;
+    protected _setModelOption(): void;
 }
 export declare const registerWaterfallChart: () => void;

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

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

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

@@ -1,10 +1,6 @@
-import type { IWordCloud3dSeriesSpec, IWordCloudSeriesSpec } from '../../series/word-cloud/interface';
+import type { 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.d.ts

@@ -1,15 +1,11 @@
-import { IWordCloudChartSpec } from './interface';
+import type { IWordCloudChartSpec } from './interface';
 import { BaseWordCloudChart } from './base/base';
 import { BaseWordCloudChartSpecTransformer } from './base/word-cloud-base-transformer';
-export declare class WordCloudChart<T extends IWordCloudChartSpec = IWordCloudChartSpec> extends BaseWordCloudChart<T> {
+export declare class WordCloudChart extends BaseWordCloudChart<IWordCloudChartSpec> {
     static readonly type: string;
     static readonly seriesType: string;
-    static readonly transformerConstructor: {
-        new (option: import("../interface").IChartSpecTransformerOption): BaseWordCloudChartSpecTransformer<IWordCloudChartSpec>;
-    };
-    readonly transformerConstructor: {
-        new (option: import("../interface").IChartSpecTransformerOption): BaseWordCloudChartSpecTransformer<IWordCloudChartSpec>;
-    };
+    static readonly transformerConstructor: typeof BaseWordCloudChartSpecTransformer;
+    readonly transformerConstructor: typeof BaseWordCloudChartSpecTransformer;
     readonly type: string;
     readonly seriesType: string;
 }

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, ITicker } 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;
@@ -46,6 +51,7 @@ export interface IRenderOption {
     disableDirtyBounds?: boolean;
     enableView3dTransform?: boolean;
     pluginList?: string[];
+    ticker?: ITicker;
     optimize?: IOptimizeType;
     enableHtmlAttribute?: boolean;
     supportsTouchEvents?: boolean;
@@ -53,5 +59,9 @@ export interface IRenderOption {
     ReactDOM?: any;
     clickInterval?: number;
     autoPreventDefault?: boolean;
-    performanceHook?: Hooks;
+    performanceHook?: IPerformanceHook;
+    options3d?: {
+        enable?: boolean;
+        enableView3dTranform?: boolean;
+    } & IOption3D;
 }

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

@@ -83,5 +83,6 @@ export declare abstract class CompilableMark extends GrammarItem implements ICom
     pauseAnimationByState(state?: string): import("@visactor/vgrammar-core").IAnimate;
     resumeAnimationByState(state?: string): import("@visactor/vgrammar-core").IAnimate;
     getProductElements(): IElement[];
+    clear(): void;
     release(): void;
 }

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

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