@visactor/vchart-types 2.1.0-alpha.13 → 2.1.0-alpha.15

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

@@ -8,7 +8,6 @@ import type { ICartesianBandAxisSpec } from '../..//component/axis/cartesian/int
 export declare class BaseChartSpecTransformer<T extends IChartSpec> implements IChartSpecTransformer {
     readonly type: string;
     readonly seriesType: string;
-    protected _seriesRelatedSpecKeys: Record<string, true>;
     protected _option: IChartSpecTransformerOption;
     constructor(option: IChartSpecTransformerOption);
     initChartSpec(chartSpec: T): IChartSpecInfo;
@@ -17,8 +16,6 @@ export declare class BaseChartSpecTransformer<T extends IChartSpec> implements I
     transformModelSpec(chartSpec: T): IChartSpecInfo;
     createSpecInfo(chartSpec: T, transform?: (constructor: IModelConstructor, specInfo: IModelSpecInfo, chartSpecInfo?: IChartSpecInfo) => void): IChartSpecInfo;
     protected _isValidSeries(seriesType: string): boolean;
-    getSeriesRelatedSpecKeys(): Record<string, true>;
-    protected _addSeriesRelatedSpecKeys(...keysList: Array<string[] | undefined>): void;
     protected _getDefaultSeriesSpec(chartSpec: any, pickKeys?: string[], pickKeys2?: string[]): any;
     forEachRegionInSpec<K>(chartSpec: T, callbackfn: (constructor: IRegionConstructor, specInfo: IModelSpecInfo, chartSpecInfo?: IChartSpecInfo) => K, chartSpecInfo?: IChartSpecInfo): K[];
     forEachSeriesInSpec<K>(chartSpec: T, callbackfn: (constructor: ISeriesConstructor, specInfo: IModelSpecInfo, chartSpecInfo?: IChartSpecInfo) => K, chartSpecInfo?: IChartSpecInfo): K[];

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

@@ -30,7 +30,6 @@ export declare class BaseChart<T extends IChartSpec> extends CompilableBase impl
     protected _regions: IRegion[];
     protected _series: ISeries[];
     protected _components: IComponent[];
-    protected _specTransformer: Maybe<IChartSpecTransformer>;
     protected _layoutFunc: LayoutCallBack;
     protected _layoutRect: IRect;
     getLayoutRect(): IRect;
@@ -119,32 +118,17 @@ export declare class BaseChart<T extends IChartSpec> extends CompilableBase impl
     updateGlobalScale(result: IUpdateSpecResult): void;
     updateGlobalScaleTheme(): void;
     private _getSpecKeys;
-    updateSpec(spec: T): IUpdateSpecResult;
+    updateSpec(spec: T): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
     updateChartConfig(result: IUpdateSpecResult, oldSpec: IChartSpec): void;
     updateDataSpec(): void;
     updateRegionSpec(result: IUpdateSpecResult): void;
-    updateComponentSpec(result: IUpdateSpecResult): {
-        componentOnlyUpdatedComponents: IComponent[];
-        hasNonComponentOnlyUpdate: boolean;
-    };
-    private _canChangeMarkerComponentsWithoutRemake;
-    private _canAddMarkerComponentsWithoutRemake;
-    private _isMarkerAdditionSpecSafeWithoutRemake;
-    private _isAutoRangeMarkerSpec;
-    private _canRemoveMarkerComponentsWithoutRemake;
-    private _isOnlyMarkerComponentsRemoved;
-    private _isComponentSpecKey;
-    private _isOnlyComponentSpecsChanged;
-    private _isOnlySeriesSpecsChanged;
-    private _isOnlyComponentOrSeriesSpecsChanged;
-    private _canSkipChartDataStages;
-    private _isComponentScaleDomainOnlyUpdate;
-    private _reRunStackDataFlow;
-    private _getModelSpecIndex;
-    private _hasComponentForSpecInfo;
-    private _createMissingMarkerComponentsForSpecs;
-    private _removeMarkerComponentsForEmptySpecs;
-    private _removeComponent;
+    updateComponentSpec(result: IUpdateSpecResult): void;
     updateSeriesSpec(result: IUpdateSpecResult): void;
     getCanvas(): HTMLCanvasElement;
     private _updateLayoutRect;
@@ -158,7 +142,7 @@ export declare class BaseChart<T extends IChartSpec> extends CompilableBase impl
     compileRegions(): void;
     compileSeries(): void;
     compileComponents(): void;
-    release(forceReleaseVRenderComponents?: boolean): void;
+    release(): 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;

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

@@ -112,7 +112,6 @@ export interface IChartSpecTransformer {
     transformSpec: (spec: any) => void;
     transformModelSpec: (spec: any) => IChartSpecInfo;
     createSpecInfo: (chartSpec: any, transform?: (constructor: IModelConstructor, specInfo: IModelSpecInfo, chartSpecInfo?: IChartSpecInfo) => void) => IChartSpecInfo;
-    getSeriesRelatedSpecKeys: () => Record<string, true>;
     forEachRegionInSpec: <K>(spec: any, callbackfn: (constructor: IRegionConstructor, specInfo: IModelSpecInfo, chartSpecInfo?: IChartSpecInfo) => K, chartSpecInfo?: IChartSpecInfo) => K[];
     forEachSeriesInSpec: <K>(spec: any, callbackfn: (constructor: ISeriesConstructor, specInfo: IModelSpecInfo, chartSpecInfo?: IChartSpecInfo) => K, chartSpecInfo?: IChartSpecInfo) => K[];
     forEachComponentInSpec: <K>(spec: any, callbackfn: (constructor: IComponentConstructor, specInfo: IModelSpecInfo, chartSpecInfo?: IChartSpecInfo) => K, chartSpecInfo?: IChartSpecInfo) => K[];

package/types/chart/util.d.ts

@@ -1,7 +1,7 @@
 import type { IChartSpec } from '../typings';
 import type { ICartesianChartSpec } from './cartesian/interface';
 import type { IChartOption } from './interface/common';
-import type { IUpdateSpecEffects, IUpdateSpecResult } from '../model/interface';
+import type { IUpdateSpecResult } from '../model/interface';
 export declare function setDefaultCrosshairForCartesianChart(spec: ICartesianChartSpec): void;
 export declare function calculateChartSize(spec: {
     width?: number;
@@ -13,9 +13,6 @@ export declare function calculateChartSize(spec: {
     width: number;
     height: number;
 };
-export declare function normalizeUpdateSpecEffects(result: IUpdateSpecResult): IUpdateSpecEffects;
-export declare function isUpdateSpecResultLocalOnly(result: IUpdateSpecResult): boolean;
-export declare function isUpdateSpecResultComponentOnly(result: IUpdateSpecResult): boolean;
 export declare function mergeUpdateResult(target: IUpdateSpecResult, ...sources: IUpdateSpecResult[]): IUpdateSpecResult;
 export declare function getTrimPaddingConfig(chartType: string, spec: IChartSpec): {
     paddingInner: number;

package/types/compile/compiler.d.ts

@@ -20,8 +20,6 @@ export declare class Compiler implements ICompiler {
     private _progressiveRafId?;
     protected _rootMarks: IMark[];
     protected _stage: IStage;
-    private _isExternalStage;
-    private _releaseVRenderAppRef?;
     protected _stateAnimationConfig: Partial<MarkAnimationSpec>;
     get stateAnimationConfig(): Partial<MarkAnimationSpec>;
     protected _rootGroup: IGroup;

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

@@ -13,7 +13,7 @@ export declare class CompilableData extends GrammarItem implements ICompilableDa
     setDataView(d?: DataView): void;
     getLatestData(): any;
     constructor(option: GrammarItemInitOption, dataView?: DataView);
-    removeProduct(_releaseDetach?: boolean): void;
+    removeProduct(): void;
     release(): void;
     protected _relatedMarks?: Record<string, ICompilableMark>;
     addRelatedMark(mark: ICompilableMark): void;

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

@@ -11,7 +11,7 @@ export declare abstract class GrammarItem extends CompilableBase implements IGra
     getProductId(): string;
     compile(option?: GrammarItemCompileOption): void;
     protected abstract _compileProduct(option?: GrammarItemCompileOption): void;
-    abstract removeProduct(releaseDetach?: 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

@@ -85,7 +85,7 @@ export interface IGrammarItem extends ICompilable {
     id: number;
     generateProductId: () => string;
     getProductId: () => string;
-    removeProduct: (releaseDetach?: boolean) => void;
+    removeProduct: () => void;
     setTransform: (transform: ITransformSpec[]) => void;
 }
 export type GrammarItemInitOption = ICompilableInitOption;

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

@@ -1,8 +1,7 @@
-import type { IApp, IColor, IStageParams, IStage, ILayer, IOption3D, ITicker } from '@visactor/vrender-core';
+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';
-import type { SharedVRenderAppOption } from '../stage-app';
 export declare enum LayoutState {
     before = "before",
     layouting = "layouting",
@@ -43,8 +42,6 @@ export interface IRenderOption {
     viewBox?: IBoundsLike;
     canvasControled?: boolean;
     stage?: IStage;
-    app?: IApp;
-    sharedVRenderApp?: SharedVRenderAppOption;
     layer?: ILayer;
     beforeRender?: IStageParams['beforeRender'];
     afterRender?: IStageParams['afterRender'];

package/types/component/axis/base-axis.d.ts

@@ -82,8 +82,13 @@ export declare abstract class AxisComponent<T extends ICommonAxisSpec & Record<s
     protected computeData(updateType?: 'domain' | 'range' | 'force'): void;
     protected _updateTickDataMarks(m: ICompilableMark): void;
     protected initScales(): void;
-    _compareSpec(spec: T, prevSpec: T): import("../..").IUpdateSpecResult;
-    private _isComponentOnlySpecChange;
+    _compareSpec(spec: T, prevSpec: T): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
     protected _getAxisAttributes(): any;
     protected _getGridAttributes(): {
         alternateColor: any;

package/types/component/axis/cartesian/band-axis.d.ts

@@ -43,7 +43,13 @@ export declare class CartesianBandAxis<T extends ICartesianBandAxisSpec = ICarte
         maxBandSize: number;
         minBandSize: number;
     };
-    _compareSpec(spec: T, prevSpec: T): import("../../..").IUpdateSpecResult;
+    _compareSpec(spec: T, prevSpec: T): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
     reInit(spec?: T): void;
 }
 export declare const registerCartesianBandAxis: () => void;

package/types/component/axis/polar/band-axis.d.ts

@@ -18,7 +18,6 @@ export declare class PolarBandAxis<T extends IPolarBandAxisSpec = IPolarBandAxis
     };
     protected _scale: BandScale;
     protected _scales: BandScale[];
-    protected _updateData: () => void;
     protected computeDomain(data: {
         min: number;
         max: number;
@@ -38,7 +37,6 @@ export declare class PolarBandAxis<T extends IPolarBandAxisSpec = IPolarBandAxis
         getSpec: () => T;
     };
     protected initScales(): void;
-    reInit(spec?: T): void;
     protected registerTicksTransform(): string;
     transformScaleDomain(): void;
 }

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

@@ -19,20 +19,20 @@ export declare class BaseComponent<T extends IComponentSpec = IComponentSpec> ex
     protected _regions: IRegion[];
     getRegions(): IRegion[];
     protected _container: IGroup;
-    private _exitingVRenderComponents?;
-    private _forceReleaseVRenderComponents;
     created(): void;
     initLayout(): void;
     protected _getNeedClearVRenderComponents(): IGraphic[];
     getVRenderComponents(): IGraphic<Partial<IGraphicAttribute>>[];
     protected callPlugin(cb: (plugin: IComponentPlugin) => void): void;
     protected getContainer(): IGroup;
-    _compareSpec(spec: T, prevSpec: T): import("../../model/interface").IUpdateSpecResult;
-    beforeRelease(): void;
+    _compareSpec(spec: T, prevSpec: T): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
     release(): void;
-    protected _shouldReleaseVRenderComponentsImmediately(): boolean;
-    protected _forceReleaseExitingVRenderComponents(): void;
-    protected _releaseVRenderComponent(component: IGraphic): void;
     clear(): void;
     compile(): void;
     compileMarks(group?: IGroup): void;

package/types/component/brush/brush.d.ts

@@ -48,7 +48,6 @@ export declare class Brush<T extends IBrushSpec = IBrushSpec> extends BaseCompon
     private _zoomRecord;
     static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
     init(): void;
-    reInit(spec?: T): void;
     private _initNeedOperatedItem;
     created(): void;
     protected _bindRegions(): void;
@@ -56,8 +55,13 @@ export declare class Brush<T extends IBrushSpec = IBrushSpec> extends BaseCompon
     private _initRegionAxisMap;
     private _initAxisDataZoomMap;
     protected initEvent(): void;
-    _compareSpec(spec: T, prevSpec: T): import("../../model/interface").IUpdateSpecResult;
-    protected _isComponentOnlySpecChange(spec: T, prevSpec: T): boolean;
+    _compareSpec(spec: T, prevSpec: T): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
     onLayoutEnd(): void;
     protected _updateBrushComponent(region: IRegion, componentIndex: number): void;
     protected _shouldEnableInteractive(): boolean;

package/types/component/crosshair/base.d.ts

@@ -41,10 +41,13 @@ export declare abstract class BaseCrossHair<T extends ICartesianCrosshairSpec |
     protected _showDefaultCrosshair(): void;
     setAttrFromSpec(): void;
     created(): void;
-    _compareSpec(spec: T, prevSpec: T): import("../../model/interface").IUpdateSpecResult;
-    private _isComponentOnlySpecChange;
-    private _isFieldComponentOnlySpecChange;
-    private _isLineComponentOnlySpecChange;
+    _compareSpec(spec: T, prevSpec: T): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
     protected _initEvent(): void;
     private _registerEvent;
     private _eventOff;

package/types/component/custom-mark/custom-mark.d.ts

@@ -18,10 +18,13 @@ export declare class CustomMark extends BaseComponent<ICustomMarkSpec<EnableMark
     protected initMarks(): void;
     private _createExtensionMark;
     initEvent(): void;
-    _compareSpec(spec: ICustomMarkSpec<EnableMarkType>, prevSpec: ICustomMarkSpec<EnableMarkType>): import("../..").IUpdateSpecResult;
-    protected _isComponentOnlySpecChange(spec: ICustomMarkSpec<EnableMarkType>, prevSpec: ICustomMarkSpec<EnableMarkType>): boolean;
-    reInit(spec?: ICustomMarkSpec<EnableMarkType>): void;
-    private _updateMarkStyleWithSpec;
+    _compareSpec(spec: ICustomMarkSpec<EnableMarkType>, prevSpec: ICustomMarkSpec<EnableMarkType>): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
     private _getMarkAttributeContext;
     private _getLayoutRect;
     getBoundsInRect(rect: ILayoutRect): {

package/types/component/data-zoom/data-filter-base-component.d.ts

@@ -76,9 +76,13 @@ export declare abstract class DataFilterBaseComponent<T extends IDataFilterCompo
     created(): void;
     initLayout(): void;
     init(option: IModelInitOption): void;
-    _compareSpec(spec: AdaptiveSpec<T, 'width' | 'height'>, prevSpec: AdaptiveSpec<T, 'width' | 'height'>): import("../../model/interface").IUpdateSpecResult;
-    protected _getComponentOnlySpecKeys(): Record<string, boolean>;
-    protected _isComponentOnlySpecChange(spec: AdaptiveSpec<T, 'width' | 'height'>, prevSpec: AdaptiveSpec<T, 'width' | 'height'>): boolean;
+    _compareSpec(spec: AdaptiveSpec<T, 'width' | 'height'>, prevSpec: AdaptiveSpec<T, 'width' | 'height'>): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
     reInit(spec?: AdaptiveSpec<T, 'width' | 'height'>): void;
     onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect): void;
     updateLayoutAttribute(): void;

package/types/component/data-zoom/data-zoom/data-zoom.d.ts

@@ -36,7 +36,6 @@ export declare class DataZoom<T extends IDataZoomSpec = IDataZoomSpec> extends D
     created(): void;
     updateLayoutAttribute(): void;
     protected _beforeLayoutEnd(): void;
-    protected _getComponentOnlySpecKeys(): Record<string, boolean>;
     clear(): void;
     getBoundsInRect(rect: ILayoutRect): IBoundsLike;
     setAttrFromSpec(): void;

package/types/component/data-zoom/scroll-bar/scroll-bar.d.ts

@@ -22,7 +22,6 @@ export declare class ScrollBar<T extends IScrollBarSpec = IScrollBarSpec> extend
     constructor(spec: T, options: IComponentOption);
     protected _handleChange(start: number, end: number, updateComponent?: boolean): void;
     protected _handleDataCollectionChange(): void;
-    protected _getComponentOnlySpecKeys(): Record<string, boolean>;
     protected _beforeLayoutEnd(): void;
     onLayoutEnd(): void;
     protected _updateScaleRange(): void;

package/types/component/geo/geo-coordinate.d.ts

@@ -52,7 +52,13 @@ export declare class GeoCoordinate extends BaseComponent<IGeoRegionSpec> impleme
     invert(point: [number, number]): any;
     private evaluateProjection;
     protected _initCenterCache(): void;
-    _compareSpec(spec: IGeoRegionSpec, prevSpec: IGeoRegionSpec): import("../../model/interface").IUpdateSpecResult;
+    _compareSpec(spec: IGeoRegionSpec, prevSpec: IGeoRegionSpec): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
     release(): void;
 }
 export declare const registerGeoCoordinate: () => void;

package/types/component/indicator/indicator.d.ts

@@ -27,7 +27,6 @@ export declare class Indicator<T extends IIndicatorSpec> extends BaseComponent<T
     static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
     created(): void;
     setAttrFromSpec(): void;
-    _compareSpec(spec: T, prevSpec: T): import("../../model/interface").IUpdateSpecResult;
     protected initEvent(): void;
     updateDatum(datum: any): void;
     private initData;

package/types/component/indicator/util.d.ts

@@ -2,13 +2,12 @@ import type { IIndicatorItemSpec } from './interface';
 export interface IIndicatorDatum {
     type: 'title' | 'content';
     index: number;
-    datum: unknown;
+    datum: any;
     spec: IIndicatorItemSpec;
 }
 export interface IIndicatorMapper {
     title: IIndicatorItemSpec;
     content: IIndicatorItemSpec[];
-    datum: () => unknown;
+    datum: () => any;
 }
-export type IndicatorMapperOption = IIndicatorMapper | (() => IIndicatorMapper);
-export declare const indicatorMapper: (data: Array<unknown>, op: IndicatorMapperOption) => IIndicatorDatum[];
+export declare const indicatorMapper: (data: Array<any>, op: IIndicatorMapper) => any[];

package/types/component/label/base-label.d.ts

@@ -22,7 +22,13 @@ export declare abstract class BaseLabelComponent<T = any> extends BaseComponent<
             selected_reverse?: Partial<import("../../core").IComposedTextMarkSpec>;
         };
     };
-    _compareSpec(spec: T, prevSpec: T): import("../../core").IUpdateSpecResult;
+    _compareSpec(spec: T, prevSpec: T): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
     _getDataLabelType(baseMark: ICompilableMark, type?: string): string;
     _setTransformOfComponent(labelComponent: IComponentMark, baseMark: IMark | IMark[]): void;
     getVRenderComponents(): any[];

package/types/component/legend/base-legend.d.ts

@@ -31,8 +31,13 @@ export declare abstract class BaseLegend<T extends ILegendCommonSpec> extends Ba
     protected _regionUserIndex?: number[];
     setAttrFromSpec(): void;
     created(): void;
-    _compareSpec(spec: T, prevSpec: T): import("../../model/interface").IUpdateSpecResult;
-    private _isComponentOnlySpecChange;
+    _compareSpec(spec: T, prevSpec: T): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
     protected abstract _initLegendData(): DataView;
     protected abstract _initSelectedData(): void;
     protected abstract _getLegendAttributes(rect: ILayoutRect): any;

package/types/component/marker/base-marker.d.ts

@@ -19,8 +19,6 @@ export declare abstract class BaseMarker<T extends IMarkerSpec> extends BaseComp
     getRelativeSeries(): IMarkerSupportSeries;
     protected _markerData: DataView;
     getMarkerData(): DataView;
-    private _markerDataChangeHandler;
-    private _markerDataOwned;
     protected _markerComponent: any;
     protected _layoutOffsetX: number;
     protected _layoutOffsetY: number;
@@ -40,10 +38,6 @@ export declare abstract class BaseMarker<T extends IMarkerSpec> extends BaseComp
         getStartRelativeSeries: () => IMarkerSupportSeries;
         getEndRelativeSeries: () => IMarkerSupportSeries;
     };
-    protected _getAutoRangeExtendDomainKeyPrefix(): string;
-    private _getAutoRangeExtendDomainKey;
-    private _clearAutoRangeExtendDomain;
-    private _updateMarkerLayout;
     private _getFieldInfoFromSpec;
     protected _processSpecByDims(dimSpec: {
         dim: 'x' | 'y' | 'angle' | 'radius' | 'areaName';
@@ -55,21 +49,20 @@ export declare abstract class BaseMarker<T extends IMarkerSpec> extends BaseComp
     };
     protected _processSpecCoo(spec: any): IOptionWithCoordinates;
     protected _getRelativeDataView(): DataView;
-    protected _setMarkerData(data: DataView, owned?: boolean): void;
-    protected _bindMarkerDataChange(): void;
-    private _releaseMarkerData;
     updateLayoutAttribute(): void;
     private _getSeriesByIdOrIndex;
     protected _bindSeries(): void;
     protected initEvent(): void;
     clear(): void;
-    release(): void;
     private _getFirstSeries;
     protected _getNeedClearVRenderComponents(): IGraphic[];
     onLayoutStart(layoutRect: IRect, chartViewRect: ILayoutRect): void;
-    _compareSpec(spec: T, prevSpec: T): import("../../model/interface").IUpdateSpecResult;
-    protected _isComponentOnlySpecChange(spec: T, prevSpec: T): boolean;
-    protected _isAutoRangeSpecChange(spec: T, prevSpec: T): boolean;
-    reInit(spec?: T): void;
+    _compareSpec(spec: T, prevSpec: T): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
     _initCommonDataView(): void;
 }

package/types/component/marker/utils.d.ts

@@ -5,11 +5,11 @@ import type { IDataPos, IMarkerAttributeContext, IMarkerLabelSpec, IMarkerState,
 import type { IRegion } from '../../region/interface';
 import type { OffsetPoint } from './interface';
 export declare function isAggrSpec(spec: IDataPos): boolean;
-export declare function xyLayout(data: DataView, startRelativeSeries: IMarkerSupportSeries, endRelativeSeries: IMarkerSupportSeries, relativeSeries: IMarkerSupportSeries, autoRange: boolean, includeFullBand?: boolean, autoRangeExtendDomainKeyPrefix?: string): IPoint[][];
-export declare function polarLayout(data: DataView, startRelativeSeries: IMarkerSupportSeries, endRelativeSeries: IMarkerSupportSeries, relativeSeries: IMarkerSupportSeries, autoRange: boolean, autoRangeExtendDomainKeyPrefix?: string): IPolarPoint[][];
+export declare function xyLayout(data: DataView, startRelativeSeries: IMarkerSupportSeries, endRelativeSeries: IMarkerSupportSeries, relativeSeries: IMarkerSupportSeries, autoRange: boolean, includeFullBand?: boolean): IPoint[][];
+export declare function polarLayout(data: DataView, startRelativeSeries: IMarkerSupportSeries, endRelativeSeries: IMarkerSupportSeries, relativeSeries: IMarkerSupportSeries, autoRange: boolean): IPolarPoint[][];
 export declare function geoLayout(data: DataView, relativeSeries: IMarkerSupportSeries): IPoint[][];
-export declare function cartesianCoordinateLayout(data: DataView, relativeSeries: IMarkerSupportSeries, autoRange: boolean, coordinatesOffset: OffsetPoint[] | OffsetPoint, autoRangeExtendDomainKeyPrefix?: string): IPoint[];
-export declare function polarCoordinateLayout(data: DataView, relativeSeries: IMarkerSupportSeries, autoRange: boolean, autoRangeExtendDomainKeyPrefix?: string): IPolarPoint[];
+export declare function cartesianCoordinateLayout(data: DataView, relativeSeries: IMarkerSupportSeries, autoRange: boolean, coordinatesOffset: OffsetPoint[] | OffsetPoint): IPoint[];
+export declare function polarCoordinateLayout(data: DataView, relativeSeries: IMarkerSupportSeries, autoRange: boolean): IPolarPoint[];
 export declare function positionLayout(positions: MarkerPositionPoint | MarkerPositionPoint[] | ((seriesData: Datum[], relativeSeries: IMarkerSupportSeries) => MarkerPositionPoint) | ((seriesData: Datum[], relativeSeries: IMarkerSupportSeries) => MarkerPositionPoint[]), series: IMarkerSupportSeries, regionRelative: boolean): IPoint[];
 export declare function computeClipRange(regions: IRegion[]): {
     minX: number;

package/types/component/player/player.d.ts

@@ -29,7 +29,6 @@ export declare class Player extends BaseComponent<IPlayer> implements IComponent
     get orient(): IOrientType;
     set layoutOrient(v: IOrientType);
     setAttrFromSpec(): void;
-    _compareSpec(spec: IPlayer, prevSpec: IPlayer): import("../../model/interface").IUpdateSpecResult;
     afterSetLayoutStartPoint(pos: IPoint): void;
     getBoundsInRect(rect: ILayoutRect, fullSpace: ILayoutRect): {
         x1: number;

package/types/component/title/title.d.ts

@@ -24,7 +24,13 @@ export declare class Title<T extends ITitleSpec = ITitleSpec> extends BaseCompon
     constructor(spec: T, options: IComponentOption);
     initLayout(): void;
     static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
-    _compareSpec(spec: T, prevSpec: T): import("../../model/interface").IUpdateSpecResult;
+    _compareSpec(spec: T, prevSpec: T): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
     afterSetLayoutStartPoint(pos: IPoint): void;
     getBoundsInRect(rect: ILayoutRect): {
         x1: number;

package/types/component/tooltip/tooltip.d.ts

@@ -45,7 +45,6 @@ export declare class Tooltip extends BaseComponent<any> implements ITooltip {
     protected _releaseEvent(): void;
     onLayoutEnd(): void;
     created(): void;
-    _compareSpec(spec: ITooltipSpec, prevSpec: ITooltipSpec): import("../../model/interface").IUpdateSpecResult;
     release(): void;
     beforeRelease(): void;
     protected _initHandler(): void;

package/types/core/vchart.d.ts

@@ -8,7 +8,7 @@ import type { IComponentConstructor } from '../component/interface';
 import type { EventCallback, EventQuery, EventType, ExtendEventParam, IEvent } from '../event/interface';
 import type { IParserOptions, Transform } from '@visactor/vdataset';
 import { DataSet, DataView } from '@visactor/vdataset';
-import type { IGraphic, IStage } from '@visactor/vrender-core';
+import type { IStage } from '@visactor/vrender-core';
 import type { GeoSourceType } from '../typings/geo';
 import type { GeoSourceOption } from '../series/map/geo-source';
 import type { IMark, MarkConstructor } from '../mark/interface';
@@ -78,7 +78,6 @@ export declare class VChart implements IVChart {
     private _onError?;
     private _context;
     private _isReleased;
-    private _exitingVRenderComponents?;
     private _chartPlugin?;
     private _vChartPlugin?;
     private _onResize?;
@@ -111,9 +110,6 @@ export declare class VChart implements IVChart {
     protected _renderAsync(option?: IVChartRenderOption): Promise<IVChart>;
     private _updateAnimateState;
     release(): void;
-    _registerExitingVRenderComponent(component: IGraphic): void;
-    _unregisterExitingVRenderComponent(component: IGraphic): void;
-    private _forceReleaseExitingVRenderComponents;
     updateData(id: StringOrNumber, data: DataView | Datum[] | string, parserOptions?: IParserOptions, userUpdateOptions?: IUpdateDataResult): Promise<IVChart>;
     private _updateDataById;
     updateDataInBatches(list: {

package/types/data/transforms/box-plot.d.ts

@@ -1,9 +1,6 @@
-import type { DataView } from '@visactor/vdataset';
 export interface IBoxPlotOutlierOpt {
     dimensionField: string[];
     outliersField: string;
     seriesField?: string;
 }
-type BoxPlotOutlierOption = IBoxPlotOutlierOpt | (() => IBoxPlotOutlierOpt);
-export declare const foldOutlierData: (data: Array<DataView>, op: BoxPlotOutlierOption) => Record<string, unknown>[];
-export {};
+export declare const foldOutlierData: (data: Array<DataView>, op: IBoxPlotOutlierOpt) => any;

package/types/data/transforms/correlation-center.d.ts

@@ -1,10 +1,4 @@
-type CorrelationCenterOptionValue<T> = T | (() => T);
-type CorrelationCenterData = Array<{
-    latestData: Array<Record<string, unknown>>;
-}>;
-export interface ICorrelationCenterOpt {
-    keyword: CorrelationCenterOptionValue<string>;
-    categoryField: CorrelationCenterOptionValue<string>;
-}
-export declare const correlationCenter: (data: CorrelationCenterData, options: ICorrelationCenterOpt) => Record<string, unknown> | [];
-export {};
+export declare const correlationCenter: (data: any, options: any) => {
+    [x: string]: any;
+    [x: number]: any;
+};

package/types/data/transforms/correlation.d.ts

@@ -1,20 +1,17 @@
-type CorrelationOptionValue<T> = T | (() => T);
 export interface ICorrelationOpt {
-    view: () => {
-        x0: number;
-        x1: number;
-        y0: number;
-        y1: number;
-    };
-    field: CorrelationOptionValue<string>;
-    radiusField?: CorrelationOptionValue<string | undefined>;
-    radiusRange?: CorrelationOptionValue<[number, number] | undefined>;
-    center?: CorrelationOptionValue<[string | number, string | number] | undefined>;
-    startAngle?: CorrelationOptionValue<number | undefined>;
-    endAngle?: CorrelationOptionValue<number | undefined>;
-    innerRadius?: CorrelationOptionValue<string | number | undefined>;
-    outerRadius?: CorrelationOptionValue<string | number | undefined>;
+    field: string;
+    radiusField?: string;
+    radiusRange?: [number, number];
+    center?: [string | number, string | number];
+    startAngle?: number;
+    endAngle?: number;
+    innerRadius?: string | number;
+    outerRadius?: string | number;
 }
-export type CircularRelationItem = Record<string, unknown>;
-export declare const correlation: (data: unknown, options: ICorrelationOpt) => unknown;
-export {};
+export interface CircularRelationItem {
+    x: number;
+    y: number;
+    size: number;
+    datum: any;
+}
+export declare const correlation: (data: any, options: any) => any;