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

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

@@ -110,6 +110,7 @@ export declare class BaseChart<T extends IChartSpec> extends CompilableBase impl
     updateGlobalScaleDomain(): void;
     updateGlobalScale(result: IUpdateSpecResult): void;
     updateGlobalScaleTheme(): void;
+    private _getSpecKeys;
     updateSpec(spec: T): {
         change: boolean;
         reMake: boolean;
@@ -140,6 +141,7 @@ export declare class BaseChart<T extends IChartSpec> extends CompilableBase impl
     setSelected(datum: MaybeArray<any> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier): void;
     setHovered(datum: MaybeArray<Datum> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier): void;
     clearState(state: string): void;
+    clearAllStates(): void;
     clearSelected(): void;
     clearHovered(): void;
     private _initEvent;

package/types/chart/chart-meta/data.d.ts

@@ -5,9 +5,8 @@ import type { StringOrNumber } from '../../typings';
 export declare class ChartData {
     protected _dataArr: DataView[];
     get dataList(): DataView[];
-    protected _onError: (...args: any[]) => void;
     protected _dataSet: DataSet;
-    constructor(dataSet: DataSet, onError: (...args: any[]) => void);
+    constructor(dataSet: DataSet);
     parseData(dataSpec: IData): void;
     updateData(dataSpec: IData, fullUp?: boolean, forceMerge?: boolean): boolean;
     private _dataValueForEach;

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

@@ -3,7 +3,7 @@ import type { IGaugePointerSeriesSpec, IGaugeSeriesSpec } from '../../series/gau
 import type { ILinearAxisSpec } from '../../component/axis/interface';
 import type { ICircularProgressSeriesSpec } from '../../series/progress/circular/interface';
 import type { IPolarChartSpec } from '../polar';
-export interface IGaugeChartSpec extends Omit<IPolarChartSpec, 'axes'>, Omit<IGaugePointerSeriesSpec, 'data' | 'type' | 'morph'> {
+export interface IGaugeChartSpec extends Omit<IPolarChartSpec, 'axes'>, Omit<IGaugePointerSeriesSpec, 'data' | 'type' | 'morph' | 'tooltip'> {
     type: 'gauge';
     gauge?: Omit<IGaugeSeriesSpec, 'data'> | Omit<ICircularProgressSeriesSpec, 'data'>;
     axes?: (IPolarAxisSpec | ILinearAxisSpec)[];

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

@@ -84,6 +84,7 @@ export interface IChart extends ICompilable {
     setSelected: (datum: MaybeArray<any> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier) => void;
     setHovered: (datum: MaybeArray<Datum> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier) => void;
     clearState: (state: string) => void;
+    clearAllStates: () => void;
     clearSelected: () => void;
     clearHovered: () => void;
     updateViewBox: (viewBox: IBoundsLike, reLayout: boolean) => void;

package/types/chart/mosaic/mosaic.d.ts

@@ -12,7 +12,6 @@ export declare class MosaicChart<T extends IMosaicChartSpec = IMosaicChartSpec>
     readonly type: string;
     readonly seriesType: string;
     protected _stack: Stack;
-    afterCompile(): void;
     protected _beforeInit(): void;
     protected _initStack(): void;
     handleAfterStackRegion: (region: IRegion, stackValueGroup: {

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

@@ -3,9 +3,9 @@ import type { IIndicatorSpec } from '../../component/indicator/interface';
 import type { IChartExtendsSeriesSpec, IChartSpec } from '../../typings/spec/common';
 export interface IPieChartSpec extends IChartSpec, IChartExtendsSeriesSpec<IPieSeriesSpec> {
     type: 'pie';
-    indicator?: IIndicatorSpec;
+    indicator?: IIndicatorSpec | IIndicatorSpec[];
 }
 export interface IPie3dChartSpec extends IChartSpec, IChartExtendsSeriesSpec<IPie3dSeriesSpec> {
     type: 'pie3d';
-    indicator?: IIndicatorSpec;
+    indicator?: IIndicatorSpec | IIndicatorSpec[];
 }

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

@@ -2,8 +2,10 @@ import type { IPointLike } from '@visactor/vutils';
 import type { IPolarAxisSpec } from '../../component/axis/polar/interface';
 import type { IPolarCrosshairSpec } from '../../component/crosshair/interface';
 import type { IChartSpec, ILayoutRect } from '../../typings';
+import type { IIndicatorSpec } from '../../component';
 export interface IPolarChartSpec extends IChartSpec {
     axes?: IPolarAxisSpec[];
     crosshair?: IPolarCrosshairSpec | IPolarCrosshairSpec[];
     layoutRadius?: 'auto' | number | ((layoutRect: ILayoutRect, center: IPointLike) => number);
+    indicator?: IIndicatorSpec | IIndicatorSpec[];
 }

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

@@ -1,6 +1,6 @@
 import type { ITreemapSeriesSpec } from '../../series/treemap/interface';
 import type { IChartSpec } from '../../typings/spec/common';
-export interface ITreemapChartSpec extends Omit<IChartSpec, 'data' | 'series'>, ITreemapSeriesSpec {
+export interface ITreemapChartSpec extends Omit<IChartSpec, 'data' | 'series'>, Omit<ITreemapSeriesSpec, 'tooltip'> {
     type: 'treemap';
     series?: ITreemapSeriesSpec[];
 }

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

@@ -1,6 +1,6 @@
 import type { IVennSeriesSpec } from '../../series/venn/interface';
-import type { IChartSpec } from '../../typings/spec/common';
-export interface IVennChartSpec extends Omit<IChartSpec, 'data' | 'series'>, IVennSeriesSpec {
+import type { IChartExtendsSeriesSpec, IChartSpec } from '../../typings/spec/common';
+export interface IVennChartSpec extends IChartSpec, IChartExtendsSeriesSpec<IVennSeriesSpec> {
     type: 'venn';
     series?: IVennSeriesSpec[];
 }

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

@@ -12,12 +12,27 @@ export type IOptimizeType = {
     skipRenderWithOutRange?: boolean;
     disableCheckGraphicWidthOutRange?: boolean;
 };
+export interface GestureConfig {
+    press?: {
+        time?: number;
+        threshold?: number;
+    };
+    swipe?: {
+        threshold?: number;
+        velocity?: number;
+    };
+    tap?: {
+        interval?: number;
+    };
+}
 export interface IRenderOption {
     mode?: RenderMode;
+    gestureConfig?: GestureConfig;
     modeParams?: {
         tooltipCanvasId?: StringOrNumber;
         [key: string]: any;
     } | unknown;
+    autoRefreshDpr?: boolean;
     dpr?: number;
     interactive?: boolean;
     viewBox?: IBoundsLike;

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

@@ -1,35 +1,22 @@
-import type { IElement, IGroupMark, IMark, MarkAnimationSpec, MarkFunctionCallback, Nil, TransformSpec } from '@visactor/vgrammar-core';
+import type { IElement, IGroupMark, IMark, IMarkConfig, MarkAnimationSpec, MarkFunctionCallback, Nil, TransformSpec } from '@visactor/vgrammar-core';
 import type { DataView } from '@visactor/vdataset';
 import { GrammarItem } from '../grammar-item';
 import type { Maybe, Datum, StringOrNumber } from '../../typings';
-import type { IMarkProgressiveConfig, IMarkStateStyle, MarkType } from '../../mark/interface';
+import type { IMarkStateStyle, MarkType } from '../../mark/interface';
 import type { IModel } from '../../model/interface';
 import { MarkStateManager } from './mark-state-manager';
-import type { ICompilableMark, IMarkDataInitOption, ICompilableMarkOption, StateValueType, IMarkCompileOption, IAttributeOpt, MarkClip } from './interface';
+import type { ICompilableMark, IMarkDataInitOption, ICompilableMarkOption, StateValueType, IMarkCompileOption, IAttributeOpt } from './interface';
 import { MarkData } from './mark-data';
 import { GrammarType } from '../interface/compilable-item';
 import type { IEvent } from '../../event/interface';
-import type { ICustomPath2D } from '@visactor/vrender-core';
 export declare abstract class CompilableMark extends GrammarItem implements ICompilableMark {
     readonly grammarType = GrammarType.mark;
     readonly type: MarkType;
     readonly name: string;
     readonly key: ICompilableMark['key'];
-    protected _skipTheme?: boolean;
-    getSkipTheme(): boolean;
-    setSkipTheme(skipTheme: boolean): void;
-    protected _support3d?: boolean;
-    getSupport3d(): boolean;
-    setSupport3d(support3d: boolean): void;
-    protected _facet?: string;
-    getFacet(): string;
-    setFacet(facet: string): void;
-    protected _interactive: boolean;
-    getInteractive(): boolean;
-    setInteractive(interactive: boolean): void;
-    protected _zIndex: number;
-    getZIndex(): number;
-    setZIndex(zIndex: number): void;
+    protected _markConfig: IMarkConfig;
+    getMarkConfig(): IMarkConfig;
+    setMarkConfig(config: IMarkConfig): void;
     protected _visible: boolean;
     getVisible(): boolean;
     setVisible(visible: boolean): void;
@@ -56,28 +43,9 @@ export declare abstract class CompilableMark extends GrammarItem implements ICom
     private _skipBeforeLayouted;
     setSkipBeforeLayouted(skip: boolean): void;
     getSkipBeforeLayouted(): boolean;
-    protected _morph: boolean;
-    getMorph(): boolean;
-    setMorph(morph: boolean): void;
-    protected _morphKey?: string;
-    getMorphKey(): string;
-    setMorphKey(morphKey: string): void;
-    protected _morphElementKey?: string;
-    getMorphElementKey(): string;
-    setMorphElementKey(key: string): void;
     protected _groupKey?: string;
     getGroupKey(): string;
     setGroupKey(groupKey: string): void;
-    protected _progressiveConfig: IMarkProgressiveConfig;
-    getProgressiveConfig(): IMarkProgressiveConfig;
-    setProgressiveConfig(config: IMarkProgressiveConfig): void;
-    protected _setCustomizedShape?: (datum: any[], attrs: any, path: ICustomPath2D) => ICustomPath2D;
-    setCustomizedShapeCallback(callback: (datum: any[], attrs: any, path: ICustomPath2D) => ICustomPath2D): void;
-    protected _enableSegments: boolean;
-    setEnableSegments(enable: boolean): void;
-    protected _clip: MarkClip;
-    getClip(): MarkClip;
-    setClip(clip: MarkClip): void;
     protected _stateSort?: (stateA: string, stateB: string) => number;
     setStateSortCallback(stateSort: (stateA: string, stateB: string) => number): void;
     protected _option: ICompilableMarkOption;
@@ -101,7 +69,7 @@ export declare abstract class CompilableMark extends GrammarItem implements ICom
     compileEncode(): void;
     compileState(): void;
     compileAnimation(): void;
-    compileContext(): void;
+    compileContext(extraContext?: any): void;
     compileSignal(): void;
     protected _computeAttribute(key: string, state: StateValueType): (datum: Datum, opt: IAttributeOpt) => any;
     protected compileCommonAttributeCallback(key: string, state: string): MarkFunctionCallback<any>;

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

@@ -1,21 +1,18 @@
-import type { IMarkProgressiveConfig, IMarkStateStyle, MarkType } from '../../mark/interface';
+import type { IMarkStateStyle, MarkType } from '../../mark/interface';
 import type { IModel } from '../../model/interface';
 import type { GrammarItemCompileOption, GrammarItemInitOption } from '../interface';
 import type { IGrammarItem } from '../interface';
 import type { MarkStateManager } from './mark-state-manager';
 import type { DataView } from '@visactor/vdataset';
-import type { IAnimate, IAnimateArranger, IElement, IGroupMark, IMark, MarkAnimationSpec, Nil, TransformSpec } from '@visactor/vgrammar-core';
+import type { IAnimate, IAnimateArranger, IElement, IGroupMark, IMark, IMarkConfig, MarkAnimationSpec, Nil, TransformSpec } from '@visactor/vgrammar-core';
 import type { Maybe, Datum, StringOrNumber } from '../../typings';
 import type { MarkData } from './mark-data';
 import type { IRegion } from '../../region/interface';
-import type { ICustomPath2D, IGraphic } from '@visactor/vrender-core';
 export interface ICompilableMarkOption extends GrammarItemInitOption {
     key?: string | ((datum: Datum) => string);
     groupKey?: string;
     skipBeforeLayouted?: boolean;
-    support3d?: boolean;
     mode?: '2d' | '3d';
-    skipTheme?: boolean;
     noSeparateStyle?: boolean;
 }
 export interface ICompilableMark extends IGrammarItem {
@@ -28,8 +25,6 @@ export interface ICompilableMark extends IGrammarItem {
     setData: (d: MarkData) => void;
     getDataView: () => DataView | undefined;
     setDataView: (d?: DataView, productId?: string) => void;
-    getFacet: () => string | undefined;
-    setFacet: (facet: string) => void;
     state: MarkStateManager;
     readonly stateStyle: IMarkStateStyle<any>;
     hasState: (state: string) => boolean;
@@ -40,38 +35,23 @@ export interface ICompilableMark extends IGrammarItem {
     updateLayoutState: (noRender?: boolean, recursion?: boolean) => void;
     updateMarkState: (key: string) => void;
     setTransform: (transform: TransformSpec[] | Nil) => void;
-    getInteractive: () => boolean;
-    setInteractive: (interactive: boolean) => void;
     setAnimationConfig: (config: Partial<MarkAnimationSpec>) => void;
     getAnimationConfig: () => Partial<MarkAnimationSpec>;
-    getZIndex: () => number;
-    setZIndex: (zIndex: number) => void;
     getVisible: () => boolean;
     setVisible: (visible: boolean) => void;
-    getMorph: () => boolean;
-    setMorph: (morph: boolean) => void;
-    getProgressiveConfig: () => IMarkProgressiveConfig;
-    setProgressiveConfig: (config: IMarkProgressiveConfig) => void;
-    getMorphKey: () => string | undefined;
-    setMorphKey: (morphKey: string) => void;
-    getMorphElementKey: () => string | undefined;
-    setMorphElementKey: (morphKey: string) => void;
     getGroupKey: () => string | undefined;
     setGroupKey: (groupKey: string) => void;
     getUserId: () => StringOrNumber | undefined;
     setUserId: (id: StringOrNumber) => void;
-    getSupport3d: () => boolean | undefined;
-    setSupport3d: (support3d: boolean) => void;
-    getClip: () => MarkClip | undefined;
-    setClip: (clip: MarkClip) => void;
     compile: (option?: IMarkCompileOption) => void;
     getProduct: () => Maybe<IMark>;
     getProductElements: () => Maybe<IMark['elements']>;
     getMarks: () => ICompilableMark[];
     setSkipBeforeLayouted: (skip: boolean) => void;
     getSkipBeforeLayouted: () => boolean;
-    setCustomizedShapeCallback: (callback: (datum: any[], attrs: any, path: ICustomPath2D) => ICustomPath2D) => void;
     setStateSortCallback: (stateSort: (stateA: string, stateB: string) => number) => void;
+    getMarkConfig: () => IMarkConfig;
+    setMarkConfig: (config: IMarkConfig) => void;
     runAnimationByState: (animationState?: string) => IAnimateArranger;
     stopAnimationByState: (animationState?: string) => IAnimate;
     pauseAnimationByState: (animationState: string) => IAnimate;
@@ -83,6 +63,7 @@ export interface IMarkDataInitOption extends ICompilableMarkOption {
 export interface IMarkCompileOption extends GrammarItemCompileOption {
     group?: string | IGroupMark;
     ignoreChildren?: boolean;
+    context?: any;
 }
 export interface IStateInfo {
     stateValue: StateValue;
@@ -150,4 +131,3 @@ export interface ISeriesMarkAttributeContext extends IModelMarkAttributeContext
     seriesColor: (seriesValue?: string | number) => string;
     getRegion: () => IRegion;
 }
-export type MarkClip = false | IGraphic[] | ((elements: IElement[]) => IGraphic[]);

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

@@ -1,6 +1,6 @@
 import type { ITickDataOpt } from '@visactor/vrender-components';
 import type { IBaseScale } from '@visactor/vscale';
-import type { IGroup, IGraphic } from '@visactor/vrender-core';
+import type { IGraphic } from '@visactor/vrender-core';
 import type { IOrientType, IPolarOrientType, StringOrNumber, CoordinateType } from '../../typings';
 import { BaseComponent } from '../base/base-component';
 import { CompilableData } from '../../compile/data';
@@ -42,6 +42,7 @@ export declare abstract class AxisComponent<T extends ICommonAxisSpec & Record<s
     protected abstract collectSeriesField(depth: number, series: ISeries): string | string[];
     abstract transformScaleDomain(): void;
     protected abstract updateScaleRange(): boolean;
+    protected abstract getDefaultInteractive(): boolean;
     protected _dataFieldText: string;
     protected _axisMark: IComponentMark;
     protected _gridMark: IComponentMark;
@@ -77,7 +78,6 @@ export declare abstract class AxisComponent<T extends ICommonAxisSpec & Record<s
         reSize: boolean;
         reCompile: boolean;
     };
-    protected _delegateAxisContainerEvent(component: IGroup): void;
     protected _getAxisAttributes(): any;
     protected _getGridAttributes(): {
         alternateColor: any;

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

@@ -35,6 +35,7 @@ export declare abstract class CartesianAxis<T extends ICartesianAxisCommonSpec =
     };
     protected _orient: IOrientType;
     getOrient(): IOrientType;
+    protected getDefaultInteractive(): boolean;
     protected _autoIndentOnce: boolean;
     protected _hasAutoIndent: boolean;
     set autoIndentOnce(v: boolean);
@@ -107,4 +108,5 @@ export declare abstract class CartesianAxis<T extends ICartesianAxisCommonSpec =
     onDataUpdate(): void;
     private _appendAxisUnit;
     protected _getNeedClearVRenderComponents(): IGraphic[];
+    private _getLabelOverflowLimit;
 }

package/types/component/axis/cartesian/interface/common.d.ts

@@ -17,6 +17,7 @@ export type ICartesianTitle = ITitle & {
 export type ICartesianLabel = ILabel & {
     flush?: boolean;
     lastVisible?: boolean | null;
+    firstVisible?: boolean | null;
     containerAlign?: 'left' | 'right' | 'center' | 'top' | 'bottom' | 'middle';
 } & AxisLabelOverlap;
 export interface ILinearAxis extends IAxis {

package/types/component/axis/interface/spec.d.ts

@@ -17,6 +17,7 @@ export interface ICommonAxisSpec extends Omit<IComponentSpec, 'orient' | 'center
 }
 export type ILinearAxisBreakSpec = Omit<AxisBreakProps, 'rawRange'> & {
     gap?: number | string;
+    scopeType?: 'count' | 'length';
 };
 export interface ILinearAxisSpec {
     min?: number;

package/types/component/axis/mixin/util/break-data.d.ts

@@ -1,4 +1,4 @@
-export declare function breakData(data: number[], points: number[]): {
+export declare function breakData(data: number[], points: number[], scopeType?: 'count' | 'length'): {
     domain: [number, number][];
     scope: [number, number][];
 };

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

@@ -34,6 +34,7 @@ export declare abstract class PolarAxis<T extends IPolarAxisCommonSpec = IPolarA
     get endAngle(): number;
     protected _orient: IPolarOrientType;
     getOrient(): IPolarOrientType;
+    protected getDefaultInteractive(): boolean;
     protected _groupScales: IBaseScale[];
     getGroupScales(): IBaseScale[];
     private _axisStyle;
@@ -47,7 +48,6 @@ export declare abstract class PolarAxis<T extends IPolarAxisCommonSpec = IPolarA
     onRender(ctx: any): void;
     changeRegions(): void;
     protected _tickTransformOption(): IPolarTickDataOpt;
-    afterCompile(): void;
     protected updateScaleRange(): boolean;
     protected collectSeriesField(depth: number, series: IPolarSeries): string | string[];
     protected abstract computeDomain(data: {

package/types/component/axis/polar/interface/spec.d.ts

@@ -1,8 +1,10 @@
 import type { IPointLike } from '@visactor/vutils';
+import type { AxisLabelOverlap } from '@visactor/vrender-components';
 import type { ILayoutRect, IPolarOrientType } from '../../../../typings';
 import type { IBandAxisSpec, IDomainLine, ILinearAxisSpec, ITitle, ILabel, ICommonAxisSpec } from '../../interface';
 import type { IPolarGrid } from './common';
 export type IPolarAxisSpec = IPolarLinearAxisSpec | IPolarBandAxisSpec;
+export type IPolarAxisLabel = ILabel & Pick<AxisLabelOverlap, 'autoHide' | 'autoHideMethod' | 'autoHideSeparation' | 'autoLimit' | 'limitEllipsis' | 'layoutFunc' | 'autoWrap'>;
 export type IPolarAxisCommonSpec = Omit<ICommonAxisSpec, 'center'> & {
     layoutRadius?: 'auto' | number | ((layoutRect: ILayoutRect, center: IPointLike) => number);
     inside?: boolean;
@@ -11,7 +13,7 @@ export type IPolarAxisCommonSpec = Omit<ICommonAxisSpec, 'center'> & {
     radius?: number;
     subGrid?: IPolarGrid;
     domainLine?: IDomainLine;
-    label?: ILabel;
+    label?: IPolarAxisLabel;
     title?: ITitle;
     innerRadius?: number;
     outerRadius?: number;

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

@@ -1,6 +1,8 @@
 import type { IOrientType, IPolarOrientType } from '../../typings';
 import type { AxisType, ICommonAxisSpec, ILinearAxisSpec } from './interface';
 import type { ITheme } from '../../theme';
+import type { IAxisHelper } from './cartesian';
+import type { IPolarAxisHelper } from './polar';
 export declare const DEFAULT_TITLE_STYLE: {
     left: {
         textAlign: string;
@@ -33,3 +35,4 @@ export declare function getAxisItem(value: any, normalizedValue: number): {
     value: number;
     rawValue: any;
 };
+export declare function shouldUpdateAxis(preHelper: IAxisHelper | IPolarAxisHelper, curHelper: IAxisHelper | IPolarAxisHelper, forceUpdate: boolean): boolean;

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

@@ -1,9 +1,8 @@
 import { BaseComponent } from '../base/base-component';
 import { ComponentTypeEnum } from '../interface/type';
 import type { IRegion } from '../../region/interface';
-import type { IModelRenderOption, IModelSpecInfo } from '../../model/interface';
+import type { IModelRenderOption } from '../../model/interface';
 import type { EnableMarkType, ICustomMarkGroupSpec, ICustomMarkSpec, ILayoutRect } from '../../typings';
-import type { Maybe } from '@visactor/vutils';
 import type { IGraphic } from '@visactor/vrender-core';
 import type { IModelMarkAttributeContext } from '../../compile/mark/interface';
 export declare class CustomMark extends BaseComponent<ICustomMarkSpec<EnableMarkType>> {
@@ -15,7 +14,6 @@ export declare class CustomMark extends BaseComponent<ICustomMarkSpec<EnableMark
     layoutZIndex: number;
     layoutLevel: number;
     protected _spec: ICustomMarkSpec<Exclude<EnableMarkType, 'group'>> | ICustomMarkGroupSpec;
-    static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
     created(): void;
     protected _markAttributeContext: IModelMarkAttributeContext;
     getMarkAttributeContext(): IModelMarkAttributeContext;
@@ -33,7 +31,6 @@ export declare class CustomMark extends BaseComponent<ICustomMarkSpec<EnableMark
     changeRegions(regions: IRegion[]): void;
     protected _getNeedClearVRenderComponents(): IGraphic[];
     onRender(ctx: IModelRenderOption): void;
-    afterCompile(): void;
     private _getMarkAttributeContext;
     private _getLayoutRect;
     getBoundsInRect(rect: ILayoutRect): {

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

@@ -36,6 +36,7 @@ export declare abstract class DataFilterBaseComponent<T extends IDataFilterCompo
     protected _maxSpan: number;
     protected _spanCache: number;
     protected _shouldChange: boolean;
+    protected _domainCache: any;
     protected _field: string | undefined;
     protected _stateField: string;
     protected _valueField?: string;
@@ -113,7 +114,9 @@ export declare abstract class DataFilterBaseComponent<T extends IDataFilterCompo
     protected _handleChartMove: (value: number, rate: number) => boolean;
     protected _initCommonEvent(): void;
     updateLayoutAttribute(): void;
+    protected _autoVisible(isShown: boolean): void;
     onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect, ctx: any): void;
+    onLayoutEnd(ctx: any): void;
     getBoundsInRect(rect: ILayoutRect): IBoundsLike;
     hide(): void;
     show(): void;

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

@@ -1,4 +1,3 @@
-import type { Maybe } from '@visactor/vutils';
 import type { IComponentOption } from '../../interface';
 import { ComponentTypeEnum } from '../../interface/type';
 import { DataFilterBaseComponent } from '../data-filter-base-component';
@@ -7,7 +6,6 @@ import type { IRectGraphicAttribute, ISymbolGraphicAttribute, IGraphic } from '@
 import type { Datum, ILayoutType } from '../../../typings';
 import type { ILinearScale, IBaseScale } from '@visactor/vscale';
 import type { IDataZoomSpec } from './interface';
-import type { IModelSpecInfo } from '../../../model/interface';
 import { DataZoomSpecTransformer } from './data-zoom-transformer';
 export declare class DataZoom<T extends IDataZoomSpec = IDataZoomSpec> extends DataFilterBaseComponent<T> {
     static type: ComponentTypeEnum;
@@ -27,7 +25,6 @@ export declare class DataZoom<T extends IDataZoomSpec = IDataZoomSpec> extends D
     protected _startHandlerSize: number;
     protected _endHandlerSize: number;
     protected _isReverseCache: boolean;
-    static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
     constructor(spec: T, options: IComponentOption);
     created(): void;
     setAttrFromSpec(): void;

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

@@ -1,4 +1,3 @@
-import type { Maybe } from '@visactor/vutils';
 import type { IComponentOption } from '../../interface';
 import { ComponentTypeEnum } from '../../interface/type';
 import { DataFilterBaseComponent } from '../data-filter-base-component';
@@ -7,7 +6,6 @@ import { ScrollBar as ScrollBarComponent } from '@visactor/vrender-components';
 import type { IGraphic } from '@visactor/vrender-core';
 import type { IScrollBarSpec } from './interface';
 import type { ILayoutType } from '../../../typings/layout';
-import type { IModelSpecInfo } from '../../../model/interface';
 export declare class ScrollBar<T extends IScrollBarSpec = IScrollBarSpec> extends DataFilterBaseComponent<T> {
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
@@ -18,7 +16,6 @@ export declare class ScrollBar<T extends IScrollBarSpec = IScrollBarSpec> extend
     layoutLevel: number;
     layoutType: ILayoutType;
     protected _component: ScrollBarComponent;
-    static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
     constructor(spec: T, options: IComponentOption);
     setAttrFromSpec(): void;
     onLayoutEnd(ctx: any): void;

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

@@ -56,6 +56,13 @@ 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;
+    };
     release(): void;
 }
 export declare const registerGeoCoordinate: () => void;

package/types/component/interface/common.d.ts

@@ -33,7 +33,7 @@ export interface IComponent extends ILayoutModel {
 export interface IComponentConstructor extends IModelConstructor {
     type: string;
     specKey?: string;
-    getSpecInfo: (chartSpec: any, chartSpecInfo?: IChartSpecInfo) => Maybe<IModelSpecInfo[]>;
+    getSpecInfo?: (chartSpec: any, chartSpecInfo?: IChartSpecInfo) => Maybe<IModelSpecInfo[]>;
     createComponent: (specInfo: IModelSpecInfo, options: IComponentOption) => IComponent;
     new (spec: any, options: IComponentOption): IComponent;
 }

package/types/component/interface/index.d.ts

@@ -1,4 +1,3 @@
 export * from './common';
 export * from './type';
-export * from './tooltip-helper';
 export * from './theme';

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

@@ -4,7 +4,7 @@ import { ComponentTypeEnum } from '../interface/type';
 import type { IRegion } from '../../region/interface';
 import type { IModelRenderOption } from '../../model/interface';
 import type { ILabelSpec } from './interface';
-import type { IGraphic, IGroup } from '@visactor/vrender-core';
+import type { IGraphic } from '@visactor/vrender-core';
 export declare abstract class BaseLabelComponent<T = any> extends BaseComponent<T> {
     static type: ComponentTypeEnum;
     type: ComponentTypeEnum;
@@ -32,5 +32,4 @@ export declare abstract class BaseLabelComponent<T = any> extends BaseComponent<
     onRender(ctx: IModelRenderOption): void;
     changeRegions(regions: IRegion[]): void;
     protected _getNeedClearVRenderComponents(): IGraphic[];
-    protected _delegateLabelEvent(component: IGroup): void;
 }

package/types/component/label/interface.d.ts

@@ -6,7 +6,7 @@ import type { ISeries } from '../../series';
 export interface ILabelFormatMethodContext {
     series?: ISeries;
 }
-export interface ILabelSpec extends IComponentSpec {
+export interface ILabelSpec extends IComponentSpec, ILabelAnimationSpec {
     visible?: boolean;
     interactive?: boolean;
     textType?: 'text' | 'rich';
@@ -18,7 +18,6 @@ export interface ILabelSpec extends IComponentSpec {
     state?: LabelStateStyle<Partial<IComposedTextMarkSpec>>;
     overlap?: BaseLabelAttrs['overlap'];
     smartInvert?: BaseLabelAttrs['smartInvert'];
-    animation?: BaseLabelAttrs['animation'];
     stackDataFilterType?: 'min' | 'max';
     dataFilter?: BaseLabelAttrs['dataFilter'];
     customLayoutFunc?: BaseLabelAttrs['customLayoutFunc'];
@@ -27,6 +26,7 @@ export interface ILabelSpec extends IComponentSpec {
     support3d?: boolean;
     syncState?: boolean;
 }
+export type ILabelAnimationSpec = Pick<BaseLabelAttrs, 'animation' | 'animationEnter' | 'animationUpdate' | 'animationExit'>;
 export type IMultiLabelSpec<T extends Omit<ILabelSpec, 'position'>> = T | T[];
 type LabelStateStyle<T> = {
     hover?: T;

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

@@ -40,7 +40,6 @@ export declare class Label<T extends IChartSpec = any> extends BaseLabelComponen
     init(option: IModelInitOption): void;
     reInit(spec?: T): void;
     initEvent(): void;
-    afterCompile(): void;
     protected _initTextMark(): void;
     protected _initLabelComponent(): void;
     protected _initTextMarkStyle(): void;

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

@@ -16,10 +16,10 @@ export declare class TotalLabel extends BaseLabelComponent {
     private _baseMark?;
     static getSpecInfo(chartSpec: any, chartSpecInfo?: IChartSpecInfo): Maybe<IModelSpecInfo[]>;
     init(option: IModelInitOption): void;
+    reInit(spec?: any): void;
     protected _initTextMark(): void;
     _initTextMarkStyle(): void;
     protected _initLabelComponent(): void;
-    afterCompile(): void;
     updateLayoutAttribute(): void;
     compileMarks(): void;
     getVRenderComponents(): any[];

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

@@ -22,21 +22,21 @@ export declare function textAttribute(labelInfo: ILabelInfo, datum: Datum, forma
 export declare function symbolLabel(labelInfo: ILabelInfo): {
     position: string | ((datum: Datum) => any);
     overlap: boolean | {
-        strategy: Strategy[];
+        strategy: Strategy[] | import("@visactor/vrender-components").ShiftYStrategy;
         avoidBaseMark: boolean;
     };
 };
 export declare function lineDataLabel(labelInfo: ILabelInfo): {
     position: string | ((datum: Datum) => any);
     overlap: boolean | {
-        strategy: Strategy[];
+        strategy: Strategy[] | import("@visactor/vrender-components").ShiftYStrategy;
         avoidBaseMark: boolean;
     };
 };
 export declare function barLabel(labelInfo: ILabelInfo): {
-    position: import("@visactor/vrender-components").Functional<string>;
+    position: (data: any) => string;
     overlap: boolean | {
-        strategy: Strategy[];
+        strategy: Strategy[] | import("@visactor/vrender-components").ShiftYStrategy;
     };
     smartInvert: boolean;
 };
@@ -74,7 +74,7 @@ export declare function LineLabel(labelInfo: ILabelInfo): {
 export declare function sankeyLabel(labelInfo: ILabelInfo): {
     position: import("@visactor/vrender-components").Functional<string>;
     overlap: boolean | {
-        strategy: Strategy[];
+        strategy: Strategy[] | import("@visactor/vrender-components").ShiftYStrategy;
     };
     smartInvert: boolean;
     offset: number;