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

package/types/plugin/components/tooltip-handler/dom/model/text-model.d.ts

@@ -0,0 +1,5 @@
+import { BaseTooltipModel } from './base-tooltip-model';
+export declare class TextModel extends BaseTooltipModel {
+    init(classList?: string[], id?: string, tag?: keyof HTMLElementTagNameMap): void;
+    setContent(content?: any, multiLine?: boolean): void;
+}

package/types/plugin/components/tooltip-handler/dom/model/title-model.d.ts

@@ -0,0 +1,15 @@
+import type { Maybe } from '@visactor/vutils';
+import { BaseTooltipModel } from './base-tooltip-model';
+import { ShapeModel } from './shape-model';
+import { TextModel } from './text-model';
+export declare class TitleModel extends BaseTooltipModel {
+    shape: Maybe<ShapeModel>;
+    textSpan: Maybe<TextModel>;
+    init(): void;
+    private _initShape;
+    private _releaseShape;
+    private _initTextSpan;
+    setStyle(style?: Partial<CSSStyleDeclaration>): void;
+    setContent(): void;
+    release(): void;
+}

package/types/plugin/components/tooltip-handler/dom/model/tooltip-model.d.ts

@@ -0,0 +1,21 @@
+import { BaseTooltipModel } from './base-tooltip-model';
+import { ContentModel } from './content-model';
+import type { ITooltipModelOption } from './interface';
+import { TitleModel } from './title-model';
+export declare class TooltipModel extends BaseTooltipModel {
+    title: TitleModel | null;
+    content: ContentModel | null;
+    private _classList;
+    private _id;
+    constructor(option: ITooltipModelOption, classList: string[], id: string);
+    setVisibility(visibility: boolean): void;
+    init(): void;
+    private _initPanel;
+    private _initTitle;
+    private _releaseTitle;
+    private _initContent;
+    private _releaseContent;
+    setStyle(): void;
+    setContent(): void;
+    release(): void;
+}

package/types/plugin/components/tooltip-handler/dom/utils/common.d.ts

@@ -0,0 +1,3 @@
+export declare const getPixelPropertyStr: (num?: number | number[], defaultStr?: string) => string;
+export declare const pixelPropertyStrToNumber: (str: string) => number | number[];
+export declare const getScrollbarWidth: (container?: HTMLElement) => number;

package/types/plugin/components/tooltip-handler/dom/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './common';
+export * from './style';

package/types/plugin/components/tooltip-handler/dom/utils/style.d.ts

@@ -0,0 +1,4 @@
+import type { Maybe } from '@visactor/vutils';
+import type { ITooltipAttributes } from '../../interface';
+import type { IDomTooltipStyle } from '../interface';
+export declare function getDomStyles(attributes?: Maybe<ITooltipAttributes>): IDomTooltipStyle;

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

@@ -0,0 +1,2 @@
+export * from './dom';
+export * from './canvas';

package/types/plugin/components/tooltip-handler/interface/common.d.ts

@@ -0,0 +1,4 @@
+import type { ITooltipHandler } from '../../../../typings';
+export interface ITooltipHandlerConstructor {
+    new (): ITooltipHandler;
+}

package/types/plugin/components/tooltip-handler/interface/index.d.ts

@@ -0,0 +1,2 @@
+export * from './style';
+export * from './common';

package/types/plugin/components/tooltip-handler/interface/style.d.ts

@@ -0,0 +1,13 @@
+import type { TooltipAttributes } from '@visactor/vrender-components';
+import type { ITextAttribute, IFillStyle, RichTextWordBreak } from '@visactor/vrender-core';
+export interface ITooltipTextStyle extends Partial<ITextAttribute & IFillStyle> {
+    spacing?: number;
+    multiLine?: boolean;
+    maxWidth?: number;
+    wordBreak?: RichTextWordBreak;
+    autoWidth?: boolean;
+}
+export interface ITooltipAttributes extends TooltipAttributes {
+    panelDomHeight?: number;
+    maxContentHeight?: number;
+}

package/types/plugin/components/tooltip-handler/utils/attribute.d.ts

@@ -0,0 +1,8 @@
+import type { TooltipPanelAttrs } from '@visactor/vrender-components';
+import type { IToolTipActual } from '../../../../typings';
+import type { ITooltipAttributes, ITooltipTextStyle } from '../interface';
+import type { ITheme } from '../../../../theme';
+import type { ITooltipSpec, ITooltipTextTheme, ITooltipTheme } from '../../../../component/tooltip';
+export declare function getTextAttributes(style?: ITooltipTextTheme, globalTheme?: ITheme, defaultAttributes?: Partial<ITooltipTextStyle>): ITooltipTextStyle;
+export declare const getPanelAttributes: (style: ITooltipTheme['panel']) => TooltipPanelAttrs;
+export declare const getTooltipAttributes: (actualTooltip: IToolTipActual, spec: ITooltipSpec, globalTheme: ITheme) => ITooltipAttributes;

package/types/plugin/components/tooltip-handler/utils/common.d.ts

@@ -0,0 +1,20 @@
+import type { Datum } from '@visactor/vgrammar-core';
+import type { IToolTipLinePattern, ITooltipPattern, MaybeArray, TooltipContentProperty, TooltipData, TooltipPatternProperty } from '../../../../typings';
+import type { ITooltipTextStyle } from '../interface/style';
+import type { TooltipRichTextAttrs } from '@visactor/vrender-components';
+import type { TooltipHandlerParams } from '../../../../component/tooltip';
+export declare function escapeHTML(value: any): string;
+export declare const getTooltipContentValue: <T>(field?: TooltipContentProperty<T>, datum?: any, params?: TooltipHandlerParams) => T;
+export declare const getTooltipPatternValue: <T>(field?: TooltipPatternProperty<T>, data?: TooltipData, params?: TooltipHandlerParams) => T;
+export declare const getTooltipContentPattern: (field?: ITooltipPattern['content'], data?: TooltipData, params?: TooltipHandlerParams) => Array<IToolTipLinePattern> | undefined;
+export declare function getFirstDatumFromTooltipData(data: TooltipData): Datum;
+export declare function pickFirstValidValue<T>(isValid: (element?: T) => any, ...elements: T[]): T | undefined;
+export declare function convertToColorString(color: any, defaultColor?: string): string;
+export declare const getScale: (element: HTMLElement, boundingClientRect?: DOMRect) => number;
+interface ITooltipTextInfo {
+    width: number;
+    height: number;
+    text: MaybeArray<number> | MaybeArray<string> | TooltipRichTextAttrs;
+}
+export declare const measureTooltipText: (text: string | TooltipRichTextAttrs, style: ITooltipTextStyle) => ITooltipTextInfo;
+export {};

package/types/plugin/components/tooltip-handler/utils/compose.d.ts

@@ -0,0 +1,4 @@
+import type { IToolTipLinePattern, ITooltipPattern, TooltipData, IToolTipLineActual } from '../../../../typings/tooltip';
+import type { TooltipActualTitleContent, TooltipHandlerParams } from '../../../../component/tooltip';
+export declare const getShowContent: (pattern: ITooltipPattern, data: TooltipData, params: TooltipHandlerParams) => TooltipActualTitleContent | null;
+export declare const getOneLineData: (datum: any, config: IToolTipLinePattern, params: TooltipHandlerParams) => IToolTipLineActual;

package/types/plugin/components/tooltip-handler/utils/get-spec.d.ts

@@ -0,0 +1,5 @@
+import type { TooltipActiveType } from '../../../../typings';
+import type { ISeries } from '../../../../series/interface';
+import type { IDimensionInfo } from '../../../../event/events/dimension/interface';
+import type { ITooltipSpec } from '../../../../component/tooltip';
+export declare const getTooltipSpecForShow: (activeType: TooltipActiveType, globalSpec: ITooltipSpec, series?: ISeries, dimensionInfo?: IDimensionInfo[]) => ITooltipSpec;

package/types/plugin/components/tooltip-handler/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from './common';
+export * from './compose';
+export * from './pattern';
+export * from './get-spec';
+export * from './position';
+export * from './attribute';

package/types/plugin/components/tooltip-handler/utils/pattern.d.ts

@@ -0,0 +1,4 @@
+import type { IDimensionInfo } from '../../../../event/events/dimension/interface';
+import type { ISeries } from '../../../../series/interface';
+import type { ITooltipPattern, TooltipActiveType } from '../../../../typings';
+export declare const makeDefaultPattern: (series: ISeries, activeType: TooltipActiveType, dimensionInfo?: IDimensionInfo[]) => ITooltipPattern | null;

package/types/plugin/components/tooltip-handler/utils/position.d.ts

@@ -0,0 +1,7 @@
+import { TooltipFixedPosition } from '../../../../typings/tooltip/position';
+export declare const getActualTooltipPositionValue: (position: number | ((event: MouseEvent) => number), event: MouseEvent) => number;
+export type TooltipHorizontalPositionType = 'left' | 'right' | 'middle';
+export type TooltipVerticalPositionType = 'top' | 'bottom' | 'middle';
+export declare const positionType: Record<TooltipFixedPosition, [TooltipHorizontalPositionType, TooltipVerticalPositionType]>;
+export declare const getHorizontalPositionType: (position: TooltipFixedPosition, defaultCase?: TooltipHorizontalPositionType) => TooltipHorizontalPositionType;
+export declare const getVerticalPositionType: (position: TooltipFixedPosition, defaultCase?: TooltipVerticalPositionType) => TooltipVerticalPositionType;

package/types/region/interface.d.ts

@@ -63,7 +63,4 @@ export interface IGeoRegionSpec extends IRegionSpec {
 export interface IRegionSpecInfo<T extends IRegionSpec = IRegionSpec> extends IModelSpecInfo {
     type: 'region';
     spec: T;
-    seriesIndexes?: number[];
-    markLabel?: IModelSpecInfo;
-    geoCoordinate?: IModelSpecInfo;
 }

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

@@ -1,5 +1,7 @@
+import type { IChartSpecInfo } from '../../chart/interface';
 import { LineLikeSeriesSpecTransformer } from '../mixin/line-mixin-transformer';
 import type { IAreaSeriesSpec, IAreaSeriesTheme } from './interface';
 export declare class AreaSeriesSpecTransformer<T extends IAreaSeriesSpec = IAreaSeriesSpec, K extends IAreaSeriesTheme = IAreaSeriesTheme> extends LineLikeSeriesSpecTransformer<T, K> {
     protected _transformLabelSpec(spec: T): void;
+    protected _transformSpecAfterMergingTheme(spec: T, chartSpec: any, chartSpecInfo?: IChartSpecInfo): void;
 }

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

@@ -19,7 +19,6 @@ export declare class AreaSeries<T extends IAreaSeriesSpec = IAreaSeriesSpec> ext
     protected _areaMark: IAreaMark;
     protected _supportStack: boolean;
     protected _sortDataByAxis: boolean;
-    setAttrFromSpec(): void;
     initMark(): void;
     initMarkStyle(): void;
     initAnimation(): void;

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

@@ -36,12 +36,25 @@ export declare class BarSeries<T extends IBarSeriesSpec = IBarSeriesSpec> extend
     private _shouldDoPreCalculate;
     private _calculateStackRectPosition;
     private _calculateRectPosition;
+    protected _dataToPosX(datum: Datum): number;
+    protected _dataToPosX1(datum: Datum): number;
+    protected _dataToPosY(datum: Datum): number;
+    protected _dataToPosY1(datum: Datum): number;
     initBandRectMarkStyle(): void;
-    protected _initBarBackgroundMarkStyle(): void;
+    protected _initBandBarBackgroundMarkStyle(): void;
     initLinearRectMarkStyle(): void;
+    protected _initLinearBarBackgroundMarkStyle(): void;
     initAnimation(): void;
-    protected _getBarWidth(axisHelper: IAxisHelper): number;
-    protected _getPosition(direction: DirectionType, datum: Datum): number;
+    protected _getBarWidth(axisHelper: IAxisHelper, scaleDepth?: number): number;
+    protected _getPosition(direction: DirectionType, datum: Datum, scaleDepth?: number, mark?: SeriesMarkNameEnum): number;
+    protected _barBackgroundPositionXEncoder?: (datum: Datum) => number;
+    protected _getBarBackgroundPositionXEncoder: () => (datum: Datum) => number;
+    protected _setBarBackgroundPositionXEncoder: (encoder: (datum: Datum) => number) => void;
+    dataToBarBackgroundPositionX(datum: Datum, scaleDepth?: number): number;
+    protected _barBackgroundPositionYEncoder?: (datum: Datum) => number;
+    protected _getBarBackgroundPositionYEncoder: () => (datum: Datum) => number;
+    protected _setBarBackgroundPositionYEncoder: (encoder: (datum: Datum) => number) => void;
+    dataToBarBackgroundPositionY(datum: Datum, scaleDepth?: number): number;
     onLayoutEnd(ctx: any): void;
     compile(): void;
     getDefaultShapeType(): string;

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

@@ -13,7 +13,7 @@ export interface IBarSeriesSpec extends ICartesianSeriesSpec, IAnimationSpec<Bar
     xField?: string | string[];
     yField?: string | string[];
     [SeriesMarkNameEnum.bar]?: IMarkSpec<IRectMarkSpec>;
-    [SeriesMarkNameEnum.barBackground]?: IMarkSpec<IRectMarkSpec>;
+    [SeriesMarkNameEnum.barBackground]?: IMarkSpec<IRectMarkSpec> & IBarBackgroundSpec;
     [SeriesMarkNameEnum.label]?: Omit<ILabelSpec, 'position'> & {
         position?: Functional<'outside' | 'top' | 'bottom' | 'left' | 'right' | 'inside' | 'inside-top' | 'inside-bottom' | 'inside-right' | 'inside-left' | 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left'>;
     };
@@ -23,9 +23,12 @@ export interface IBarSeriesSpec extends ICartesianSeriesSpec, IAnimationSpec<Bar
     barGapInGroup?: number | string | (number | string)[];
     barMinHeight?: number;
 }
+export interface IBarBackgroundSpec {
+    fieldLevel?: number;
+}
 export interface IBarSeriesTheme extends ICartesianSeriesTheme {
     [SeriesMarkNameEnum.bar]?: Partial<IMarkTheme<IRectMarkSpec>>;
-    [SeriesMarkNameEnum.barBackground]?: IMarkSpec<IRectMarkSpec>;
+    [SeriesMarkNameEnum.barBackground]?: Partial<IMarkTheme<IRectMarkSpec>> & IBarBackgroundSpec;
     barWidth?: number;
     barMinWidth?: number;
     barMaxWidth?: number;

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

@@ -7,12 +7,12 @@ import { BaseModel } from '../../model/base-model';
 import type { ISeriesOption, ISeries, ISeriesMarkInitOption, ISeriesStackData, ISeriesTooltipHelper, SeriesMarkMap, ISeriesMarkInfo, ISeriesSpecInfo } from '../interface';
 import type { IModelEvaluateOption, IModelRenderOption } from '../../model/interface';
 import type { AddVChartPropertyContext } from '../../data/transforms/add-property';
-import type { ITrigger } from '../../interaction/interface';
 import type { StatisticOperations } from '../../data/transforms/dimension-statistics';
 import { SeriesData } from './series-data';
 import type { IGroupMark } from '../../mark/group';
-import type { ISeriesMarkAttributeContext } from '../../compile/mark';
+import { STATE_VALUE_ENUM, type ISeriesMarkAttributeContext } from '../../compile/mark';
 import { BaseSeriesSpecTransformer } from './base-series-transformer';
+import type { EventType } from '@visactor/vgrammar-core';
 export declare abstract class BaseSeries<T extends ISeriesSpec> extends BaseModel<T> implements ISeries {
     readonly specKey: string;
     readonly type: string;
@@ -23,8 +23,6 @@ export declare abstract class BaseSeries<T extends ISeriesSpec> extends BaseMode
     static readonly transformerConstructor: typeof BaseSeriesSpecTransformer;
     readonly transformerConstructor: any;
     getSpecInfo: () => ISeriesSpecInfo;
-    protected _trigger: ITrigger;
-    getTrigger(): ITrigger;
     protected _option: ISeriesOption;
     readonly coordinate: CoordinateType;
     protected _region: IRegion;
@@ -76,6 +74,7 @@ export declare abstract class BaseSeries<T extends ISeriesSpec> extends BaseMode
     getInvalidType(): IInvalidType;
     setInvalidType(t: IInvalidType): void;
     protected _markAttributeContext: ISeriesMarkAttributeContext;
+    getMarkAttributeContext(): ISeriesMarkAttributeContext;
     constructor(spec: T, options: ISeriesOption);
     created(): void;
     protected _buildMarkAttributeContext(): void;
@@ -122,11 +121,40 @@ export declare abstract class BaseSeries<T extends ISeriesSpec> extends BaseMode
     setValueFieldToStackOffsetSilhouette(): void;
     abstract getActiveMarks(): IMark[];
     initRootMark(): void;
-    protected _initExtensionMark(): void;
+    protected _initExtensionMark(options: {
+        hasAnimation: boolean;
+        depend?: IMark[];
+    }): void;
     private _createExtensionMark;
     protected _updateExtensionMarkSpec(lastSpec?: any): void;
     getStackData(): ISeriesStackData;
-    initTrigger(): void;
+    protected _parseDefaultInteractionConfig(mainMarks?: IMark[]): ({
+        seriesId: number;
+        regionId: number;
+        selector: string[];
+        type: string;
+        trigger: EventType;
+        resetTrigger: EventType;
+        blurState: STATE_VALUE_ENUM;
+        highlightState: STATE_VALUE_ENUM;
+        reverseState?: undefined;
+        state?: undefined;
+        isMultiple?: undefined;
+    } | {
+        type: string;
+        seriesId: number;
+        regionId: number;
+        selector: string[];
+        trigger: EventType;
+        resetTrigger: EventType;
+        reverseState: STATE_VALUE_ENUM;
+        state: STATE_VALUE_ENUM;
+        isMultiple: boolean;
+        blurState?: undefined;
+        highlightState?: undefined;
+    })[];
+    protected _parseInteractionConfig(mainMarks?: IMark[]): void;
+    initInteraction(): void;
     initAnimation(): void;
     initMarkState(): void;
     initSeriesStyleState(): void;
@@ -195,4 +223,5 @@ export declare abstract class BaseSeries<T extends ISeriesSpec> extends BaseMode
     getMarkInfoList(): import("../../model/interface").IModelMarkInfo[];
     protected _getInvalidConnectType(): "none" | "zero" | "connect";
     protected _getInvalidDefined: (datum: Datum) => boolean;
+    protected _getRelatedComponentSpecInfo(specKey: string): import("../../model/interface").IModelSpecInfo<any>[];
 }

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

@@ -1,2 +1,6 @@
 import type { SeriesMarkMap } from '../interface/common';
 export declare const baseSeriesMark: SeriesMarkMap;
+export declare const RECT_X: string;
+export declare const RECT_X1: string;
+export declare const RECT_Y: string;
+export declare const RECT_Y1: string;

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

@@ -1,5 +1,5 @@
 import type { TooltipHandlerParams } from '../../component/tooltip/interface';
-import type { ITooltipPattern, ShapeType, TooltipActiveType } from '../../typings';
+import type { IToolTipLinePattern, ITooltipPattern, ShapeType, TooltipActiveType } from '../../typings';
 import type { ISeries, ISeriesTooltipHelper } from '../interface';
 import { BaseTooltipHelper } from '../../model/tooltip-helper';
 import type { IDimensionInfo } from '../../event/events/dimension/interface';
@@ -26,4 +26,6 @@ export declare class BaseSeriesTooltipHelper extends BaseTooltipHelper implement
     titleValueCallback: (datum: Datum, params?: TooltipHandlerParams) => string | undefined;
     getDefaultTooltipPattern(activeType: TooltipActiveType, dimensionInfo?: IDimensionInfo[]): ITooltipPattern | null;
 }
+export declare const addExtraInfoToTooltipTitlePattern: <T>(pattern: ITooltipPattern['title'], extraInfo: T | ((line: IToolTipLinePattern) => T), overwrite?: boolean) => ITooltipPattern['title'] | undefined;
+export declare const addExtraInfoToTooltipContentPattern: <T>(pattern: ITooltipPattern['content'], extraInfo: T | ((line: IToolTipLinePattern) => T), overwrite?: boolean) => ITooltipPattern['content'] | undefined;
 export {};

package/types/series/cartesian/cartesian.d.ts

@@ -76,9 +76,14 @@ export declare abstract class CartesianSeries<T extends ICartesianSeriesSpec = I
     protected _axisPosition(helper: IAxisHelper, value: StringOrNumber | StringOrNumber[], datum?: any): number;
     valueToPositionX(value: StringOrNumber | StringOrNumber[], datum?: any): number;
     valueToPositionY(value: StringOrNumber | StringOrNumber[], datum?: any): number;
+    protected _dataToPosition(datum: Datum, axisHelper: IAxisHelper, field: string[], scaleDepth: number | undefined, getEncoder: () => (datum: Datum) => number, setEncoder: (encoder: (datum: Datum) => number) => void): number;
     protected _positionXEncoder?: (datum: Datum) => number;
+    protected _getPositionXEncoder: () => (datum: Datum) => number;
+    protected _setPositionXEncoder: (encoder: (datum: Datum) => number) => void;
     dataToPositionX(datum: Datum): number;
     protected _positionYEncoder?: (datum: Datum) => number;
+    protected _getPositionYEncoder: () => (datum: Datum) => number;
+    protected _setPositionYEncoder: (encoder: (datum: Datum) => number) => void;
     dataToPositionY(datum: Datum): number;
     dataToPositionZ(datum: Datum): number;
     dataToPositionX1(datum: Datum): number;
@@ -90,6 +95,7 @@ export declare abstract class CartesianSeries<T extends ICartesianSeriesSpec = I
     getRegionRectRight(): number;
     afterInitMark(): void;
     getDimensionField(): string[];
+    getDimensionContinuousField(): string[];
     getMeasureField(): string[];
     viewDataUpdate(d: DataView): void;
     _sortDataInAxisDomain(): void;

package/types/series/gauge/gauge-pointer.d.ts

@@ -30,6 +30,7 @@ export declare class GaugePointerSeries<T extends IGaugePointerSeriesSpec = IGau
     };
     private initPinBackgroundMarkStyle;
     private initPinMarkStyle;
+    initInteraction(): void;
     initAnimation(): void;
     getDefaultShapeType(): string;
     getActiveMarks(): IMark[];

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

@@ -29,6 +29,7 @@ export declare class HeatmapSeries<T extends IHeatmapSeriesSpec = IHeatmapSeries
         scale: any;
         field: any;
     };
+    initInteraction(): void;
     initAnimation(): void;
     protected getCellSize(axisHelper: IAxisHelper): number;
     protected initTooltip(): void;

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

@@ -67,6 +67,8 @@ export interface ISeriesMarkInitOption {
     progressive?: IMarkProgressiveConfig;
     support3d?: boolean;
     customShape?: (datum: any[], attrs: any, path: ICustomPath2D) => ICustomPath2D;
+    stateSort?: (stateA: string, stateB: string) => number;
+    componentType?: string;
 }
 export interface ISeriesMarkInfo extends IModelMarkInfo {
     name: SeriesMarkNameEnum | string;
@@ -76,5 +78,4 @@ export interface ISeriesSpecInfo<T extends ISeriesSpec = ISeriesSpec> extends IM
     type: string | SeriesTypeEnum;
     spec: T;
     markLabelSpec?: Partial<Record<SeriesMarkNameEnum, TransformedLabelSpec[]>>;
-    totalLabel?: IModelSpecInfo;
 }

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

@@ -1,4 +1,3 @@
-import type { ITrigger } from '../../interaction/interface';
 import type { PanEventParam, ZoomEventParam } from '../../event/interface';
 import type { IModel } from '../../model/interface';
 import type { DataSet, DataView, ITransformOptions } from '@visactor/vdataset';
@@ -11,7 +10,7 @@ import type { IPolarAxisHelper } from '../../component/axis/polar/interface';
 import type { ISeriesSeriesInfo, ISeriesSpecInfo, ISeriesStackData } from './common';
 import type { ISeriesTooltipHelper } from './tooltip-helper';
 import type { IInvalidType, Datum, DirectionType, IGroup, StringOrNumber } from '../../typings';
-import type { StateValueType } from '../../compile/mark';
+import type { ISeriesMarkAttributeContext, StateValueType } from '../../compile/mark';
 import type { StatisticOperations } from '../../data/transforms/dimension-statistics';
 import type { IGroupMark } from '../../mark/group';
 import type { IGeoCoordinateHelper } from '../../component/geo/interface';
@@ -90,11 +89,11 @@ export interface ISeries extends IModel {
     };
     getDefaultColorDomain: () => any[];
     getInvalidType: () => IInvalidType;
-    getTrigger: () => ITrigger;
     getDefaultShapeType: () => string;
     initLabelMarkStyle?: (labelMark: ILabelMark) => void;
     getGroupFields: () => string[];
     getSpecInfo: () => ISeriesSpecInfo;
+    getMarkAttributeContext: () => ISeriesMarkAttributeContext;
 }
 export interface ICartesianSeries extends ISeries {
     readonly coordinate: 'cartesian';

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

@@ -25,6 +25,7 @@ import type { ICorrelationSeriesTheme } from '../correlation/interface';
 import { SeriesTypeEnum } from './type';
 import type { SeriesMarkMap } from './common';
 import type { IRangeAreaSeriesTheme } from '../range-area/interface';
+import type { ILiquidSeriesTheme } from '../liquid/interface';
 export interface ISeriesTheme {
     [SeriesTypeEnum.bar]?: IBarSeriesTheme;
     [SeriesTypeForThemeEnum.bar_vertical]?: IBarSeriesTheme;
@@ -76,6 +77,7 @@ export interface ISeriesTheme {
     [SeriesTypeEnum.circlePacking]?: ICirclePackingSeriesTheme;
     [SeriesTypeEnum.heatmap]?: IHeatmapSeriesTheme;
     [SeriesTypeEnum.correlation]?: ICorrelationSeriesTheme;
+    [SeriesTypeEnum.liquid]?: ILiquidSeriesTheme;
 }
 export declare enum SeriesTypeForThemeEnum {
     area_horizontal = "area_horizontal",

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

@@ -31,9 +31,10 @@ export declare enum SeriesTypeEnum {
     circlePacking = "circlePacking",
     waterfall = "waterfall",
     heatmap = "heatmap",
-    correlation = "correlation"
+    correlation = "correlation",
+    liquid = "liquid"
 }
-export declare enum SeriesMarkNameEnum {
+export declare const enum SeriesMarkNameEnum {
     label = "label",
     point = "point",
     line = "line",
@@ -88,6 +89,8 @@ export declare enum SeriesMarkNameEnum {
     centerLabel = "centerLabel",
     barBackground = "barBackground",
     lineLabel = "lineLabel",
-    areaLabel = "areaLabel"
+    areaLabel = "areaLabel",
+    liquid = "liquid",
+    liquidBackground = "liquidBackground",
+    liquidOutline = "liquidOutline"
 }
-export declare const seriesMarkNameSet: Set<string>;

package/types/series/link/link.d.ts

@@ -44,6 +44,7 @@ export declare class LinkSeries<T extends ILinkSeriesSpec = ILinkSeriesSpec> ext
         scale: any;
         field: string;
     };
+    initInteraction(): void;
     protected initTooltip(): void;
     protected onMarkTreePositionUpdate(marks: IMark[]): void;
     getDotInfoData(): import("../../compile/mark/mark-data").MarkData;

package/types/series/liquid/animation.d.ts

@@ -0,0 +1,14 @@
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+export interface ILiquidAnimationParams {
+    height: {
+        from: () => number | number;
+        to: () => number | number;
+    };
+    y: {
+        from: () => number | number;
+        to: () => number | number;
+    };
+}
+export type LiquidAppearPreset = 'wave' | 'grow' | 'waveGrow';
+export declare function liquidPresetAnimation(params: ILiquidAnimationParams, preset: LiquidAppearPreset): IAnimationTypeConfig;
+export declare const registerLiquidAnimation: () => void;

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

@@ -0,0 +1,2 @@
+import type { SeriesMarkMap } from '../interface/common';
+export declare const LiquidSeriesMark: SeriesMarkMap;

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

@@ -0,0 +1,35 @@
+import type { IMarkSpec, IMarkTheme } from '../../typings/spec/common';
+import type { ILiquidMarkSpec, IGroupMarkSpec, ILiquidOutlineSpec } from '../../typings/visual';
+import type { SeriesMarkNameEnum } from '../interface/type';
+import type { IAnimationSpec } from '../../animation/spec';
+import type { LiquidAppearPreset } from './animation';
+import type { SymbolType } from '@visactor/vrender-core';
+import type { ISymbolMark } from '../../mark/symbol';
+type LiquidMarks = 'liquid';
+export type LiquidShapeType = SymbolType | 'drop';
+export type ILiquidPadding = {
+    left?: number;
+    right?: number;
+    top?: number;
+    bottom?: number;
+};
+export type ILiquidPaddingSpec = ILiquidPadding | number | number[];
+export interface ILiquidSeriesSpec extends IAnimationSpec<LiquidMarks, LiquidAppearPreset> {
+    type: 'liquid';
+    valueField?: string;
+    maskShape?: LiquidShapeType;
+    outlineMargin?: ILiquidPaddingSpec;
+    outlinePadding?: ILiquidPaddingSpec;
+    indicatorSmartInvert?: boolean;
+    [SeriesMarkNameEnum.liquid]?: IMarkSpec<ILiquidMarkSpec>;
+    [SeriesMarkNameEnum.liquidBackground]?: IMarkSpec<IGroupMarkSpec>;
+    [SeriesMarkNameEnum.liquidOutline]?: IMarkSpec<ISymbolMark>;
+}
+export interface ILiquidSeriesTheme {
+    outlineMargin?: ILiquidPaddingSpec;
+    outlinePadding?: ILiquidPaddingSpec;
+    [SeriesMarkNameEnum.liquid]?: Partial<IMarkTheme<ILiquidMarkSpec>>;
+    [SeriesMarkNameEnum.liquidBackground]?: IMarkSpec<IGroupMarkSpec>;
+    [SeriesMarkNameEnum.liquidOutline]?: IMarkSpec<ILiquidOutlineSpec>;
+}
+export {};

package/types/series/liquid/liquid.d.ts

@@ -0,0 +1,50 @@
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { Datum, ILiquidMarkSpec, IPoint } from '../../typings';
+import type { ILiquidSeriesSpec } from './interface';
+import type { IMark, IMarkRaw } from '../../mark/interface';
+import { LineLikeSeriesSpecTransformer } from '../mixin/line-mixin-transformer';
+import { BaseSeries } from '../base';
+import type { DataView } from '@visactor/vdataset';
+export type ILiquidMark = IMarkRaw<ILiquidMarkSpec>;
+export declare class LiquidSeries<T extends ILiquidSeriesSpec = ILiquidSeriesSpec> extends BaseSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    static readonly transformerConstructor: typeof LineLikeSeriesSpecTransformer;
+    readonly transformerConstructor: typeof LineLikeSeriesSpecTransformer;
+    private _liquidMark?;
+    private _liquidBackgroundMark?;
+    private _liquidOutlineMark?;
+    private _paddingSpec?;
+    private _marginSpec?;
+    private _heightRatio?;
+    protected _valueField?: string;
+    setValueField(field: string): void;
+    getValueField(): string;
+    setAttrFromSpec(): void;
+    rawDataUpdate(d: DataView): void;
+    initMark(): void;
+    initMarkStyle(): void;
+    private _initLiquidOutlineMark;
+    private _initLiquidBackgroundMark;
+    private _initLiquidMark;
+    private _getPosAndSizeFormRegion;
+    private _initLiquidOutlineMarkStyle;
+    private _initLiquidBackgroundMarkStyle;
+    private _initLiquidMarkStyle;
+    protected initTooltip(): void;
+    initInteraction(): void;
+    initAnimation(): void;
+    protected initEvent(): void;
+    dataToPosition(data: Datum): IPoint;
+    dataToPositionX(data: Datum): number;
+    dataToPositionY(data: Datum): number;
+    valueToPosition(value1: any, value2?: any): IPoint;
+    getStatisticFields(): any[];
+    getGroupFields(): string[];
+    getStackGroupFields(): string[];
+    getStackValueField(): string;
+    getActiveMarks(): IMark[];
+}
+export declare const registerLiquidSeries: () => void;

package/types/series/liquid/tooltip-helper.d.ts

@@ -0,0 +1,9 @@
+import type { ISeriesTooltipHelper } from '../interface';
+import { BaseSeriesTooltipHelper } from '../base/tooltip-helper';
+import type { Datum, ITooltipPattern, TooltipActiveType } from '../../typings';
+export declare class LiquidSeriesTooltipHelper extends BaseSeriesTooltipHelper implements ISeriesTooltipHelper {
+    getDefaultTooltipPattern(activeType: TooltipActiveType): ITooltipPattern | null;
+    getContentKey: () => (datum: any) => string;
+    getContentValue: () => (datum: any) => any;
+    getLiquidFillColor: (datum: Datum) => any;
+}

package/types/series/liquid/util.d.ts

@@ -0,0 +1,2 @@
+import type { LiquidShapeType } from './interface';
+export declare const getShapes: (shapesType: LiquidShapeType, size: number) => string;

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

@@ -1,5 +1,4 @@
 import type { ISeriesOption } from '../interface/common';
-import type { ITrigger } from '../../interaction/interface';
 import type { ISeries } from '../interface/series';
 import type { IMark, IMarkProgressiveConfig } from '../../mark/interface';
 import type { ILineMark } from '../../mark/line';
@@ -28,7 +27,6 @@ export interface LineLikeSeriesMixin extends ISeries {
     _option: ISeriesOption;
     _seriesField: string;
     _theme: Maybe<ILineLikeSeriesTheme>;
-    _trigger: ITrigger;
     _tooltipHelper: ISeriesTooltipHelper;
     _invalidType: IInvalidType;
     _region: IRegion;
@@ -56,6 +54,8 @@ export declare class LineLikeSeriesMixin {
     protected _dimensionTrigger(params: DimensionEventParams): void;
     initSymbolMark(progressive?: IMarkProgressiveConfig, isSeriesMark?: boolean): ISymbolMark;
     initSymbolMarkStyle(): ISymbolMark;
+    private _initSymbolMark;
+    private _initSymbolActiveMarkAlone;
     initLabelMarkStyle(labelMark?: ILabelMark): void;
     initLineLabelMarkStyle(labelMark?: ILabelMark): void;
     encodeDefined(mark: IMark, attr: string): void;