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

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

@@ -1,6 +1,7 @@
 import type { DataView } from '@visactor/vdataset';
+type FunnelOptionValue<T> = T | (() => T);
 export interface IFunnelOpt {
-    valueField: string;
+    valueField: FunnelOptionValue<string>;
     asTransformRatio: string;
     asReachRatio: string;
     asHeightRatio: string;
@@ -10,12 +11,12 @@ export interface IFunnelOpt {
     asCurrentValue: string;
     asLastValue: string;
     asNextValue: string;
-    isCone?: boolean;
-    heightVisual?: boolean;
-    range?: {
-        min: number;
-        max: number;
-    };
+    isCone?: FunnelOptionValue<boolean | undefined>;
+    heightVisual?: FunnelOptionValue<boolean | undefined>;
+    range?: FunnelOptionValue<{
+        min?: number;
+        max?: number;
+    } | undefined>;
 }
 export declare const funnel: (originData: Array<DataView>, op: IFunnelOpt) => {
     dataSet: import("@visactor/vdataset").DataSet;
@@ -43,4 +44,5 @@ export declare const funnel: (originData: Array<DataView>, op: IFunnelOpt) => {
 export interface IFunnelTransformOpt {
     asIsTransformLevel: string;
 }
-export declare const funnelTransform: (originData: Array<DataView>, op: IFunnelTransformOpt) => any;
+export declare const funnelTransform: (originData: Array<DataView>, op: IFunnelTransformOpt) => Record<string, unknown>[];
+export {};

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

@@ -3,10 +3,10 @@ import type { Datum } from '../../typings';
 export interface ILookUpOpt {
     from: () => object[];
     key: string;
-    fields: string;
+    fields: string | (() => string);
     values?: string[];
     as?: string[];
-    default?: any;
-    set?: (A: Datum, B: Datum) => void;
+    default?: unknown;
+    set?: (A: Datum, B?: Datum) => void;
 }
 export declare const lookup: (data: Array<DataView>, opt: ILookUpOpt) => DataView[];

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

@@ -1,6 +1,12 @@
 import type { GeoSourceType } from '../../typings/geo';
 export interface IMapOpt {
-    nameMap: Record<string, string>;
+    nameMap: Record<string, unknown>;
     nameProperty: string;
 }
-export declare const map: (data: GeoSourceType, opt: IMapOpt) => any;
+type MapFeature = {
+    properties?: Record<string, unknown>;
+    [key: string]: unknown;
+};
+type MapOption = IMapOpt | (() => IMapOpt);
+export declare const map: (data: GeoSourceType, opt: MapOption) => MapFeature[];
+export {};

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

@@ -1,4 +1,4 @@
-import type { SankeyOptions, SankeyData } from '@visactor/vlayouts';
+import { type SankeyOptions, type SankeyData } from '@visactor/vlayouts';
 export interface ISankeyOpt extends SankeyOptions {
     targetField: string;
     sourceField: string;
@@ -10,10 +10,18 @@ export interface ISankeyOpt extends SankeyOptions {
         y1: number;
     };
 }
-export declare const collectHierarchyField: (set: Set<any>, data: any[], field: string) => void;
-export declare const sankeyFormat: (data: any[]) => SankeyData[];
-export declare const sankeyLayout: (data: SankeyData[], op: ISankeyOpt) => {
+type SankeyLayoutOption = ISankeyOpt | (() => ISankeyOpt);
+type SankeyFormatDatum = Record<string, unknown> & {
+    id?: 'links' | 'nodes';
+    values?: unknown;
+    latestData?: SankeyData[];
+    children?: SankeyFormatDatum[];
+};
+export declare const collectHierarchyField: <T>(set: Set<T>, data: SankeyFormatDatum[], field: string) => void;
+export declare const sankeyFormat: (data: SankeyFormatDatum[]) => SankeyData[];
+export declare const sankeyLayout: (data: SankeyData[], op: SankeyLayoutOption) => {
     nodes: import("@visactor/vlayouts").SankeyNodeElement[];
     links: import("@visactor/vlayouts").SankeyLinkElement[];
     columns: import("@visactor/vlayouts").SankeyNodeElement[][];
 }[];
+export {};

package/types/data/transforms/stack-split.d.ts

@@ -3,4 +3,5 @@ import type { DataView } from '@visactor/vdataset';
 export interface IStackOption {
     fields: string[];
 }
-export declare const stackSplit: (data: Array<DataView>, op: IStackOption) => ISeriesStackDataNode;
+export type StackOption = IStackOption | (() => IStackOption);
+export declare const stackSplit: (data: Array<DataView>, op: StackOption) => ISeriesStackDataNode;

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

@@ -1,5 +1,5 @@
-import type { TreemapNodeElement, TreemapOptions } from '@visactor/vlayouts';
-export declare const treemapLayout: (data: Array<any>, op: TreemapOptions & {
+import { type TreemapNodeElement, type TreemapOptions } from '@visactor/vlayouts';
+interface ITreemapLayoutOptions extends TreemapOptions {
     getViewBox: () => {
         x0: number;
         x1: number;
@@ -7,4 +7,6 @@ export declare const treemapLayout: (data: Array<any>, op: TreemapOptions & {
         y1: number;
     };
     nameField: string;
-}) => TreemapNodeElement[];
+}
+export declare const treemapLayout: (data: Array<Record<string, unknown>>, op: ITreemapLayoutOptions | (() => ITreemapLayoutOptions)) => TreemapNodeElement[];
+export {};

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

@@ -1,4 +1,4 @@
-export declare const vennLayout: (data: Array<any>, op: {
+interface IVennLayoutOptions {
     setField: string;
     valueField: string;
     getViewBox: () => {
@@ -7,4 +7,6 @@ export declare const vennLayout: (data: Array<any>, op: {
         y0: number;
         y1: number;
     };
-}) => (import("@visactor/vlayouts").IVennCircleDatum<any> | import("@visactor/vlayouts").IVennOverlapDatum<any>)[];
+}
+export declare const vennLayout: (data: Array<Record<string, unknown>>, op: IVennLayoutOptions | (() => IVennLayoutOptions)) => (import("@visactor/vlayouts").IVennCircleDatum<any> | import("@visactor/vlayouts").IVennOverlapDatum<any>)[];
+export {};

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

@@ -17,7 +17,8 @@ export interface IWaterfallOpt {
     stackInverse: boolean;
     groupData: () => DataView;
 }
-export declare const waterfall: (lastData: Array<Datum>, op: IWaterfallOpt) => Datum[];
+export type WaterfallOption = IWaterfallOpt | (() => IWaterfallOpt);
+export declare const waterfall: (lastData: Array<Datum>, op: WaterfallOption) => Datum[];
 export interface IWaterfallFillEndOpt {
     indexField: string;
     valueField: string;
@@ -25,4 +26,5 @@ export interface IWaterfallFillEndOpt {
     total: IWaterfallSeriesSpec['total'];
     calculationMode: IWaterfallSeriesSpec['calculationMode'];
 }
-export declare const waterfallFillTotal: (data: Array<Datum>, op: IWaterfallFillEndOpt) => Datum[];
+export type WaterfallFillEndOption = IWaterfallFillEndOpt | (() => IWaterfallFillEndOpt);
+export declare const waterfallFillTotal: (data: Array<Datum>, op: WaterfallFillEndOption) => Datum[];

package/types/event/event.d.ts

@@ -4,6 +4,7 @@ export declare class Event implements IEvent {
     private _eventDispatcher;
     private _mode;
     private _composedEventMap;
+    private _eventHandlerMap;
     getComposedEventMap(): Map<EventCallback<EventParams>, {
         eventType: string;
         event: IComposedEvent;
@@ -20,4 +21,7 @@ export declare class Event implements IEvent {
     }): this;
     allow<Evt extends EventType>(eType: Evt): this;
     release(): void;
+    private _addEventHandler;
+    private _getEventHandler;
+    private _removeEventHandler;
 }

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/scale/color-ordinal-scale.d.ts

@@ -2,6 +2,7 @@ import { OrdinalScale } from '@visactor/vscale';
 import type { ColorSchemeItem, ProgressiveDataScheme } from '../theme/color-scheme/interface';
 export declare class ColorOrdinalScale extends OrdinalScale {
     protected _range: Array<ColorSchemeItem> | ProgressiveDataScheme<ColorSchemeItem>;
+    setSpecified(value?: Record<string, unknown>): this;
     range(value?: Array<ColorSchemeItem> | ProgressiveDataScheme<ColorSchemeItem>): this | any;
     domain(value?: any[]): this | any;
     protected _resetRange(): 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,14 @@ 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>>;
+    seriesOnlyKeys?: Record<string, true>;
+}
+export declare function markSeriesCompileEffect(compareResult: IUpdateSpecResult, dataRelated?: boolean): void;
+export declare function markSeriesOnlyEffect(compareResult: IUpdateSpecResult): void;
 export declare abstract class BaseSeries<T extends ISeriesSpec> extends BaseModel<T> implements ISeries {
     readonly specKey: string;
     readonly type: string;
@@ -170,13 +178,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;
+};

package/types/series/box-plot/box-plot.d.ts

@@ -8,6 +8,7 @@ import { DataView } from '@visactor/vdataset';
 import type { IMark, ITextMark } from '../../mark/interface';
 import type { ICompilableData } from '../../compile/data';
 import { BoxPlotSeriesSpecTransformer } from './box-plot-transformer';
+import type { ISeriesSpecUpdatePolicy } from '../base/base-series';
 export declare const DEFAULT_FILL_COLOR = "#FFF";
 export declare const DEFAULT_STROKE_COLOR = "#000";
 export declare class BoxPlotSeries<T extends IBoxPlotSeriesSpec = IBoxPlotSeriesSpec> extends CartesianSeries<T> {
@@ -46,6 +47,7 @@ export declare class BoxPlotSeries<T extends IBoxPlotSeriesSpec = IBoxPlotSeries
     getOutliersStyle(): IOutlierMarkSpec;
     protected _outlierData: ICompilableData;
     private _autoBoxWidth;
+    protected _getSpecUpdatePolicy(): ISeriesSpecUpdatePolicy;
     setAttrFromSpec(): void;
     private _boxPlotMark?;
     private _outlierMark?;

package/types/series/dot/dot.d.ts

@@ -31,6 +31,18 @@ export declare class DotSeries<T extends IDotSeriesSpec = IDotSeriesSpec> extend
     setHighLightSeriesGroup(field: string): void;
     protected _gridBackground?: IFillMarkSpec;
     setGridBackground(gridBackground: IFillMarkSpec): void;
+    protected _getSpecUpdatePolicy(): {
+        compileOnlyKeys: {
+            highLightSeriesGroup: true;
+            titleField: true;
+            subTitleField: true;
+        };
+        compileOnlySubKeys: {
+            grid: Record<"background", true>;
+        };
+        dataRelatedKeys?: Record<string, true>;
+        seriesOnlyKeys?: Record<string, true>;
+    };
     initData(): void;
     getStatisticFields(): {
         key: string;

package/types/series/heatmap/heatmap.d.ts

@@ -5,6 +5,7 @@ import type { SeriesMarkMap } from '../interface';
 import { SeriesTypeEnum } from '../interface/type';
 import type { ICellMark, IMark, ITextMark } from '../../mark/interface';
 import { HeatmapSeriesSpecTransformer } from './heatmap-transformer';
+import type { ISeriesSpecUpdatePolicy } from '../base/base-series';
 export declare const DefaultBandWidth = 6;
 export declare class HeatmapSeries<T extends IHeatmapSeriesSpec = IHeatmapSeriesSpec> extends CartesianSeries<T> {
     static readonly type: string;
@@ -20,6 +21,7 @@ export declare class HeatmapSeries<T extends IHeatmapSeriesSpec = IHeatmapSeries
     protected _fieldValue: string[];
     getFieldValue(): string[];
     setFieldValue(f: string | string[]): void;
+    protected _getSpecUpdatePolicy(): ISeriesSpecUpdatePolicy;
     setAttrFromSpec(): void;
     initMark(): void;
     initMarkStyle(): void;

package/types/series/line/line.d.ts

@@ -6,6 +6,7 @@ import type { Datum } from '../../typings';
 import type { ILineSeriesSpec } from './interface';
 import type { IMark } from '../../mark/interface';
 import { LineLikeSeriesSpecTransformer } from '../mixin/line-mixin-transformer';
+import type { ISeriesSpecUpdatePolicy } from '../base/base-series';
 export interface LineSeries<T extends ILineSeriesSpec = ILineSeriesSpec> extends Pick<LineLikeSeriesMixin, 'initLineMark' | 'initSymbolMark' | 'initLabelMarkStyle' | 'initLineMarkStyle' | 'initSymbolMarkStyle' | '_lineMark' | '_symbolMark' | 'addSamplingCompile' | 'addOverlapCompile' | 'reCompileSampling'>, CartesianSeries<T> {
 }
 export declare class LineSeries<T extends ILineSeriesSpec = ILineSeriesSpec> extends CartesianSeries<T> {
@@ -18,6 +19,7 @@ export declare class LineSeries<T extends ILineSeriesSpec = ILineSeriesSpec> ext
     static readonly transformerConstructor: typeof LineLikeSeriesSpecTransformer;
     readonly transformerConstructor: typeof LineLikeSeriesSpecTransformer;
     protected _sortDataByAxis: boolean;
+    protected _getSpecUpdatePolicy(): ISeriesSpecUpdatePolicy;
     compile(): void;
     initMark(): void;
     protected initTooltip(): void;

package/types/series/mixin/line-mixin.d.ts

@@ -7,6 +7,7 @@ import type { DimensionEventParams } from '../../event/events/dimension';
 import type { IRegion } from '../../region/interface';
 import type { ILineLikeSeriesTheme } from './interface';
 import type { ICompilableData } from '../../compile/data';
+export declare const LINE_LIKE_SERIES_DATA_RELATED_KEYS: Record<string, true>;
 export interface LineLikeSeriesMixin extends ISeries {
     _spec: any;
     _option: ISeriesOption;

package/types/series/pie/pie.d.ts

@@ -1,5 +1,6 @@
 import type { IPoint, Datum, StateValueType } from '../../typings';
 import { PolarSeries } from '../polar/polar';
+import type { ISeriesSpecUpdatePolicy } from '../base/base-series';
 import type { IArcMark, IMark, IPathMark, ITextMark } from '../../mark/interface';
 import type { IArcSeries, SeriesMarkMap } from '../interface';
 import { SeriesTypeEnum } from '../interface/type';
@@ -56,15 +57,10 @@ export declare class BasePieSeries<T extends IBasePieSeriesSpec> extends PolarSe
     getInnerRadius(state?: StateValueType): number;
     computeRadius(r: number, k?: number): number;
     computeDatumRadius(datum: Datum, state?: string): number;
+    protected _getSpecUpdatePolicy(): ISeriesSpecUpdatePolicy;
     _compareSpec(spec: T, prevSpec: T, ignoreCheckKeys?: {
         [key: string]: true;
-    }): {
-        change: boolean;
-        reMake: boolean;
-        reRender: boolean;
-        reSize: boolean;
-        reCompile: boolean;
-    };
+    }): import("../..").IUpdateSpecResult;
     computeDatumInnerRadius(datum: Datum, state?: string): number;
     dataToPosition(datum: Datum, checkInViewData?: boolean): IPoint | null;
     dataToCentralPosition: (datum: Datum) => IPoint | null;

package/types/series/polar/progress-like/progress-like.d.ts

@@ -4,11 +4,13 @@ import { PolarSeries } from '../polar';
 import type { IContinuousTickData, IProgressLikeSeriesSpec } from './interface';
 import type { IPolarAxis } from '../../../component/axis';
 import type { SeriesMarkMap } from '../../interface';
+import type { ISeriesSpecUpdatePolicy } from '../../base/base-series';
 export declare abstract class ProgressLikeSeries<T extends IProgressLikeSeriesSpec> extends PolarSeries<T> {
     static readonly mark: SeriesMarkMap;
     protected _startAngle: number;
     protected _endAngle: number;
     protected _arcGroupMark: IGroupMark | null;
+    protected _getSpecUpdatePolicy(): ISeriesSpecUpdatePolicy;
     setAttrFromSpec(): void;
     getStackGroupFields(): string[];
     getStackValueField(): string;

package/types/series/polar/rose-like/rose-like.d.ts

@@ -1,6 +1,8 @@
 import { PolarSeries } from '../polar';
 import type { IRoseLikeSeriesSpec } from './interface';
+import type { ISeriesSpecUpdatePolicy } from '../../base/base-series';
 export declare abstract class RoseLikeSeries<T extends IRoseLikeSeriesSpec> extends PolarSeries<T> {
+    protected _getSpecUpdatePolicy(): ISeriesSpecUpdatePolicy;
     getStackGroupFields(): string[];
     getStackValueField(): string;
     getGroupFields(): string[];

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

@@ -1,6 +1,7 @@
 import type { Datum } from '../../../typings';
 import type { SeriesMarkMap } from '../../interface';
 import { SeriesTypeEnum } from '../../interface/type';
+import type { ISeriesSpecUpdatePolicy } from '../../base/base-series';
 import type { ICircularProgressSeriesSpec } from './interface';
 import { ProgressLikeSeries } from '../../polar/progress-like/progress-like';
 import type { IMark } from '../../../mark/interface';
@@ -16,6 +17,7 @@ export declare class CircularProgressSeries<T extends ICircularProgressSeriesSpe
     readonly transformerConstructor: typeof CircularProgressSeriesSpecTransformer;
     private _progressMark;
     private _trackMark;
+    protected _getSpecUpdatePolicy(): ISeriesSpecUpdatePolicy;
     getStackGroupFields(): string[];
     getGroupFields(): string[];
     initMark(): void;

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

@@ -3,6 +3,7 @@ import type { SeriesMarkMap } from '../../interface';
 import { SeriesTypeEnum } from '../../interface/type';
 import type { ILinearProgressSeriesSpec } from './interface';
 import type { IMark } from '../../../mark/interface';
+import type { ISeriesSpecUpdatePolicy } from '../../base/base-series';
 export declare class LinearProgressSeries<T extends ILinearProgressSeriesSpec = ILinearProgressSeriesSpec> extends CartesianSeries<T> {
     static readonly type: string;
     type: SeriesTypeEnum;
@@ -12,6 +13,7 @@ export declare class LinearProgressSeries<T extends ILinearProgressSeriesSpec =
     };
     private _progressMark;
     private _trackMark;
+    protected _getSpecUpdatePolicy(): ISeriesSpecUpdatePolicy;
     initMark(): void;
     initMarkStyle(): void;
     private _initProgressMark;

package/types/series/scatter/scatter.d.ts

@@ -2,6 +2,7 @@ import type { DataView } from '@visactor/vdataset';
 import type { IScatterInvalidType } from '../../typings';
 import type { IScatterSeriesSpec } from './interface';
 import { CartesianSeries } from '../cartesian/cartesian';
+import type { ISeriesSpecUpdatePolicy } from '../base/base-series';
 import type { SeriesMarkMap } from '../interface';
 import { SeriesTypeEnum } from '../interface/type';
 import type { ILabelMark, IMark } from '../../mark/interface';
@@ -22,6 +23,7 @@ export declare class ScatterSeries<T extends IScatterSeriesSpec = IScatterSeries
     private _shape;
     private _shapeField;
     protected _invalidType: IScatterInvalidType;
+    protected _getSpecUpdatePolicy(): ISeriesSpecUpdatePolicy;
     setAttrFromSpec(): void;
     private _getSeriesAttribute;
     private getSizeAttribute;

package/types/series/waterfall/waterfall.d.ts

@@ -8,6 +8,7 @@ import type { Datum } from '../../typings';
 import type { ILabelMark, IRuleMark, ITextMark } from '../../mark/interface';
 import type { ILabelInfo } from '../../component/label/interface';
 import { type ICompilableData } from '../../compile/data';
+import type { ISeriesSpecUpdatePolicy } from '../base/base-series';
 export declare const DefaultBandWidth = 6;
 export declare class WaterfallSeries<T extends IWaterfallSeriesSpec = IWaterfallSeriesSpec> extends BarSeries<any> {
     static readonly type: string;
@@ -24,6 +25,7 @@ export declare class WaterfallSeries<T extends IWaterfallSeriesSpec = IWaterfall
     protected _leaderLineMark: IRuleMark;
     protected _stackLabelMark: ITextMark;
     protected _labelMark: ITextMark;
+    protected _getSpecUpdatePolicy(): ISeriesSpecUpdatePolicy;
     protected initGroups(): void;
     setAttrFromSpec(): void;
     getSeriesKeys(): string[];

package/types/util/graphic-state.d.ts

@@ -1,3 +1,4 @@
 import type { IMarkGraphic } from '../mark/interface';
+export declare const setGraphicStates: (graphic: IMarkGraphic, nextStates?: string[] | null, hasAnimation?: boolean) => void;
 export declare const addGraphicState: (graphic: IMarkGraphic, state: string, keepCurrentStates?: boolean, hasAnimation?: boolean) => void;
 export declare const removeGraphicState: (graphic: IMarkGraphic, state: string | string[], hasAnimation?: boolean) => void;