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

package/types/mark/interface/mark.d.ts

@@ -1,8 +1,22 @@
+import type { IGraphic } from '@visactor/vrender-core';
 import type { IMarkSpec } from '../../typings';
 import type { IArc3dMarkSpec, IArcMarkSpec, IAreaMarkSpec, IBoxPlotMarkSpec, ICellMarkSpec, ICommonSpec, IComposedTextMarkSpec, IGroupMarkSpec, IImageMarkSpec, ILineMarkSpec, ILinkPathMarkSpec, IPathMarkSpec, IPolygonMarkSpec, IPyramid3dMarkSpec, IRect3dMarkSpec, IRectMarkSpec, IRippleMarkSpec, IRuleMarkSpec, ISymbolMarkSpec } from '../../typings/visual';
 import type { IMark, IMarkRaw } from './common';
 import type { MarkType } from './type';
-export type IComponentMark = IMarkRaw<ICommonSpec>;
+export interface IComponentMark extends IMarkRaw<ICommonSpec> {
+    renderInner: () => void;
+    getComponent: () => IGraphic;
+    setAttributeTransform: (t: (attrs: any) => any) => any;
+}
+export interface IGlyphMark<T extends ICommonSpec = ICommonSpec, C = any> extends IMarkRaw<T> {
+    setGlyphConfig: (cfg: C) => void;
+    getGlyphConfig: () => C;
+    getSubMarks: () => Record<string, {
+        type: MarkType;
+        defaultAttributes?: any;
+    }>;
+    getPositionChannels: () => string[];
+}
 export interface ILabelMark extends ITextMark {
     skipEncode: boolean;
     getRule: () => string;
@@ -42,3 +56,6 @@ export interface IGroupMark extends IMarkRaw<IGroupMarkSpec> {
     getMarkInId: (id: number) => IMark | undefined;
     getMarkInName: (name: string) => IMark[] | undefined;
 }
+export interface ILinkPathConfig {
+    direction?: 'horizontal' | 'vertical' | 'LR' | 'RL' | 'TB' | 'BL' | 'radial';
+}

package/types/mark/interface/type.d.ts

@@ -20,6 +20,7 @@ export declare const enum MarkTypeEnum {
     ripple = "ripple",
     liquid = "liquid",
     component = "component",
+    dataLabel = "dataLabel",
     label = "label",
     pictogram = "pictogram"
 }

package/types/mark/label.d.ts

@@ -1,7 +1,7 @@
 import type { IMark } from './interface/common';
 import { MarkTypeEnum } from './interface/type';
 import { TextMark } from './text';
-import type { ILabelMark } from './interface/mark';
+import type { IComponentMark, ILabelMark } from './interface/mark';
 export declare class LabelMark extends TextMark implements ILabelMark {
     static readonly type = MarkTypeEnum.text;
     static readonly constructorType = MarkTypeEnum.label;
@@ -13,7 +13,8 @@ export declare class LabelMark extends TextMark implements ILabelMark {
     getTarget(): IMark;
     setTarget(target: IMark): void;
     private _component;
-    getComponent(): IMark;
-    setComponent(component: IMark): void;
+    getComponent(): IComponentMark;
+    setComponent(component: IComponentMark): void;
+    render(): void;
 }
 export declare const registerLabelMark: () => void;

package/types/mark/link-path.d.ts

@@ -1,12 +1,42 @@
-import { BaseMark } from './base/base-mark';
 import type { ILinkPathMarkSpec } from '../typings/visual';
-import type { ILinkPathMark, IMarkStyle } from './interface';
+import type { ILinkPathConfig, ILinkPathMark, IMarkStyle } from './interface';
 import { MarkTypeEnum } from './interface/type';
-import type { IGroupMark } from '@visactor/vgrammar-core';
-export declare class LinkPathMark extends BaseMark<ILinkPathMarkSpec> implements ILinkPathMark {
+import { GlyphMark } from './glyph';
+import type { IGlyph } from '@visactor/vrender-core';
+import type { Datum } from '../typings/common';
+export declare const getHorizontalPath: (options: ILinkPathMarkSpec, ratio?: number) => string;
+export declare const getVerticalPath: (options: ILinkPathMarkSpec, ratio?: number) => string;
+export declare class LinkPathMark extends GlyphMark<ILinkPathMarkSpec, ILinkPathConfig> implements ILinkPathMark {
     static readonly type = MarkTypeEnum.linkPath;
     readonly type = MarkTypeEnum.linkPath;
     protected _getDefaultStyle(): IMarkStyle<ILinkPathMarkSpec>;
-    protected _initProduct(group?: string | IGroupMark): void;
+    protected _subMarks: {
+        back: {
+            type: string;
+            defaultAttributes: {
+                zIndex: number;
+            };
+        };
+        front: {
+            type: string;
+            defaultAttributes: {
+                zIndex: number;
+            };
+        };
+    };
+    protected _positionChannels: string[];
+    protected _channelEncoder: {
+        backgroundStyle: (val: any) => {
+            back: any;
+        };
+    };
+    protected _positionEncoder: (glyphAttrs: any, datum: Datum, g: IGlyph) => {
+        back: {
+            path: string;
+        };
+        front: {
+            path: string;
+        };
+    };
 }
 export declare const registerLinkPathMark: () => void;

package/types/mark/liquid.d.ts

@@ -1,13 +1,55 @@
-import type { ILiquidMarkSpec } from '../typings';
 import type { IMarkStyle } from './interface';
 import { MarkTypeEnum } from './interface/type';
-import { BaseMark } from './base';
 import type { ILiquidMark } from '../series/liquid/liquid';
-import type { IGroupMark } from '@visactor/vgrammar-core';
-export declare class LiquidMark extends BaseMark<ILiquidMarkSpec> implements ILiquidMark {
+import { GlyphMark } from './glyph';
+import { type IGlyph } from '@visactor/vrender-core';
+import type { IPointLike } from '@visactor/vutils';
+import type { ILiquidMarkSpec } from '../typings/visual';
+import type { Datum } from '../typings/common';
+export declare class LiquidMark extends GlyphMark<ILiquidMarkSpec> implements ILiquidMark {
     static readonly type = MarkTypeEnum.liquid;
     readonly type = MarkTypeEnum.liquid;
     protected _getDefaultStyle(): IMarkStyle<ILiquidMarkSpec>;
-    protected _initProduct(group?: string | IGroupMark): void;
+    protected _subMarks: {
+        wave0: {
+            type: string;
+            defaultAttributes: {
+                curveType: string;
+                fillOpacity: number;
+            };
+        };
+        wave1: {
+            type: string;
+            defaultAttributes: {
+                curveType: string;
+                fillOpacity: number;
+            };
+        };
+        wave2: {
+            type: string;
+            defaultAttributes: {
+                curveType: string;
+                fillOpacity: number;
+            };
+        };
+    };
+    protected _positionChannels: string[];
+    protected _positionEncoder: (glyphAttrs: any, datum: Datum, g: IGlyph) => {
+        wave0: {
+            x: number;
+            y: number;
+            points: IPointLike[];
+        };
+        wave1: {
+            x: number;
+            y: number;
+            points: IPointLike[];
+        };
+        wave2: {
+            x: number;
+            y: number;
+            points: IPointLike[];
+        };
+    };
 }
 export declare const registerLiquidMark: () => void;

package/types/mark/ripple.d.ts

@@ -1,12 +1,47 @@
-import { BaseMark } from './base/base-mark';
 import type { IRippleMarkSpec } from '../typings/visual';
 import type { IMarkStyle, IRippleMark } from './interface';
 import { MarkTypeEnum } from './interface/type';
-import type { IGroupMark } from '@visactor/vgrammar-core';
-export declare class RippleMark extends BaseMark<IRippleMarkSpec> implements IRippleMark {
+import { GlyphMark } from './glyph';
+import type { Datum } from '../typings/common';
+import { type IGlyph } from '@visactor/vrender-core';
+export declare class RippleMark extends GlyphMark<IRippleMarkSpec> implements IRippleMark {
     static readonly type = MarkTypeEnum.ripple;
     readonly type = MarkTypeEnum.ripple;
     protected _getDefaultStyle(): IMarkStyle<IRippleMarkSpec>;
-    protected _initProduct(group?: string | IGroupMark): void;
+    protected _subMarks: {
+        ripple0: {
+            type: string;
+            defaultAttributes: {
+                fillOpacity: number;
+            };
+        };
+        ripple1: {
+            type: string;
+            defaultAttributes: {
+                fillOpacity: number;
+            };
+        };
+        ripple2: {
+            type: string;
+            defaultAttributes: {
+                fillOpacity: number;
+            };
+        };
+    };
+    protected _positionChannels: string[];
+    protected _positionEncoder: (glyphAttrs: any, datum: Datum, g: IGlyph) => {
+        ripple0: {
+            size: any;
+            fillOpacity: number;
+        };
+        ripple1: {
+            size: any;
+            fillOpacity: number;
+        };
+        ripple2: {
+            size: any;
+            fillOpacity: number;
+        };
+    };
 }
 export declare const registerRippleMark: () => void;

package/types/mark/rule.d.ts

@@ -2,9 +2,12 @@ import type { IRuleMarkSpec } from '../typings/visual';
 import { BaseMark } from './base/base-mark';
 import type { IMarkStyle, IRuleMark } from './interface';
 import { MarkTypeEnum } from './interface/type';
+import type { IGraphic, ILineGraphicAttribute } from '@visactor/vrender-core';
 export declare class RuleMark extends BaseMark<IRuleMarkSpec> implements IRuleMark {
     static readonly type = MarkTypeEnum.rule;
     readonly type = MarkTypeEnum.rule;
     protected _getDefaultStyle(): IMarkStyle<IRuleMarkSpec>;
+    protected _transformGraphicAttributes(g: IGraphic, attrs: any, groupAttrs?: any): any;
+    protected _createGraphic(attrs?: ILineGraphicAttribute): IGraphic;
 }
 export declare const registerRuleMark: () => void;

package/types/mark/symbol.d.ts

@@ -2,11 +2,11 @@ import type { ISymbolMarkSpec } from '../typings/visual';
 import { BaseMark } from './base/base-mark';
 import type { IMarkStyle, ISymbolMark } from './interface';
 import { MarkTypeEnum } from './interface/type';
-export declare class BaseSymbolMark<T extends ISymbolMarkSpec> extends BaseMark<T> {
-    protected _getDefaultStyle(): IMarkStyle<T>;
-}
-export declare class SymbolMark extends BaseSymbolMark<ISymbolMarkSpec> implements ISymbolMark {
+import type { IGraphic } from '@visactor/vrender-core';
+export declare class SymbolMark extends BaseMark<ISymbolMarkSpec> implements ISymbolMark {
     static readonly type = MarkTypeEnum.symbol;
     readonly type = MarkTypeEnum.symbol;
+    protected _getDefaultStyle(): IMarkStyle<ISymbolMarkSpec>;
+    protected _transformGraphicAttributes(g: IGraphic, attrs: any, groupAttrs?: any): any;
 }
 export declare const registerSymbolMark: () => void;

package/types/mark/text.d.ts

@@ -3,6 +3,7 @@ import { BaseMark } from './base/base-mark';
 import type { IMarkOption, IMarkStyle } from './interface';
 import { MarkTypeEnum } from './interface';
 import type { ITextMark, ITextSpec } from './interface/mark';
+import type { IGraphic, IRichTextGraphicAttribute, ITextGraphicAttribute } from '@visactor/vrender-core';
 export declare class TextMark extends BaseMark<IComposedTextMarkSpec> implements ITextMark {
     static readonly type = MarkTypeEnum.text;
     readonly type = MarkTypeEnum.text;
@@ -10,7 +11,8 @@ export declare class TextMark extends BaseMark<IComposedTextMarkSpec> implements
     getTextType(): "text" | "rich";
     constructor(name: string, option: IMarkOption);
     protected _getDefaultStyle(): IMarkStyle<IComposedTextMarkSpec>;
-    initStyleWithSpec(spec: ITextSpec<IComposedTextMarkSpec>, key?: string): void;
-    compileEncode(): void;
+    initStyleWithSpec(spec: ITextSpec<IComposedTextMarkSpec>): void;
+    protected _transformGraphicAttributes(g: IGraphic, attrs: any, groupAttrs?: any): any;
+    protected _createGraphic(attrs?: ITextGraphicAttribute | IRichTextGraphicAttribute): IGraphic;
 }
 export declare const registerTextMark: () => void;

package/types/mark/transform/data-sampling.d.ts

@@ -0,0 +1,10 @@
+import type { Datum } from '../../typings/common';
+export declare const dataSampling: (options: {
+    size: number | (() => number);
+    factor?: number;
+    skipfirst?: boolean;
+    yfield?: string;
+    groupBy?: string;
+    mode?: 'lttb' | 'min' | 'max' | 'average' | 'sum';
+}, upstreamData: Datum[]) => Datum[];
+export declare const registerDataSamplingTransform: () => void;

package/types/mark/transform/filter.d.ts

@@ -0,0 +1 @@
+export declare const registerMarkFilterTransform: () => void;

package/types/mark/transform/map.d.ts

@@ -0,0 +1 @@
+export declare const registerMarkMapTransform: () => void;

package/types/mark/transform/symbol-overlap.d.ts

@@ -0,0 +1,14 @@
+import type { IMarkGraphic } from '../interface';
+export declare const OVERLAP_HIDE_KEY: string;
+export declare const transform: (options: {
+    direction: number;
+    delta?: number;
+    deltaMul?: number;
+    radius?: boolean;
+    hideMode?: number;
+    forceUpdate?: boolean;
+    forceUpdateStamp?: number;
+    groupBy?: string;
+    sort?: boolean;
+}, upstreamData: IMarkGraphic[]) => IMarkGraphic[];
+export declare const registerSymbolOverlapTransform: () => void;

package/types/mark/utils/common.d.ts

@@ -1,5 +1,9 @@
 import { MarkTypeEnum } from '../interface/type';
+import type { Datum } from '../../typings';
+import type { GroupedData } from '../interface/common';
 export declare const MultiDatumMark: string[];
 export declare function isMultiDatumMark(type: MarkTypeEnum): boolean;
 export declare function curveTypeTransform(type: string, direction: string): string;
 export declare function is3DMark(type: MarkTypeEnum): boolean;
+export declare function groupData<T>(data: T[], groupBy: (datum: Datum, index: number) => string, sort?: (a: T, b: T) => number): GroupedData<T>;
+export declare const runEncoder: (styles: Record<string, (datum: Datum) => any>, datum: Datum, attrs?: any) => any;

package/types/mark/utils/glyph.d.ts

@@ -0,0 +1,2 @@
+import type { IMarkGraphic } from '../interface/common';
+export declare const addRuntimeState: (g: IMarkGraphic, stateName: string, attrs: any, keepCurrentStates?: boolean, hasAnimation?: boolean) => void;

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

@@ -1 +1,3 @@
 export * from './common';
+export * from './line';
+export * from './glyph';

package/types/mark/utils/line.d.ts

@@ -0,0 +1,3 @@
+import type { IColorStop } from '@visactor/vrender-core';
+export declare const isStopsEqual: (prev: IColorStop[], next: IColorStop[]) => boolean;
+export declare const isSegmentAttrEqual: (prev: any, next: any, key: string) => boolean;

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

@@ -3,12 +3,12 @@ import type { IEffect, IModel, IModelInitOption, IModelOption, IModelRenderOptio
 import type { CoordinateType } from '../typings/coordinate';
 import type { ICompileMarkConfig, IMark, IMarkOption, IMarkRaw, IMarkStyle } from '../mark/interface';
 import type { Datum, StateValueType, ConvertToMarkStyleSpec, ICommonSpec, StringOrNumber, IRect, ILayoutRect } from '../typings';
-import type { CompilableData } from '../compile/data/compilable-data';
-import type { IGroupMark } from '@visactor/vgrammar-core';
 import { MarkSet } from '../mark/mark-set';
 import type { ILayoutItem } from '../layout/interface';
 import { CompilableBase } from '../compile/compilable-base';
 import { BaseModelSpecTransformer } from './base-model-transformer';
+import type { IGroup } from '@visactor/vrender-core';
+import type { ICompilableData } from '../compile/data/interface';
 export declare abstract class BaseModel<T extends IModelSpec> extends CompilableBase implements IModel {
     readonly transformerConstructor: typeof BaseModelSpecTransformer;
     protected _spec: T;
@@ -21,8 +21,8 @@ export declare abstract class BaseModel<T extends IModelSpec> extends Compilable
     userId: StringOrNumber | undefined;
     readonly event: IEvent;
     readonly effect: IEffect;
-    protected _data: CompilableData;
-    getData(): CompilableData;
+    protected _data: ICompilableData;
+    getData(): ICompilableData;
     protected _layout?: ILayoutItem;
     get layout(): ILayoutItem;
     readonly specKey: string;
@@ -42,8 +42,8 @@ export declare abstract class BaseModel<T extends IModelSpec> extends Compilable
     init(option: IModelInitOption): void;
     afterInit(): void;
     getVisible(): boolean;
-    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect, ctx: any): void;
-    onLayoutEnd(ctx: any): void;
+    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect): void;
+    onLayoutEnd(): void;
     onEvaluateEnd(ctx: IModelEvaluateOption): void;
     abstract onRender(ctx: IModelRenderOption): void;
     onDataUpdate(): void;
@@ -68,10 +68,10 @@ export declare abstract class BaseModel<T extends IModelSpec> extends Compilable
     setAttrFromSpec(): void;
     protected _convertMarkStyle<T extends ICommonSpec = ICommonSpec>(style: Partial<IMarkStyle<T> | ConvertToMarkStyleSpec<T>>): Partial<IMarkStyle<T> | ConvertToMarkStyleSpec<T>>;
     setMarkStyle<T extends ICommonSpec>(mark: IMarkRaw<T>, style?: Partial<IMarkStyle<T> | ConvertToMarkStyleSpec<T>>, state?: StateValueType, level?: number): void;
-    initMarkStyleWithSpec(mark?: IMark, spec?: any, key?: string): void;
+    initMarkStyleWithSpec(mark?: IMark, spec?: any): void;
     protected stateKeyToSignalName(key: string, opt?: string): string;
     compileData(): void;
-    compileMarks(group?: string | IGroupMark): void;
+    compileMarks(group?: IGroup): void;
     protected _createMark<T extends IMark>(markInfo: IModelMarkInfo, option?: Partial<IMarkOption>, config?: ICompileMarkConfig): T;
     protected _getDataIdKey(): string | ((datum: Datum) => string) | undefined;
     getColorScheme(): import("..").IThemeColorScheme;

package/types/model/interface.d.ts

@@ -3,7 +3,6 @@ import type { DataSet, DataView } from '@visactor/vdataset';
 import type { IEvent, IEventDispatcher } from '../event/interface';
 import type { IMark, IMarkRaw, IMarkStyle, MarkTypeEnum } from '../mark/interface';
 import type { RenderMode } from '../typings/spec/common';
-import type { IData } from '@visactor/vgrammar-core';
 import type { StringOrNumber } from '../typings/common';
 import type { IGroupMarkSpec, ConvertToMarkStyleSpec, ICommonSpec } from '../typings/visual';
 import type { IRect } from '../typings/space';
@@ -11,7 +10,6 @@ import type { IPoint, CoordinateType } from '../typings/coordinate';
 import type { ITheme } from '../theme/interface';
 import type { StateValueType } from '../typings/spec';
 import type { ICompilable, ICompilableInitOption } from '../compile/interface';
-import type { ICompilableData } from '../compile/data/interface';
 import type { IGlobalScale } from '../scale/interface';
 import type { IChart, IChartSpecInfo, IChartSpecTransformerOption } from '../chart/interface';
 import type { IThemeColorScheme } from '../theme/color-scheme/interface';
@@ -22,6 +20,7 @@ import type { SeriesTypeEnum } from '../series/interface';
 import type { ITooltipSpec } from '../component/tooltip/interface';
 import type { TooltipActiveType } from '../typings';
 import type { IVChart } from '../core/interface';
+import type { ICompilableData } from '../compile/data/interface';
 export interface IModelInitOption {
 }
 export interface IModelLayoutOption {
@@ -53,9 +52,6 @@ export interface IUpdateSpecResult {
 export interface IUpdateDataResult {
     reAnimate?: boolean;
 }
-export interface IModelProduct {
-    srData: IData;
-}
 export interface IModel extends ICompilable {
     readonly modelType: string;
     readonly type: string;
@@ -84,11 +80,11 @@ export interface IModel extends ICompilable {
     getSpec?: () => any;
     getSpecIndex: () => number;
     getSpecPath: () => Array<string | number>;
-    onLayoutStart: (layoutRect: IRect, viewRect: ILayoutRect, ctx: IModelLayoutOption) => void;
-    onLayoutEnd: (ctx: IModelLayoutOption) => void;
+    onLayoutStart: (layoutRect: IRect, viewRect: ILayoutRect) => void;
+    onLayoutEnd: () => void;
     getColorScheme: () => IThemeColorScheme | undefined;
     setMarkStyle: <T extends ICommonSpec>(mark?: IMarkRaw<T>, style?: Partial<IMarkStyle<T> | ConvertToMarkStyleSpec<T>>, state?: StateValueType, level?: number) => void;
-    initMarkStyleWithSpec: (mark?: IMark, spec?: any, key?: string) => void;
+    initMarkStyleWithSpec: (mark?: IMark, spec?: any) => void;
     getSpecInfo: () => IModelSpecInfo;
 }
 export interface ILayoutModel extends IModel {

package/types/model/layout-model.d.ts

@@ -19,8 +19,8 @@ export declare abstract class LayoutModel<T extends IModelSpec> extends BaseMode
     protected _layoutStartPos: IPoint;
     protected _isLayout: boolean;
     initLayout(): void;
-    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect, ctx: any): void;
-    onLayoutEnd(ctx: any): void;
+    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect): void;
+    onLayoutEnd(): void;
     afterSetLayoutStartPoint(_pos: ILayoutPoint): void;
     protected _forceLayout(): void;
     getLayoutStartPoint(): IPoint;

package/types/plugin/components/tooltip-handler/base.d.ts

@@ -19,7 +19,7 @@ export declare abstract class BaseTooltipHandler extends BasePlugin implements I
     protected _option: ITooltipHandlerOptions;
     protected _chartOption: IChartOption;
     protected _env: RenderMode;
-    get env(): "node" | "desktop-browser" | "mobile-browser" | "worker" | "miniApp" | "wx" | "tt" | "harmony" | "desktop-miniApp" | "lynx";
+    get env(): "desktop-browser" | "mobile-browser" | "node" | "worker" | "miniApp" | "wx" | "tt" | "harmony" | "desktop-miniApp" | "lynx";
     protected _component: Tooltip;
     protected _chartContainer: Maybe<HTMLElement>;
     protected _compiler: ICompiler;
@@ -37,7 +37,7 @@ export declare abstract class BaseTooltipHandler extends BasePlugin implements I
     protected _getDefaultOption(): ITooltipHandlerOptions;
     protected _getActualTooltipPosition: (actualTooltip: ITooltipActual, params: TooltipHandlerParams, tooltipBoxSize: IContainerSize | undefined) => ITooltipPositionActual;
     protected _getParentElement(spec: ITooltipSpec): HTMLElement;
-    getTooltipContainer(): HTMLElement | IGroup;
+    getTooltipContainer(): IGroup | HTMLElement;
     protected _initFromSpec(): void;
     reInit(): void;
 }

package/types/plugin/components/tooltip-handler/utils/position.d.ts

@@ -8,12 +8,10 @@ export declare const getPositionType: (position: TooltipFixedPosition, dim: 'x'
 export declare const getCartesianCrosshairRect: (dimensionData: IDimensionData, layoutStartPoint: ILayoutPoint) => {
     visible: boolean;
     start: {
-        x: number;
-        y: number;
+        [x: string]: number;
     };
     end: {
-        x: number;
-        y: number;
+        [x: string]: number;
     };
 };
 export declare const isGlobalTooltipPositionPattern: (obj: any) => obj is IGlobalTooltipPositionPattern;

package/types/plugin/other.d.ts

@@ -1,6 +1,6 @@
 import { registerHtmlAttributePlugin, registerReactAttributePlugin } from '@visactor/vrender-core';
-import { registerDragPlugin, registerGesturePlugin } from '@visactor/vgrammar-core';
 export declare const register3DPlugin: () => void;
 export declare const registerAnimate: () => void;
-export { registerReactAttributePlugin, registerHtmlAttributePlugin, registerDragPlugin, registerGesturePlugin };
-export declare const registerMorph: () => void;
+export declare const registerDragPlugin: () => void;
+export declare const registerGesturePlugin: () => void;
+export { registerReactAttributePlugin, registerHtmlAttributePlugin };

package/types/region/interface.d.ts

@@ -2,7 +2,6 @@ import type { IMark, IGroupMark } from '../mark/interface';
 import type { ILayoutModel, IModelConstructor, IModelOption, IModelSpecInfo } from '../model/interface';
 import type { ISeries, SeriesType } from '../series/interface';
 import type { CoordinateType } from '../typings/coordinate';
-import type { IInteraction } from '../interaction/interface';
 import type { IProjectionSpec } from '../component/geo/interface';
 import type { ConvertToMarkStyleSpec, IRectMarkSpec } from '../typings/visual';
 import type { IAnimate } from '../animation/interface';
@@ -10,7 +9,6 @@ import type { StringOrNumber } from '../typings';
 import type { ILayoutItemSpec } from '../layout/interface';
 export interface IRegion extends ILayoutModel {
     animate?: IAnimate;
-    interaction: IInteraction;
     getStackInverse: () => boolean;
     getStackSort: () => boolean;
     getMaxWidth: () => number | undefined;

package/types/region/region.d.ts

@@ -1,14 +1,13 @@
-import type { IGroupMark as IVGrammarGroupMark } from '@visactor/vgrammar-core';
 import type { ISeries } from '../series/interface';
 import type { IModelOption } from '../model/interface';
 import type { CoordinateType } from '../typings/coordinate';
 import type { IRegion, IRegionSpec, IRegionSpecInfo } from './interface';
-import type { IInteraction, ITrigger } from '../interaction/interface';
 import type { IAnimate } from '../animation/interface';
 import type { ILayoutType, StringOrNumber } from '../typings';
 import { LayoutModel } from '../model/layout-model';
 import { RegionSpecTransformer } from './region-transformer';
 import type { IGroupMark, IRectMark } from '../mark/interface/mark';
+import type { IGroup } from '@visactor/vrender-core';
 export declare class Region<T extends IRegionSpec = IRegionSpec> extends LayoutModel<T> implements IRegion {
     static type: string;
     static readonly transformerConstructor: typeof RegionSpecTransformer;
@@ -21,7 +20,6 @@ export declare class Region<T extends IRegionSpec = IRegionSpec> extends LayoutM
     layoutType: ILayoutType;
     layoutZIndex: number;
     animate?: IAnimate;
-    interaction: IInteraction;
     getSpecInfo: () => IRegionSpecInfo;
     getMaxWidth(): number;
     setMaxWidth(value: number): void;
@@ -35,7 +33,6 @@ export declare class Region<T extends IRegionSpec = IRegionSpec> extends LayoutM
     getStackSort(): boolean;
     protected _backgroundMark?: IRectMark;
     protected _foregroundMark?: IRectMark;
-    protected _trigger: ITrigger;
     constructor(spec: T, ctx: IModelOption);
     protected _getClipDefaultValue(): boolean;
     created(): void;
@@ -73,10 +70,7 @@ export declare class Region<T extends IRegionSpec = IRegionSpec> extends LayoutM
     initSeriesDataflow(): void;
     seriesDataFilterOver: () => void;
     release(): void;
-    createTrigger(): void;
-    initTrigger(): void;
-    initInteraction(): void;
-    compileMarks(group?: string | IVGrammarGroupMark): void;
+    compileMarks(group?: IGroup): void;
     compile(): void;
     getBoundsInRect: () => {
         x1: number;
@@ -84,5 +78,5 @@ export declare class Region<T extends IRegionSpec = IRegionSpec> extends LayoutM
         x2: number;
         y2: number;
     };
-    onLayoutEnd(ctx: any): void;
+    onLayoutEnd(): void;
 }

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

@@ -1,4 +1,4 @@
-import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+import type { IAnimationTypeConfig } from '../../animation/interface';
 import type { AreaAppearPreset, IAreaAnimationParams } from './interface';
 export declare function areaPresetAnimation(params: IAreaAnimationParams, preset: AreaAppearPreset | boolean): IAnimationTypeConfig;
 export declare const registerAreaSeriesAnimation: () => void;

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

@@ -28,7 +28,7 @@ export declare class AreaSeries<T extends IAreaSeriesSpec = IAreaSeriesSpec> ext
     compile(): void;
     getDefaultShapeType(): string;
     getActiveMarks(): IMark[];
-    onLayoutEnd(ctx: any): void;
+    onLayoutEnd(): void;
     getSeriesStyle(datum: Datum): (attribute: string) => any;
 }
 export declare const registerAreaSeries: () => void;

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

@@ -1,5 +1,5 @@
-import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
 import type { BarAppearPreset, IBarAnimationParams } from './interface';
+import type { IAnimationTypeConfig } from '../../animation/interface';
 export declare const barGrowIn: (params: IBarAnimationParams, isOverall?: boolean) => IAnimationTypeConfig;
 export declare const barGrowOut: (params: IBarAnimationParams, isOverall?: boolean) => IAnimationTypeConfig;
 export declare function barPresetAnimation(params: IBarAnimationParams, preset: BarAppearPreset | boolean): IAnimationTypeConfig;

package/types/series/bar/bar.d.ts

@@ -8,9 +8,9 @@ import type { IAxisHelper } from '../../component/axis/cartesian/interface';
 import type { IModelInitOption } from '../../model/interface';
 import type { SeriesMarkMap } from '../interface';
 import { SeriesMarkNameEnum, SeriesTypeEnum } from '../interface/type';
-import { SeriesData } from '../base/series-data';
 import { DataView } from '@visactor/vdataset';
 import { BarSeriesSpecTransformer } from './bar-transformer';
+import type { ICompilableData } from '../../compile/data';
 export declare const DefaultBandWidth = 6;
 export declare class BarSeries<T extends IBarSeriesSpec = IBarSeriesSpec> extends CartesianSeries<T> {
     static readonly type: string;
@@ -23,7 +23,7 @@ export declare class BarSeries<T extends IBarSeriesSpec = IBarSeriesSpec> extend
     protected _bandPosition: number;
     protected _barMark: IRectMark;
     protected _barBackgroundMark: IRectMark;
-    protected _barBackgroundViewData: SeriesData;
+    protected _barBackgroundViewData: ICompilableData;
     initMark(): void;
     protected _initBarBackgroundMark(): void;
     initMarkStyle(): void;
@@ -61,7 +61,7 @@ export declare class BarSeries<T extends IBarSeriesSpec = IBarSeriesSpec> extend
     protected _getBarBackgroundPositionYEncoder: () => (datum: Datum) => number;
     protected _setBarBackgroundPositionYEncoder: (encoder: (datum: Datum) => number) => void;
     dataToBarBackgroundPositionY(datum: Datum, scaleDepth?: number): number;
-    onLayoutEnd(ctx: any): void;
+    onLayoutEnd(): void;
     compile(): void;
     getDefaultShapeType(): string;
     getActiveMarks(): IMark[];