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

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,22 @@ 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 _canRemoveMarkerComponentsWithoutRemake;
+    private _isOnlyMarkerComponentsRemoved;
+    private _isComponentSpecKey;
+    private _isOnlyComponentSpecsChanged;
+    private _isOnlySeriesSpecsChanged;
+    private _canSkipChartDataStages;
+    private _removeMarkerComponentsForEmptySpecs;
+    private _removeComponent;
     updateSeriesSpec(result: IUpdateSpecResult): void;
     getCanvas(): HTMLCanvasElement;
     private _updateLayoutRect;
@@ -142,7 +148,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/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,7 @@ 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;
     onLayoutEnd(): void;
     protected _updateBrushComponent(region: IRegion, componentIndex: number): void;
     protected _shouldEnableInteractive(): boolean;

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

@@ -41,13 +41,7 @@ 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;
     protected _initEvent(): void;
     private _registerEvent;
     private _eventOff;

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

@@ -18,13 +18,7 @@ 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;
     private _getMarkAttributeContext;
     private _getLayoutRect;
     getBoundsInRect(rect: ILayoutRect): {

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

@@ -76,13 +76,7 @@ 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;
     reInit(spec?: AdaptiveSpec<T, 'width' | 'height'>): void;
     onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect): void;
     updateLayoutAttribute(): 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/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;
@@ -49,20 +51,18 @@ 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;
     _initCommonDataView(): void;
 }

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/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/mark/base/base-mark.d.ts

@@ -5,7 +5,7 @@ import { MarkTypeEnum } from '../interface';
 import type { IMarkRaw, IMarkStateStyle, IMarkStyle, IMark, IMarkOption, StyleConvert, MarkInputStyle, GroupedData, IAttrs, IMarkGraphic, ProgressiveContext, IProgressiveTransformResult, MarkType, AnimationStateValues } from '../interface';
 import type { ICompilableMark, IMarkCompileOption, IMarkConfig, IMarkStateManager, StateValueType } from '../../compile/mark/interface';
 import type { ICompilableInitOption } from '../../compile/interface';
-import type { IGroupGraphicAttribute, IGroup, IGraphic } from '@visactor/vrender-core';
+import type { IGroupGraphicAttribute, IGroup, IGraphic, StateDefinitionsInput } from '@visactor/vrender-core';
 import { GrammarItem } from '../../compile/grammar-item';
 import type { IModel } from '../../model/interface';
 import type { ICompilableData } from '../../compile/data/interface';
@@ -74,7 +74,7 @@ export declare class BaseMark<T extends ICommonSpec> extends GrammarItem impleme
     stopAnimationByState(state?: string): void;
     pauseAnimationByState(state?: string): void;
     resumeAnimationByState(state?: string): void;
-    removeProduct(): void;
+    removeProduct(releaseDetach?: boolean): void;
     release(): void;
     protected _simpleStyle: T;
     setSimpleStyle(s: T): void;
@@ -82,6 +82,11 @@ export declare class BaseMark<T extends ICommonSpec> extends GrammarItem impleme
     protected _option: IMarkOption;
     protected _attributeContext: IModelMarkAttributeContext;
     protected _encoderOfState: Record<string, Record<string, (datum: Datum) => any>>;
+    protected _sharedStateDefinitionsCacheKey?: string;
+    protected _sharedStateDefinitionsCache?: StateDefinitionsInput<Record<string, unknown>>;
+    protected _sharedStateDefinitionRefIds: WeakMap<object, number>;
+    protected _sharedStateDefinitionRefId: number;
+    protected _dynamicSharedStateNames: Set<string>;
     _extensionChannel: {
         [key: string | number | symbol]: string[];
     };
@@ -155,9 +160,14 @@ export declare class BaseMark<T extends ICommonSpec> extends GrammarItem impleme
     protected _getEncoderOfStyle: (stateName: string, style: Partial<IAttrs<T>>) => Record<string, (datum: Datum) => any>;
     protected _setGraphicFromMarkConfig: (g: IMarkGraphic) => void;
     protected _setStateOfGraphic: (g: IMarkGraphic, hasAnimation?: boolean) => void;
+    protected _getSharedStateDefinitionRefId(value: unknown): string;
+    protected _getSharedStateDefinitionValueKey(value: unknown): string;
+    protected _isStaticSharedStateAttribute(stateName: string, key: string): boolean;
     protected _applySharedStateDefinitions(): void;
     protected _addProgressiveGraphic(parent: IGroup, g: IMarkGraphic): void;
     protected _runEncoder(graphics: IMarkGraphic[], noGroupEncode?: boolean): void;
+    protected _excludeStateControlledDiffAttrs(g: IMarkGraphic, diffAttrs: Record<string, any>): Record<string, any>;
+    protected _hasDiffAttrs(g: IMarkGraphic): boolean;
     protected _runApplyGraphic(graphics: IMarkGraphic[]): void;
     protected _updateEncoderByState(): void;
     protected _runState(graphics: IMarkGraphic[]): void;

package/types/mark/component.d.ts

@@ -8,11 +8,20 @@ export declare class ComponentMark extends BaseMark<ICommonSpec> implements ICom
     type: string;
     private _componentType;
     private _component;
+    private _exitingComponent?;
+    private _exitingProduct?;
     private _mode;
     constructor(name: string, option: IMarkOption);
     protected _getDefaultStyle(): IMarkStyle<ICommonSpec>;
     getComponent(): IGraphic<Partial<import("@visactor/vrender-core").IGraphicAttribute>>;
+    private _clearExitingComponent;
+    private _removeProductAfterExit;
+    private _registerExitingComponent;
+    private _unregisterExitingComponent;
+    private _releaseComponentWithExitAnimation;
     clearComponent(): void;
+    releaseWithExitAnimation(): boolean;
+    forceReleaseExitAnimation(): void;
     protected _getAttrsFromConfig(attrs?: IGroupGraphicAttribute): IGroupGraphicAttribute;
     protected _attributesTransform: (attrs: any) => any;
     setAttributeTransform(t: (attrs: any) => any): void;

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

@@ -6,6 +6,8 @@ import type { MarkType } from './type';
 export interface IComponentMark extends IMarkRaw<ICommonSpec> {
     getComponent: () => IGraphic;
     clearComponent: () => void;
+    releaseWithExitAnimation: () => boolean;
+    forceReleaseExitAnimation: () => void;
     setAttributeTransform: (t: (attrs: any) => any) => any;
 }
 export interface IGlyphMark<T extends ICommonSpec = ICommonSpec, C = any> extends IMarkRaw<T> {

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

@@ -1,5 +1,5 @@
 import type { IEvent } from '../event/interface';
-import type { IEffect, IModel, IModelInitOption, IModelOption, IModelEvaluateOption, IModelSpec, IModelMarkInfo, IModelSpecInfo } from './interface';
+import type { IEffect, IModel, IModelInitOption, IModelOption, IModelEvaluateOption, IModelSpec, IModelMarkInfo, IModelSpecInfo, IUpdateSpecResult } from './interface';
 import type { CoordinateType } from '../typings/coordinate';
 import type { AnimationStateValues, ICompileMarkConfig, IMark, IMarkGraphic, IMarkOption, IMarkRaw, IMarkStyle } from '../mark/interface';
 import type { Datum, StateValueType, ConvertToMarkStyleSpec, ICommonSpec, StringOrNumber, IRect, ILayoutRect } from '../typings';
@@ -50,20 +50,8 @@ export declare abstract class BaseModel<T extends IModelSpec> extends Compilable
     beforeRelease(): void;
     clear(): void;
     release(): void;
-    updateSpec(spec: T): {
-        change: boolean;
-        reMake: boolean;
-        reRender: boolean;
-        reSize: boolean;
-        reCompile: boolean;
-    };
-    protected _compareSpec(spec: T, prevSpec: T): {
-        change: boolean;
-        reMake: boolean;
-        reRender: boolean;
-        reSize: boolean;
-        reCompile: boolean;
-    };
+    updateSpec(spec: T): IUpdateSpecResult;
+    protected _compareSpec(spec: T, prevSpec: T): IUpdateSpecResult;
     reInit(spec?: T): void;
     updateLayoutAttribute(): void;
     setAttrFromSpec(): void;

package/types/model/interface.d.ts

@@ -33,6 +33,18 @@ export interface IModelRenderOption {
 export interface IEffect {
     [key: string]: (e?: any) => any;
 }
+export interface IUpdateSpecEffects {
+    remake?: boolean;
+    compile?: boolean;
+    render?: boolean;
+    layout?: boolean;
+    data?: boolean;
+    scaleDomain?: boolean;
+    series?: boolean;
+    component?: boolean;
+    animation?: boolean;
+    localOnly?: boolean;
+}
 export interface IMarkTreeGroup extends Partial<IMarkStyle<IGroupMarkSpec>> {
     type: 'group';
     name: string;
@@ -46,6 +58,7 @@ export interface IUpdateSpecResult {
     reSize?: boolean;
     reCompile?: boolean;
     reTransformSpec?: boolean;
+    effects?: IUpdateSpecEffects;
     reAnimate?: boolean;
     changeTheme?: boolean;
     changeBackground?: boolean;

package/types/region/region.d.ts

@@ -39,13 +39,7 @@ export declare class Region<T extends IRegionSpec = IRegionSpec> extends LayoutM
     initMark(): void;
     protected _initBackgroundMarkStyle(): void;
     protected _initForegroundMarkStyle(): 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;
     reInit(spec?: T): void;
     addSeries(s: ISeries): void;
     removeSeries(s: ISeries): void;

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

@@ -7,6 +7,7 @@ import { SeriesTypeEnum } from '../interface/type';
 import type { IAreaSeriesSpec, IAreaSeriesTheme } from './interface';
 import type { IMark, IAreaMark } from '../../mark/interface';
 import { AreaSeriesSpecTransformer } from './area-transformer';
+import type { ISeriesSpecUpdatePolicy } from '../base/base-series';
 export interface AreaSeries<T extends IAreaSeriesSpec = IAreaSeriesSpec> extends Pick<LineLikeSeriesMixin, 'initLineMark' | 'initSymbolMark' | 'initLabelMarkStyle' | 'initLineMarkStyle' | 'initSymbolMarkStyle' | 'encodeDefined' | '_lineMark' | '_symbolMark' | 'addSamplingCompile' | 'addOverlapCompile' | 'reCompileSampling' | 'initLineLabelMarkStyle'>, CartesianSeries<T> {
 }
 export declare class AreaSeries<T extends IAreaSeriesSpec = IAreaSeriesSpec> extends CartesianSeries<T> {
@@ -18,6 +19,7 @@ export declare class AreaSeries<T extends IAreaSeriesSpec = IAreaSeriesSpec> ext
     readonly transformerConstructor: typeof AreaSeriesSpecTransformer;
     protected _areaMark: IAreaMark;
     protected _sortDataByAxis: boolean;
+    protected _getSpecUpdatePolicy(): ISeriesSpecUpdatePolicy;
     initMark(): void;
     initMarkStyle(): void;
     initAreaMarkStyle(): void;

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

@@ -1,5 +1,6 @@
 import type { IBaseScale } from '@visactor/vscale';
 import { CartesianSeries } from '../cartesian/cartesian';
+import type { ISeriesSpecUpdatePolicy } from '../base/base-series';
 import type { IMark, IRectMark, ITextMark } from '../../mark/interface';
 import type { Datum, DirectionType } from '../../typings';
 import type { IBarSeriesSpec, IBarSeriesTheme } from './interface';
@@ -24,9 +25,11 @@ export declare class BarSeries<T extends IBarSeriesSpec = IBarSeriesSpec> extend
     protected _barMark: IRectMark;
     protected _barBackgroundMark: IRectMark;
     protected _barBackgroundViewData: ICompilableData;
+    protected _getSpecUpdatePolicy(): ISeriesSpecUpdatePolicy;
     initMark(): void;
     protected _initBarBackgroundMark(): void;
     initMarkStyle(): void;
+    protected initRectMarkStyle(): void;
     initLabelMarkStyle(textMark: ITextMark): void;
     protected initTooltip(): void;
     protected _statisticViewData(): void;

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

@@ -16,6 +16,12 @@ import type { StatisticOperations } from '../../data/transforms/interface';
 import type { GraphicEventType } from '@visactor/vrender-core';
 import type { ICompilableData } from '../../compile/data';
 import type { IBaseTriggerOptions } from '../../interaction/interface/trigger';
+export interface ISeriesSpecUpdatePolicy {
+    compileOnlyKeys?: Record<string, true>;
+    dataRelatedKeys?: Record<string, true>;
+    compileOnlySubKeys?: Record<string, Record<string, true>>;
+}
+export declare function markSeriesCompileEffect(compareResult: IUpdateSpecResult, dataRelated?: boolean): void;
 export declare abstract class BaseSeries<T extends ISeriesSpec> extends BaseModel<T> implements ISeries {
     readonly specKey: string;
     readonly type: string;
@@ -170,13 +176,8 @@ export declare abstract class BaseSeries<T extends ISeriesSpec> extends BaseMode
     protected initTooltip(): void;
     _compareExtensionMarksSpec(newMarks: (IExtensionMarkSpec<Exclude<EnableMarkType, 'group'>> | IExtensionGroupMarkSpec)[], prevMarks: (IExtensionMarkSpec<Exclude<EnableMarkType, 'group'>> | IExtensionGroupMarkSpec)[], compareResult: IUpdateSpecResult): void;
     _compareLabelSpec(newLabels: ILabelSpec[], prevLabels: ILabelSpec[], compareResult: IUpdateSpecResult): void;
-    _compareSpec(spec: T, prevSpec: T, ignoreCheckKeys?: Record<string, boolean>): {
-        change: boolean;
-        reMake: boolean;
-        reRender: boolean;
-        reSize: boolean;
-        reCompile: boolean;
-    };
+    protected _getSpecUpdatePolicy(): ISeriesSpecUpdatePolicy;
+    _compareSpec(spec: T, prevSpec: T, ignoreCheckKeys?: Record<string, boolean>): IUpdateSpecResult;
     _updateSpecData(): void;
     reInit(spec?: T): void;
     onEvaluateEnd(ctx: IModelEvaluateOption): void;

package/types/series/base/constant.d.ts

@@ -10,3 +10,6 @@ export declare const defaultSeriesIgnoreCheckKeys: {
 export declare const defaultSeriesCompileCheckKeys: {
     [key: string]: true;
 };
+export declare const defaultSeriesCompileOnlyCheckKeys: {
+    [key: string]: true;
+};