@visactor/vchart-types 2.1.0-alpha.0 → 2.1.0-alpha.10

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

@@ -8,6 +8,7 @@ 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;
@@ -16,6 +17,8 @@ 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,6 +30,7 @@ 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;
@@ -118,17 +119,32 @@ export declare class BaseChart<T extends IChartSpec> extends CompilableBase impl
     updateGlobalScale(result: IUpdateSpecResult): void;
     updateGlobalScaleTheme(): void;
     private _getSpecKeys;
-    updateSpec(spec: T): {
-        change: boolean;
-        reMake: boolean;
-        reRender: boolean;
-        reSize: boolean;
-        reCompile: boolean;
-    };
+    updateSpec(spec: T): IUpdateSpecResult;
     updateChartConfig(result: IUpdateSpecResult, oldSpec: IChartSpec): void;
     updateDataSpec(): void;
     updateRegionSpec(result: IUpdateSpecResult): void;
-    updateComponentSpec(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;
     updateSeriesSpec(result: IUpdateSpecResult): void;
     getCanvas(): HTMLCanvasElement;
     private _updateLayoutRect;
@@ -142,7 +158,7 @@ export declare class BaseChart<T extends IChartSpec> extends CompilableBase impl
     compileRegions(): void;
     compileSeries(): void;
     compileComponents(): void;
-    release(): void;
+    release(forceReleaseVRenderComponents?: boolean): 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,6 +112,7 @@ 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 { IUpdateSpecResult } from '../model/interface';
+import type { IUpdateSpecEffects, IUpdateSpecResult } from '../model/interface';
 export declare function setDefaultCrosshairForCartesianChart(spec: ICartesianChartSpec): void;
 export declare function calculateChartSize(spec: {
     width?: number;
@@ -13,6 +13,9 @@ 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/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(): void;
+    removeProduct(_releaseDetach?: boolean): 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(): void;
+    abstract removeProduct(releaseDetach?: boolean): 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: () => void;
+    removeProduct: (releaseDetach?: boolean) => void;
     setTransform: (transform: ITransformSpec[]) => void;
 }
 export type GrammarItemInitOption = ICompilableInitOption;

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

@@ -82,13 +82,8 @@ 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): {
-        change: boolean;
-        reMake: boolean;
-        reRender: boolean;
-        reSize: boolean;
-        reCompile: boolean;
-    };
+    _compareSpec(spec: T, prevSpec: T): import("../..").IUpdateSpecResult;
+    private _isComponentOnlySpecChange;
     protected _getAxisAttributes(): any;
     protected _getGridAttributes(): {
         alternateColor: any;

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

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

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

@@ -18,6 +18,7 @@ export declare class PolarBandAxis<T extends IPolarBandAxisSpec = IPolarBandAxis
     };
     protected _scale: BandScale;
     protected _scales: BandScale[];
+    protected _updateData: () => void;
     protected computeDomain(data: {
         min: number;
         max: number;
@@ -37,6 +38,7 @@ 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): {
-        change: boolean;
-        reMake: boolean;
-        reRender: boolean;
-        reSize: boolean;
-        reCompile: boolean;
-    };
+    _compareSpec(spec: T, prevSpec: T): import("../../model/interface").IUpdateSpecResult;
+    beforeRelease(): void;
     release(): void;
+    protected _shouldReleaseVRenderComponentsImmediately(): boolean;
+    protected _forceReleaseExitingVRenderComponents(): void;
+    protected _releaseVRenderComponent(component: IGraphic): void;
     clear(): void;
     compile(): void;
     compileMarks(group?: IGroup): void;

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

@@ -0,0 +1,10 @@
+import type { IGraphic } from '@visactor/vrender-core';
+type ReleaseVRenderComponentOptions = {
+    enableExitAnimation?: boolean;
+    removeFromParent?: boolean;
+    onComplete?: () => void;
+};
+export declare const releaseVRenderComponentSync: (component: IGraphic, removeFromParent?: boolean) => void;
+export declare const collectVRenderComponents: (component: IGraphic) => IGraphic[];
+export declare const releaseVRenderComponent: (component: IGraphic, options?: ReleaseVRenderComponentOptions) => boolean;
+export {};

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

@@ -48,6 +48,7 @@ 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;
@@ -55,13 +56,8 @@ export declare class Brush<T extends IBrushSpec = IBrushSpec> extends BaseCompon
     private _initRegionAxisMap;
     private _initAxisDataZoomMap;
     protected initEvent(): void;
-    _compareSpec(spec: T, prevSpec: T): {
-        change: boolean;
-        reMake: boolean;
-        reRender: boolean;
-        reSize: boolean;
-        reCompile: boolean;
-    };
+    _compareSpec(spec: T, prevSpec: T): import("../../model/interface").IUpdateSpecResult;
+    protected _isComponentOnlySpecChange(spec: T, prevSpec: T): boolean;
     onLayoutEnd(): void;
     protected _updateBrushComponent(region: IRegion, componentIndex: number): void;
     protected _shouldEnableInteractive(): boolean;

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

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

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

@@ -18,13 +18,10 @@ export declare class CustomMark extends BaseComponent<ICustomMarkSpec<EnableMark
     protected initMarks(): void;
     private _createExtensionMark;
     initEvent(): void;
-    _compareSpec(spec: ICustomMarkSpec<EnableMarkType>, prevSpec: ICustomMarkSpec<EnableMarkType>): {
-        change: boolean;
-        reMake: boolean;
-        reRender: boolean;
-        reSize: boolean;
-        reCompile: boolean;
-    };
+    _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;
     private _getMarkAttributeContext;
     private _getLayoutRect;
     getBoundsInRect(rect: ILayoutRect): {

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

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

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

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

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

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

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

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

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

@@ -19,6 +19,8 @@ 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;
@@ -38,6 +40,10 @@ 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';
@@ -49,20 +55,21 @@ 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): {
-        change: boolean;
-        reMake: boolean;
-        reRender: boolean;
-        reSize: boolean;
-        reCompile: boolean;
-    };
+    _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;
     _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): IPoint[][];
-export declare function polarLayout(data: DataView, startRelativeSeries: IMarkerSupportSeries, endRelativeSeries: IMarkerSupportSeries, relativeSeries: IMarkerSupportSeries, autoRange: boolean): IPolarPoint[][];
+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 geoLayout(data: DataView, relativeSeries: IMarkerSupportSeries): IPoint[][];
-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 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 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,6 +29,7 @@ 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,13 +24,7 @@ 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): {
-        change: boolean;
-        reMake: boolean;
-        reRender: boolean;
-        reSize: boolean;
-        reCompile: boolean;
-    };
+    _compareSpec(spec: T, prevSpec: T): import("../../model/interface").IUpdateSpecResult;
     afterSetLayoutStartPoint(pos: IPoint): void;
     getBoundsInRect(rect: ILayoutRect): {
         x1: number;

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

@@ -45,6 +45,7 @@ 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 { IStage } from '@visactor/vrender-core';
+import type { IGraphic, 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,6 +78,7 @@ export declare class VChart implements IVChart {
     private _onError?;
     private _context;
     private _isReleased;
+    private _exitingVRenderComponents?;
     private _chartPlugin?;
     private _vChartPlugin?;
     private _onResize?;
@@ -110,6 +111,9 @@ 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/data-view-utils.d.ts

@@ -0,0 +1,5 @@
+import type { DataView } from '@visactor/vdataset';
+export declare const detachDataViewDependencies: (dataView?: DataView | null) => void;
+export declare const releaseDataViews: (dataViews: Array<DataView | null | undefined>) => void;
+export declare const releaseDataView: (dataView?: DataView | null) => void;
+export declare const releaseDataViewWithDependencies: (dataView: DataView | null | undefined, shouldReleaseDependency: (dataView: DataView) => boolean) => void;

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

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

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

@@ -1,4 +1,10 @@
-export declare const correlationCenter: (data: any, options: any) => {
-    [x: string]: any;
-    [x: number]: any;
-};
+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 {};

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

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