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

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

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

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

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

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 | (() => string);
+    fields: string;
     values?: string[];
     as?: string[];
-    default?: unknown;
-    set?: (A: Datum, B?: Datum) => void;
+    default?: any;
+    set?: (A: Datum, B: Datum) => void;
 }
 export declare const lookup: (data: Array<DataView>, opt: ILookUpOpt) => DataView[];

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

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

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

@@ -1,4 +1,4 @@
-import { type SankeyOptions, type SankeyData } from '@visactor/vlayouts';
+import type { SankeyOptions, SankeyData } from '@visactor/vlayouts';
 export interface ISankeyOpt extends SankeyOptions {
     targetField: string;
     sourceField: string;
@@ -10,18 +10,10 @@ export interface ISankeyOpt extends SankeyOptions {
         y1: number;
     };
 }
-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) => {
+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) => {
     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,5 +3,4 @@ import type { DataView } from '@visactor/vdataset';
 export interface IStackOption {
     fields: string[];
 }
-export type StackOption = IStackOption | (() => IStackOption);
-export declare const stackSplit: (data: Array<DataView>, op: StackOption) => ISeriesStackDataNode;
+export declare const stackSplit: (data: Array<DataView>, op: IStackOption) => ISeriesStackDataNode;

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

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

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

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

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

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

package/types/event/event.d.ts

@@ -4,7 +4,6 @@ export declare class Event implements IEvent {
     private _eventDispatcher;
     private _mode;
     private _composedEventMap;
-    private _eventHandlerMap;
     getComposedEventMap(): Map<EventCallback<EventParams>, {
         eventType: string;
         event: IComposedEvent;
@@ -21,7 +20,4 @@ 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, StateDefinitionsInput } from '@visactor/vrender-core';
+import type { IGroupGraphicAttribute, IGroup, IGraphic } 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(releaseDetach?: boolean): void;
+    removeProduct(): void;
     release(): void;
     protected _simpleStyle: T;
     setSimpleStyle(s: T): void;
@@ -82,11 +82,6 @@ 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[];
     };
@@ -160,14 +155,8 @@ 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,20 +8,11 @@ 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,8 +6,6 @@ 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, IUpdateSpecResult } from './interface';
+import type { IEffect, IModel, IModelInitOption, IModelOption, IModelEvaluateOption, IModelSpec, IModelMarkInfo, IModelSpecInfo } 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,8 +50,20 @@ export declare abstract class BaseModel<T extends IModelSpec> extends Compilable
     beforeRelease(): void;
     clear(): void;
     release(): void;
-    updateSpec(spec: T): IUpdateSpecResult;
-    protected _compareSpec(spec: T, prevSpec: T): IUpdateSpecResult;
+    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;
+    };
     reInit(spec?: T): void;
     updateLayoutAttribute(): void;
     setAttrFromSpec(): void;

package/types/model/interface.d.ts

@@ -33,18 +33,6 @@ 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;
@@ -58,7 +46,6 @@ export interface IUpdateSpecResult {
     reSize?: boolean;
     reCompile?: boolean;
     reTransformSpec?: boolean;
-    effects?: IUpdateSpecEffects;
     reAnimate?: boolean;
     changeTheme?: boolean;
     changeBackground?: boolean;

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

@@ -1,9 +1,9 @@
 import { BaseTooltipHandler } from './base';
-import { Tooltip as TooltipComponent } from '@visactor/vrender-components/tooltip';
+import { Tooltip as TooltipComponent } from '@visactor/vrender-components';
 import type { TooltipHandlerParams } from '../../../component/tooltip';
 import type { IComponentPluginService } from '../interface';
 import type { ITooltipActual } from '../../../typings';
-import type { IContainerSize } from '@visactor/vrender-components/tooltip/type';
+import type { IContainerSize } from '@visactor/vrender-components';
 import type { ITooltipAttributes } from './interface';
 export declare class CanvasTooltipHandler extends BaseTooltipHandler {
     static readonly type: string;

package/types/region/region.d.ts

@@ -39,7 +39,13 @@ export declare class Region<T extends IRegionSpec = IRegionSpec> extends LayoutM
     initMark(): void;
     protected _initBackgroundMarkStyle(): void;
     protected _initForegroundMarkStyle(): void;
-    _compareSpec(spec: T, prevSpec: T): import("../model/interface").IUpdateSpecResult;
+    _compareSpec(spec: T, prevSpec: T): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
     reInit(spec?: T): void;
     addSeries(s: ISeries): void;
     removeSeries(s: ISeries): void;

package/types/scale/color-ordinal-scale.d.ts

@@ -2,7 +2,6 @@ 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,7 +7,6 @@ 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> {
@@ -19,7 +18,6 @@ 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,6 +1,5 @@
 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';
@@ -25,11 +24,9 @@ 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,14 +16,6 @@ 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,7 +162,6 @@ export declare abstract class BaseSeries<T extends ISeriesSpec> extends BaseMode
     initSeriesStyleState(): void;
     afterInitMark(): void;
     getMarksWithoutRoot(): IMark[];
-    protected _getMarkSpecNamesForCompare(): string[];
     getMarksInType(type: string | string[]): IMark[];
     getMarkInName(name: string): IMark | undefined;
     getMarkInId(markId: number): IMark | undefined;
@@ -179,8 +170,13 @@ 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;
-    protected _getSpecUpdatePolicy(): ISeriesSpecUpdatePolicy;
-    _compareSpec(spec: T, prevSpec: T, ignoreCheckKeys?: Record<string, boolean>): IUpdateSpecResult;
+    _compareSpec(spec: T, prevSpec: T, ignoreCheckKeys?: Record<string, boolean>): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
     _updateSpecData(): void;
     reInit(spec?: T): void;
     onEvaluateEnd(ctx: IModelEvaluateOption): void;

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

@@ -10,6 +10,3 @@ 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,7 +8,6 @@ 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> {
@@ -47,7 +46,6 @@ 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,18 +31,6 @@ 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,7 +5,6 @@ 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;
@@ -21,7 +20,6 @@ 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,7 +6,6 @@ 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> {
@@ -19,7 +18,6 @@ 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,7 +7,6 @@ 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,6 +1,5 @@
 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';
@@ -57,10 +56,15 @@ 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;
-    }): import("../..").IUpdateSpecResult;
+    }): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
     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,13 +4,11 @@ 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,8 +1,6 @@
 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,7 +1,6 @@
 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';
@@ -17,7 +16,6 @@ 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,7 +3,6 @@ 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;
@@ -13,7 +12,6 @@ export declare class LinearProgressSeries<T extends ILinearProgressSeriesSpec =
     };
     private _progressMark;
     private _trackMark;
-    protected _getSpecUpdatePolicy(): ISeriesSpecUpdatePolicy;
     initMark(): void;
     initMarkStyle(): void;
     private _initProgressMark;