@visactor/vchart-types 1.12.9 → 1.12.10-alpha.2

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

@@ -12,8 +12,22 @@ 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;

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

@@ -1,32 +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 _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;
@@ -53,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;

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 {
@@ -38,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;
@@ -149,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/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/title/interface/theme.d.ts

@@ -12,7 +12,7 @@ export interface ITitleTextTheme {
     fontWeight?: StringOrNumber;
     textAlign?: TextAlign;
     textBaseline?: TextBaseLine;
-    lineHeight?: number;
+    lineHeight?: number | ITokenKey;
 }
 export interface ITitleTheme extends ILayoutItemSpec {
     textStyle?: ITitleTextTheme;

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

@@ -1,3 +1,4 @@
+import type { EventSourceType, EventType } from '../../../event/interface';
 import type { IGroupTooltipPattern, ITooltipActual, ITooltipPattern, Maybe, MaybeArray, TooltipActiveType, TooltipData } from '../../../typings';
 import type { ITooltipActiveTypeAsKeys, TooltipHandlerParams, TooltipResult } from './common';
 import type { ITooltipTheme } from './theme';
@@ -6,8 +7,17 @@ export interface ITooltipSpec extends Partial<ITooltipActiveTypeAsKeys<ITooltipP
 }, ITooltipPattern, IGroupTooltipPattern>> {
     visible?: boolean;
     activeType?: TooltipActiveType | TooltipActiveType[];
-    trigger?: MaybeArray<'hover' | 'click'> | 'none';
-    triggerOff?: MaybeArray<'hover' | 'click'> | 'none';
+    trigger?: MaybeArray<'hover' | 'click' | {
+        eventType: EventType;
+        source?: EventSourceType;
+        consume?: boolean;
+    }> | 'none';
+    triggerOff?: MaybeArray<'hover' | 'click' | {
+        eventType: EventType;
+        source?: EventSourceType;
+        consume?: boolean;
+        checkOutside?: boolean;
+    }> | 'none';
     showDelay?: number;
     hideTimer?: number;
     lockAfterClick?: boolean;

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

@@ -5,6 +5,8 @@ import type { IBaseScale } from '@visactor/vscale';
 import type { MarkType } from './type';
 import type { ICompilableMark, ICompilableMarkOption, IModelMarkAttributeContext, StateValueType } from '../../compile/mark';
 import type { StringOrNumber } from '../../typings';
+import type { IMarkConfig } from '@visactor/vgrammar-core';
+import type { ICustomPath2D } from '@visactor/vrender-core';
 export interface VisualScaleType {
     scale: IBaseScale;
     field: StringOrNumber;
@@ -42,6 +44,14 @@ export interface IMarkRaw<T extends ICommonSpec> extends ICompilableMark {
     setPostProcess: <U extends keyof T, A>(key: U, postProcessFunc: IAttrConfig<A, T>['postProcess'], state?: StateValueType) => void;
 }
 export type IMark = IMarkRaw<ICommonSpec>;
+export interface ICompileMarkConfig extends IMarkConfig {
+    morph?: boolean;
+    morphElementKey?: string;
+    support3d?: boolean;
+    setCustomizedShape?: (datum: any[], attrs: any, path: ICustomPath2D) => ICustomPath2D;
+    clip?: boolean;
+    skipTheme?: boolean;
+}
 export interface IMarkOption extends ICompilableMarkOption {
     model: IModel;
     map: Map<StringOrNumber, IModel | IMark>;

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

@@ -1,7 +1,7 @@
 import type { IEvent } from '../event/interface';
 import type { IEffect, IModel, IModelInitOption, IModelOption, IModelRenderOption, IModelEvaluateOption, IModelSpec, IModelMarkInfo, IModelSpecInfo } from './interface';
 import type { CoordinateType } from '../typings/coordinate';
-import type { IMark, IMarkOption, IMarkRaw, IMarkStyle } from '../mark/interface';
+import type { ICompileMarkConfig, IMark, IMarkOption, IMarkRaw, IMarkStyle } from '../mark/interface';
 import type { Datum, StateValueType, ConvertToMarkStyleSpec, ICommonSpec, StringOrNumber, IRect, ILayoutRect } from '../typings';
 import type { CompilableData } from '../compile/data/compilable-data';
 import type { IGroupMark } from '@visactor/vgrammar-core';
@@ -72,7 +72,7 @@ export declare abstract class BaseModel<T extends IModelSpec> extends Compilable
     protected stateKeyToSignalName(key: string, opt?: string): string;
     compileData(): void;
     compileMarks(group?: string | IGroupMark): void;
-    protected _createMark<T extends IMark>(markInfo: IModelMarkInfo, option?: Partial<IMarkOption>): T;
+    protected _createMark<T extends IMark>(markInfo: IModelMarkInfo, option?: Partial<IMarkOption>, config?: ICompileMarkConfig): T;
     protected _getDataIdKey(): string | ((datum: Datum) => string) | undefined;
     getColorScheme(): import("..").IThemeColorScheme;
     getSpecInfo(): IModelSpecInfo<any>;

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

@@ -1,6 +1,6 @@
 import type { IBaseScale } from '@visactor/vscale';
 import { CartesianSeries } from '../cartesian/cartesian';
-import type { IMark, IMarkProgressiveConfig } from '../../mark/interface';
+import type { IMark } from '../../mark/interface';
 import { MarkTypeEnum } from '../../mark/interface/type';
 import type { Datum, DirectionType } from '../../typings';
 import type { IBarSeriesSpec } from './interface';
@@ -27,7 +27,7 @@ export declare class BarSeries<T extends IBarSeriesSpec = IBarSeriesSpec> extend
     protected _barBackgroundMark: IRectMark;
     protected _barBackgroundViewData: SeriesData;
     initMark(): void;
-    protected _initBarBackgroundMark(progressive?: IMarkProgressiveConfig): void;
+    protected _initBarBackgroundMark(): void;
     initMarkStyle(): void;
     initLabelMarkStyle(textMark: ITextMark): void;
     protected initTooltip(): void;

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

@@ -1,7 +1,7 @@
 import { DataView } from '@visactor/vdataset';
 import type { DataSet, ITransformOptions } from '@visactor/vdataset';
 import type { IRegion } from '../../region/interface';
-import type { IMark } from '../../mark/interface';
+import type { ICompileMarkConfig, IMark } from '../../mark/interface';
 import type { CoordinateType, IInvalidType, IPoint, DataKeyType, Datum, Maybe, ISeriesSpec, IExtensionMarkSpec, IExtensionGroupMarkSpec, EnableMarkType, IGroup, ILayoutType, ILayoutPoint, ILayoutRect } from '../../typings';
 import { BaseModel } from '../../model/base-model';
 import type { ISeriesOption, ISeries, ISeriesMarkInitOption, ISeriesStackData, ISeriesTooltipHelper, SeriesMarkMap, ISeriesMarkInfo, ISeriesSpecInfo, ISeriesStackDataLeaf, ISeriesStackDataMeta, ISeriesSeriesInfo } from '../interface';
@@ -202,7 +202,7 @@ export declare abstract class BaseSeries<T extends ISeriesSpec> extends BaseMode
     getMeasureField(): string[];
     protected onMarkPositionUpdate(): void;
     protected onMarkTreePositionUpdate(marks: IMark[]): void;
-    protected _createMark<M extends IMark>(markInfo: ISeriesMarkInfo, option?: ISeriesMarkInitOption): NonNullable<M>;
+    protected _createMark<M extends IMark>(markInfo: ISeriesMarkInfo, option?: ISeriesMarkInitOption, config?: ICompileMarkConfig): NonNullable<M>;
     protected _getDataIdKey(): string | ((datum: Datum) => string);
     protected _getSeriesDataKey(datum: Datum): string;
     addViewDataFilter(option: ITransformOptions): void;

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

@@ -5,12 +5,10 @@ import type { IBaseModelSpecTransformerResult, IModelConstructor, IModelMarkInfo
 import type { IRegion } from '../../region/interface';
 import type { RenderMode } from '../../typings/spec/common';
 import type { ISeries } from './series';
-import type { IMarkOption, IMarkProgressiveConfig } from '../../mark/interface';
+import type { IMarkOption } from '../../mark/interface';
 import type { ISeriesSpec, StringOrNumber } from '../../typings';
 import type { TransformedLabelSpec } from '../../component/label';
 import type { SeriesMarkNameEnum, SeriesTypeEnum } from './type';
-import type { ICustomPath2D } from '@visactor/vrender-core';
-import type { MarkClip } from '../../compile/mark';
 export interface ISeriesSeriesInfo {
     key: string;
     originalKey: any;
@@ -63,17 +61,11 @@ export interface ISeriesMarkInitOption extends Partial<IMarkOption> {
     depend?: IGrammarItem | IGrammarItem[];
     key?: string | ((datum: any) => string);
     groupKey?: string;
-    morph?: boolean;
-    defaultMorphElementKey?: string;
     dataView?: DataView | false;
     dataProductId?: string;
     seriesId?: number;
-    progressive?: IMarkProgressiveConfig;
-    support3d?: boolean;
-    customShape?: (datum: any[], attrs: any, path: ICustomPath2D) => ICustomPath2D;
     stateSort?: (stateA: string, stateB: string) => number;
     componentType?: string;
-    clip?: MarkClip;
 }
 export interface ISeriesMarkInfo extends IModelMarkInfo {
     name: SeriesMarkNameEnum | string;

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

@@ -1,6 +1,6 @@
 import type { ISeriesOption } from '../interface/common';
 import type { ISeries } from '../interface/series';
-import type { IMark, IMarkProgressiveConfig } from '../../mark/interface';
+import type { ICompileMarkConfig, IMark, IMarkProgressiveConfig } from '../../mark/interface';
 import type { ILineMark } from '../../mark/line';
 import type { ISymbolMark } from '../../mark/symbol';
 import type { ITextMark } from '../../mark/text';
@@ -39,7 +39,7 @@ export interface LineLikeSeriesMixin extends ISeries {
     _fieldX?: string[];
     _fieldY?: string[];
     _fieldZ?: string[];
-    _createMark: (markInfo: ISeriesMarkInfo, option?: ISeriesMarkInitOption) => IMark;
+    _createMark: (markInfo: ISeriesMarkInfo, option?: ISeriesMarkInitOption, config?: ICompileMarkConfig) => IMark;
     _getInvalidDefined: () => boolean;
     _getInvalidConnectType: () => IInvalidType;
     getLayoutRect: () => ILayoutRect;