@visactor/vchart-types 1.12.15 → 1.13.0

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

@@ -99,6 +99,7 @@ export declare class BaseChart<T extends IChartSpec> extends CompilableBase impl
     getModelByUserId(userId: StringOrNumber): IModel | undefined;
     getAllMarks(): IMark[];
     getMarkById(id: number): IMark | undefined;
+    getMarkByUserName(name: string): IMark[];
     updateData(id: StringOrNumber, data: unknown, updateGlobalScale?: boolean, options?: IParserOptions): void;
     updateFullData(data: IDataValues | IDataValues[], updateGlobalScale?: boolean): void;
     onRender(option: IChartRenderOption): void;

package/types/chart/index.d.ts

@@ -59,6 +59,8 @@ import type { IVennChartSpec } from './venn';
 import { VennChart, registerVennChart } from './venn';
 import type { IMosaicChartSpec } from './mosaic';
 import { MosaicChart, registerMosaicChart } from './mosaic';
-export { AreaChart, BarChart, Bar3dChart, BoxPlotChart, CirclePackingChart, CommonChart, FunnelChart, Funnel3dChart, GaugeChart, HeatmapChart, HistogramChart, Histogram3dChart, LineChart, MapChart, PieChart, Pie3dChart, CircularProgressChart, LinearProgressChart, RadarChart, RangeColumnChart, RangeColumn3dChart, RangeAreaChart, RoseChart, SankeyChart, ScatterChart, SunburstChart, SequenceChart, WaterfallChart, CorrelationChart, LiquidChart, WordCloudChart, WordCloud3dChart, TreemapChart, VennChart, BaseChart, MosaicChart };
-export { registerLineChart, registerAreaChart, registerBarChart, registerBar3dChart, registerBoxplotChart, registerCirclePackingChart, registerCircularProgressChart, registerCommonChart, registerFunnelChart, registerFunnel3dChart, registerGaugeChart, registerHeatmapChart, registerHistogramChart, registerHistogram3dChart, registerLinearProgressChart, registerMapChart, registerPie3dChart, registerPieChart, registerRadarChart, registerRangeAreaChart, registerRangeColumn3dChart, registerRangeColumnChart, registerRoseChart, registerSankeyChart, registerScatterChart, registerSequenceChart, registerSunburstChart, registerTreemapChart, registerWaterfallChart, registerWordCloud3dChart, registerWordCloudChart, registerCorrelationChart, registerLiquidChart, registerWordCloudShapeChart, registerVennChart, registerMosaicChart };
-export type { IAreaChartSpec, IBarChartSpec, IBar3dChartSpec, IBoxPlotChartSpec, ICirclePackingChartSpec, ICommonChartSpec, IFunnelChartSpec, IFunnel3dChartSpec, IGaugeChartSpec, IHeatmapChartSpec, IHistogramChartSpec, IHistogram3dChartSpec, ILineChartSpec, IMapChartSpec, IPieChartSpec, IPie3dChartSpec, ICircularProgressChartSpec, ILinearProgressChartSpec, IRadarChartSpec, IRangeColumnChartSpec, IRangeColumn3dChartSpec, IRangeAreaChartSpec, IRoseChartSpec, IScatterChartSpec, ISankeyChartSpec, ISequenceChartSpec, ISunburstChartSpec, ITreemapChartSpec, IWaterfallChartSpec, ICorrelationChartSpec, ILiquidChartSpec, IWordCloud3dChartSpec, IWordCloudChartSpec, IPolarChartSpec, ICartesianChartSpec, IVennChartSpec, IMosaicChartSpec };
+import { IPictogramChartSpec } from './pictogram/interface';
+import { PictogramChart, registerPictogramChart } from './pictogram/pictogram';
+export { AreaChart, BarChart, Bar3dChart, BoxPlotChart, CirclePackingChart, CommonChart, FunnelChart, Funnel3dChart, GaugeChart, HeatmapChart, HistogramChart, Histogram3dChart, LineChart, MapChart, PieChart, Pie3dChart, CircularProgressChart, LinearProgressChart, RadarChart, RangeColumnChart, RangeColumn3dChart, RangeAreaChart, RoseChart, SankeyChart, ScatterChart, SunburstChart, SequenceChart, WaterfallChart, CorrelationChart, LiquidChart, WordCloudChart, WordCloud3dChart, TreemapChart, VennChart, BaseChart, MosaicChart, PictogramChart };
+export { registerLineChart, registerAreaChart, registerBarChart, registerBar3dChart, registerBoxplotChart, registerCirclePackingChart, registerCircularProgressChart, registerCommonChart, registerFunnelChart, registerFunnel3dChart, registerGaugeChart, registerHeatmapChart, registerHistogramChart, registerHistogram3dChart, registerLinearProgressChart, registerMapChart, registerPie3dChart, registerPieChart, registerRadarChart, registerRangeAreaChart, registerRangeColumn3dChart, registerRangeColumnChart, registerRoseChart, registerSankeyChart, registerScatterChart, registerSequenceChart, registerSunburstChart, registerTreemapChart, registerWaterfallChart, registerWordCloud3dChart, registerWordCloudChart, registerCorrelationChart, registerLiquidChart, registerWordCloudShapeChart, registerVennChart, registerMosaicChart, registerPictogramChart };
+export type { IAreaChartSpec, IBarChartSpec, IBar3dChartSpec, IBoxPlotChartSpec, ICirclePackingChartSpec, ICommonChartSpec, IFunnelChartSpec, IFunnel3dChartSpec, IGaugeChartSpec, IHeatmapChartSpec, IHistogramChartSpec, IHistogram3dChartSpec, ILineChartSpec, IMapChartSpec, IPieChartSpec, IPie3dChartSpec, ICircularProgressChartSpec, ILinearProgressChartSpec, IRadarChartSpec, IRangeColumnChartSpec, IRangeColumn3dChartSpec, IRangeAreaChartSpec, IRoseChartSpec, IScatterChartSpec, ISankeyChartSpec, ISequenceChartSpec, ISunburstChartSpec, ITreemapChartSpec, IWaterfallChartSpec, ICorrelationChartSpec, ILiquidChartSpec, IWordCloud3dChartSpec, IWordCloudChartSpec, IPolarChartSpec, ICartesianChartSpec, IVennChartSpec, IMosaicChartSpec, IPictogramChartSpec };

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

@@ -79,6 +79,7 @@ export interface IChart extends ICompilable {
     getAllModels: () => IModel[];
     getMarkById: (id: number) => IMark | undefined;
     getAllMarks: () => IMark[];
+    getMarkByUserName: (name: string) => IMark[];
     updateSpec: (spec: any) => IUpdateSpecResult;
     updateState: (state: Record<string, Omit<IMarkStateSpec<unknown>, 'style'>>, filter?: (series: ISeries, mark: IMark, stateKey: string) => boolean) => void;
     setSelected: (datum: MaybeArray<any> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier) => void;

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

@@ -34,5 +34,6 @@ export declare const enum ChartTypeEnum {
     correlation = "correlation",
     liquid = "liquid",
     venn = "venn",
-    mosaic = "mosaic"
+    mosaic = "mosaic",
+    pictogram = "pictogram"
 }

package/types/chart/pictogram/index.d.ts

@@ -0,0 +1,3 @@
+export * from './pictogram';
+export * from './interface';
+export * from './pictogram-transformer';

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

@@ -0,0 +1,6 @@
+import { IPictogramSeriesSpec } from '../../series/pictogram/interface';
+import type { IChartExtendsSeriesSpec, IChartSpec } from '../../typings/spec/common';
+export interface IPictogramChartSpec extends IChartSpec, IChartExtendsSeriesSpec<any> {
+    type: 'pictogram';
+    series?: IPictogramSeriesSpec[];
+}

package/types/chart/pictogram/pictogram-transformer.d.ts

@@ -0,0 +1,8 @@
+import { IPictogramSeriesSpec } from '../../series/pictogram/interface';
+import { BaseChartSpecTransformer } from '../base';
+import type { IPictogramChartSpec } from './interface';
+export declare class PictogramChartSpecTransformer<T extends IPictogramChartSpec = IPictogramChartSpec> extends BaseChartSpecTransformer<T> {
+    protected _isValidSeries(type: string): boolean;
+    protected _getDefaultSeriesSpec(spec: IPictogramChartSpec): IPictogramSeriesSpec;
+    transformSpec(spec: T): void;
+}

package/types/chart/pictogram/pictogram.d.ts

@@ -0,0 +1,12 @@
+import { BaseChart } from '../base/base-chart';
+import type { IPictogramChartSpec } from './interface';
+import { PictogramChartSpecTransformer } from './pictogram-transformer';
+export declare class PictogramChart<T extends IPictogramChartSpec = IPictogramChartSpec> extends BaseChart<T> {
+    static readonly type: string;
+    static readonly seriesType: string;
+    static readonly transformerConstructor: typeof PictogramChartSpecTransformer;
+    readonly transformerConstructor: typeof PictogramChartSpecTransformer;
+    readonly type: string;
+    readonly seriesType: string;
+}
+export declare const registerPictogramChart: () => void;

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

@@ -1,5 +1,5 @@
 import type { ITextAttribute } from '@visactor/vrender-core';
-import type { ITooltipShapePattern, StringOrNumber, TextAlign, TextBaseLine } from '../../../typings';
+import type { ILayoutNumber, ITooltipShapePattern, StringOrNumber, TextAlign, TextBaseLine } from '../../../typings';
 import type { Padding } from '@visactor/vrender-components';
 import type { ITokenKey } from '../../../theme/token';
 export interface ITooltipTextTheme<ColorType = string> {
@@ -42,7 +42,7 @@ export interface ITooltipTheme<ColorType = string> {
     keyLabel?: Omit<ITooltipTextTheme<ColorType>, 'autoWidth'>;
     valueLabel?: ITooltipTextTheme<ColorType>;
     spaceRow?: number;
-    maxContentHeight?: number;
+    maxContentHeight?: ILayoutNumber;
     offset?: {
         x?: number;
         y?: number;

package/types/core/vchart.d.ts

@@ -3,7 +3,7 @@ import type { ILayoutConstructor, LayoutCallBack } from '../layout/interface';
 import type { IDataValues, IMarkStateSpec, IInitOption } from '../typings/spec/common';
 import { RenderModeEnum } from '../typings/spec/common';
 import type { ISeriesConstructor } from '../series/interface';
-import type { DimensionIndexOption, IChart, IChartConstructor, IChartOption, IChartSpecInfo } from '../chart/interface';
+import { type DimensionIndexOption, type IChart, type IChartConstructor, type IChartOption, type IChartSpecInfo } from '../chart/interface';
 import type { IComponentConstructor } from '../component/interface';
 import type { EventCallback, EventParams, EventQuery, EventType } from '../event/interface';
 import type { IParserOptions, Transform } from '@visactor/vdataset';
@@ -38,6 +38,9 @@ export declare class VChart implements IVChart {
     static registerMap(key: string, source: GeoSourceType, option?: GeoSourceOption): void;
     static unregisterMap(key: string): void;
     static getMap(key: string): GeoSourceType;
+    static registerSVG(key: string, source: GeoSourceType, option?: GeoSourceOption): void;
+    static unregisterSVG(key: string): void;
+    static getSVG(key: string): any;
     static hideTooltip(excludeId?: MaybeArray<number>): void;
     static getLogger(): ILogger;
     static readonly InstanceManager: typeof InstanceManager;

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

@@ -0,0 +1,84 @@
+import type { DataView } from '@visactor/vdataset';
+export declare const graphicAttributeTransform: {
+    group: (attributes: Record<string, any>) => {
+        visibleAll: boolean;
+        x: number;
+        y: number;
+        fillStrokeOrder: boolean;
+        fill: any;
+        lineWidth: number;
+        stroke: any;
+    };
+    rule: (attributes: Record<string, any>) => {
+        x: number;
+        y: number;
+        x1: number;
+        y1: number;
+        fillStrokeOrder: boolean;
+        fill: any;
+        lineWidth: number;
+        stroke: any;
+    };
+    rect: (attributes: Record<string, any>) => {
+        fill: any;
+        width: number;
+        height: number;
+        x: number;
+        y: number;
+        fillStrokeOrder: boolean;
+        lineWidth: number;
+        stroke: any;
+    };
+    polygon: (attributes: Record<string, any>) => {
+        fill: any;
+        points: any;
+        x: number;
+        y: number;
+        fillStrokeOrder: boolean;
+        lineWidth: number;
+        stroke: any;
+    };
+    line: (attributes: Record<string, any>) => {
+        points: any;
+        x: number;
+        y: number;
+        fillStrokeOrder: boolean;
+        fill: any;
+        lineWidth: number;
+        stroke: any;
+    };
+    path: (attributes: Record<string, any>) => {
+        path: any;
+        fillStrokeOrder: boolean;
+        x: number;
+        y: number;
+        fill: any;
+        lineWidth: number;
+        stroke: any;
+    };
+    arc: (attributes: Record<string, any>) => {
+        outerRadius: any;
+        x: number;
+        y: number;
+        startAngle: number;
+        endAngle: number;
+        scaleX: number;
+        fill: any;
+        fillStrokeOrder: boolean;
+        lineWidth: number;
+        stroke: any;
+    };
+    text: (attributes: Record<string, any>, value: string) => {
+        text: string;
+        textAlign: any;
+        textBaseLine: any;
+        anchor: number[];
+        fill: any;
+        x: number;
+        y: number;
+        fillStrokeOrder: boolean;
+        lineWidth: number;
+        stroke: any;
+    };
+};
+export declare const pictogram: (data: DataView[]) => {};

package/types/mark/group.d.ts

@@ -11,7 +11,7 @@ export interface IGroupMark extends IMarkRaw<IGroupMarkSpec> {
     getMarks: () => IMark[];
     getMarkInType: (type: MarkType) => IMark[];
     getMarkInId: (id: number) => IMark | undefined;
-    getMarkInName: (name: string) => IMark | undefined;
+    getMarkInName: (name: string) => IMark[];
 }
 export declare class GroupMark extends BaseMark<IGroupMarkSpec> implements IGroupMark {
     static readonly type = MarkTypeEnum.group;
@@ -26,7 +26,8 @@ export declare class GroupMark extends BaseMark<IGroupMarkSpec> implements IGrou
     removeMark(mark: IMark): boolean;
     getMarkInType(type: MarkType): IMark[];
     getMarkInId(id: number): IMark;
-    getMarkInName(name: string): IMark;
+    getMarkInUserId(id: string | number): IMark;
+    getMarkInName(name: string): IMark[];
     protected _compileProduct(option?: IMarkCompileOption): void;
 }
 export declare const registerGroupMark: () => void;

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

@@ -20,5 +20,6 @@ export declare const enum MarkTypeEnum {
     ripple = "ripple",
     liquid = "liquid",
     component = "component",
-    label = "label"
+    label = "label",
+    pictogram = "pictogram"
 }

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

@@ -1,4 +1,3 @@
-import type { Options } from './constants';
 import type { Maybe, RenderMode } from '../../../typings';
 import type { TooltipData, ITooltipActual, TooltipActiveType, ITooltipHandler, ITooltipPositionActual } from '../../../typings/tooltip';
 import type { IGroup } from '@visactor/vrender-core';
@@ -9,7 +8,7 @@ import type { ITooltipSpec, Tooltip, TooltipHandlerParams } from '../../../compo
 import { TooltipResult } from '../../../component/tooltip';
 import type { IComponentPlugin, IComponentPluginService } from '../interface';
 import { BasePlugin } from '../../base/base-plugin';
-import type { ITooltipAttributes } from './interface';
+import type { ITooltipHandlerOptions } from './interface';
 type ChangeTooltipFunc = (visible: boolean, params: TooltipHandlerParams, data?: TooltipData) => TooltipResult;
 type ChangeTooltipPositionFunc = (params: TooltipHandlerParams, data: TooltipData) => TooltipResult;
 export declare abstract class BaseTooltipHandler extends BasePlugin implements ITooltipHandler, IComponentPlugin {
@@ -17,12 +16,11 @@ export declare abstract class BaseTooltipHandler extends BasePlugin implements I
     static readonly specKey = "tooltip";
     readonly type: string;
     protected _visible: boolean;
-    protected _option: Options;
+    protected _option: ITooltipHandlerOptions;
     protected _chartOption: IChartOption;
     protected _env: RenderMode;
     get env(): "desktop-browser" | "mobile-browser" | "node" | "worker" | "miniApp" | "wx" | "tt" | "harmony" | "desktop-miniApp" | "lynx";
     protected _component: Tooltip;
-    protected _attributes?: ITooltipAttributes | null;
     protected _chartContainer: Maybe<HTMLElement>;
     protected _compiler: Compiler;
     protected _container: Maybe<IGroup | HTMLElement>;
@@ -35,9 +33,9 @@ export declare abstract class BaseTooltipHandler extends BasePlugin implements I
     release(): void;
     protected abstract _updateTooltip(visible: boolean, params: TooltipHandlerParams): void;
     protected abstract _removeTooltip(): void;
-    protected _getDefaultOption(): Options;
+    protected abstract _getTooltipBoxSize(actualTooltip: ITooltipActual, changePositionOnly: boolean): IContainerSize | undefined;
+    protected _getDefaultOption(): ITooltipHandlerOptions;
     protected _getActualTooltipPosition: (actualTooltip: ITooltipActual, params: TooltipHandlerParams, tooltipBoxSize: IContainerSize | undefined) => ITooltipPositionActual;
-    protected _getTooltipBoxSize(actualTooltip: ITooltipActual, changePositionOnly: boolean): IContainerSize | undefined;
     protected _getParentElement(spec: ITooltipSpec): HTMLElement;
     getTooltipContainer(): HTMLElement | IGroup;
     protected _initFromSpec(): void;

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

@@ -0,0 +1,26 @@
+import { BaseTooltipHandler } from './base';
+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';
+import type { ITooltipAttributes } from './interface';
+export declare class CanvasTooltipHandler extends BaseTooltipHandler {
+    static readonly type: string;
+    readonly type: string;
+    private _layer;
+    protected _el?: HTMLCanvasElement;
+    protected _tooltipCanvasId?: string;
+    protected _tooltipComponent: TooltipComponent;
+    protected _attributes?: ITooltipAttributes | null;
+    constructor();
+    onAdd(service: IComponentPluginService<any>): void;
+    private _initTooltipComponent;
+    private _getLayer;
+    protected _getTooltipBoxSize(actualTooltip: ITooltipActual, changePositionOnly: boolean): IContainerSize | undefined;
+    protected _removeTooltip(): void;
+    protected _updateTooltip(visible: boolean, params: TooltipHandlerParams): void;
+    isTooltipShown(): boolean;
+    release(): void;
+}
+export declare const registerCanvasTooltipHandler: () => void;

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

@@ -1,9 +1,8 @@
-import { escapeHTML } from './utils/common';
-export declare const TOOLTIP_CONTAINER_EL_CLASS_NAME = "vchart-tooltip-container";
+import type { ITooltipHandlerOptions } from './interface';
+export declare const TOOLTIP_PREFIX = "vchart-tooltip";
+export declare const TOOLTIP_CONTAINER_EL_CLASS_NAME: string;
+export declare const TOOLTIP_TITLE_CLASS_NAME: string;
+export declare const TOOLTIP_CONTENT_BOX_CLASS_NAME: string;
 export declare const TOOLTIP_EMPTY_STRING = "";
-export declare const DEFAULT_OPTIONS: {
-    offsetX: number;
-    offsetY: number;
-    sanitize: typeof escapeHTML;
-};
-export type Options = typeof DEFAULT_OPTIONS;
+export declare const DEFAULT_OPTIONS: ITooltipHandlerOptions;
+export declare const DEFAULT_TOOLTIP_Z_INDEX = "99999999999999";

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

@@ -0,0 +1,42 @@
+import type { ITooltipActual, ITooltipPositionActual } from '../../../typings/tooltip';
+import { BaseTooltipHandler } from './base';
+import { type Maybe } from '@visactor/vutils';
+import type { IContainerSize } from '@visactor/vrender-components';
+import type { ITooltipSpec, TooltipHandlerParams } from '../../../component/tooltip';
+import type { IComponentPluginService } from '../interface';
+import type { ILayoutPoint } from '../../../typings';
+export declare class DomTooltipHandler extends BaseTooltipHandler {
+    static readonly type: string;
+    readonly type: string;
+    protected _tooltipContainer: HTMLElement;
+    protected _domStyle: {
+        panelPadding?: number[];
+        panel: Partial<CSSStyleDeclaration>;
+        row: Partial<CSSStyleDeclaration>;
+        title: Partial<CSSStyleDeclaration>;
+        shape: Partial<CSSStyleDeclaration>;
+        key: Partial<CSSStyleDeclaration>;
+        value: Partial<CSSStyleDeclaration>;
+    };
+    protected _rootDom?: HTMLElement;
+    protected _tooltipActual?: ITooltipActual;
+    protected _container: Maybe<HTMLDivElement>;
+    protected _domString?: string;
+    protected _cacheCustomTooltipPosition: ILayoutPoint;
+    getVisibility(): boolean;
+    setVisibility(_value: boolean): void;
+    constructor();
+    onAdd(service: IComponentPluginService<any>): void;
+    initEl(): void;
+    protected _getTooltipBoxSize(actualTooltip: ITooltipActual, changePositionOnly: boolean): IContainerSize | undefined;
+    protected _removeTooltip(): void;
+    protected _updateTooltip(visible: boolean, params: TooltipHandlerParams): void;
+    protected _initStyle(): void;
+    protected _updateDomStringByCol(actualTooltip?: ITooltipActual): void;
+    protected _updateDomStyle(sizeKey?: 'width' | 'height'): void;
+    protected _getParentElement(spec: ITooltipSpec): HTMLElement;
+    isTooltipShown(): boolean;
+    reInit(): void;
+    protected _updatePosition({ x, y }: ITooltipPositionActual): void;
+}
+export declare const registerDomTooltipHandler: () => void;

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

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

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

@@ -1,2 +1,15 @@
-export * from './style';
-export * from './common';
+import type { TooltipAttributes } from '@visactor/vrender-components';
+import type { ITextAttribute, IFillStyle } from '@visactor/vrender-core';
+export interface ITooltipTextStyle extends Partial<ITextAttribute & IFillStyle> {
+    spacing?: number;
+    multiLine?: boolean;
+    maxWidth?: number;
+    autoWidth?: boolean;
+}
+export interface ITooltipAttributes extends TooltipAttributes {
+    align?: 'left' | 'right';
+}
+export interface ITooltipHandlerOptions {
+    offsetX?: number;
+    offsetY?: number;
+}

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

@@ -1,8 +1,15 @@
-import type { TooltipPanelAttrs } from '@visactor/vrender-components';
-import type { ITooltipActual } from '../../../../typings';
+import type { TooltipPanelAttrs, TooltipRichTextAttrs } from '@visactor/vrender-components';
+import type { ITooltipActual, MaybeArray } from '../../../../typings';
 import type { ITooltipAttributes, ITooltipTextStyle } from '../interface';
 import type { ITheme } from '../../../../theme';
 import type { ITooltipSpec, ITooltipTextTheme, ITooltipTheme } from '../../../../component/tooltip';
+interface ITooltipTextInfo {
+    width: number;
+    height: number;
+    text: MaybeArray<number> | MaybeArray<string> | TooltipRichTextAttrs;
+}
+export declare const measureTooltipText: (text: string | TooltipRichTextAttrs, style: ITooltipTextStyle) => ITooltipTextInfo;
 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;
+export {};

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

@@ -1,14 +1,3 @@
-import type { MaybeArray } from '../../../../typings';
-import type { ITooltipTextStyle } from '../interface/style';
-import type { TooltipRichTextAttrs } from '@visactor/vrender-components';
 export declare function escapeHTML(value: any): string;
-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 {};
+export declare const formatContent: (content: any) => string;

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

@@ -0,0 +1,18 @@
+import type { ITooltipSpec, ITooltipTextTheme, ITooltipTheme } from '../../../../component/tooltip';
+export declare const getPixelPropertyStr: (num?: number | number[], defaultStr?: string) => string;
+export declare const getTextStyle: (style?: ITooltipTextTheme) => Partial<CSSStyleDeclaration>;
+export declare const getDomStyle: (spec?: ITooltipSpec) => {
+    panelPadding: number[];
+    row: Partial<CSSStyleDeclaration>;
+    panel: Partial<CSSStyleDeclaration>;
+    title: Partial<CSSStyleDeclaration>;
+    shape: Partial<CSSStyleDeclaration>;
+    key: Partial<CSSStyleDeclaration>;
+    value: Partial<CSSStyleDeclaration>;
+};
+export declare const getPanelStyle: (style: ITooltipTheme['panel']) => {
+    panelStyle: Partial<CSSStyleDeclaration>;
+    panelPadding?: number[];
+};
+export declare function setStyleToDom(dom: HTMLElement, style: Partial<CSSStyleDeclaration>): void;
+export declare function cssToStyleString(style: Partial<CSSStyleDeclaration>): string;

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

@@ -0,0 +1,2 @@
+import type { ITooltipShapeActual } from '../../../../typings';
+export declare function getSvgHtml(option: ITooltipShapeActual | undefined, index?: number): string;

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

@@ -7,7 +7,7 @@ import { BaseModel } from '../../model/base-model';
 import type { ISeriesOption, ISeries, ISeriesMarkInitOption, ISeriesStackData, ISeriesTooltipHelper, SeriesMarkMap, ISeriesMarkInfo, ISeriesSpecInfo, ISeriesStackDataLeaf, ISeriesStackDataMeta, ISeriesSeriesInfo } from '../interface';
 import type { IModelEvaluateOption, IModelRenderOption, IUpdateSpecResult } from '../../model/interface';
 import type { AddVChartPropertyContext } from '../../data/transforms/add-property';
-import type { IBaseInteractionSpec } from '../../interaction/interface';
+import type { IBaseInteractionSpec, IHoverSpec, ISelectSpec } from '../../interaction/interface';
 import type { StatisticOperations } from '../../data/transforms/dimension-statistics';
 import { SeriesData } from './series-data';
 import type { IGroupMark } from '../../mark/group';
@@ -141,9 +141,6 @@ export declare abstract class BaseSeries<T extends ISeriesSpec> extends BaseMode
         triggerOff: EventType;
         blurState: STATE_VALUE_ENUM;
         highlightState: STATE_VALUE_ENUM;
-        reverseState?: undefined;
-        state?: undefined;
-        isMultiple?: undefined;
     } | {
         type: string;
         seriesId: number;
@@ -154,9 +151,28 @@ export declare abstract class BaseSeries<T extends ISeriesSpec> extends BaseMode
         reverseState: STATE_VALUE_ENUM;
         state: STATE_VALUE_ENUM;
         isMultiple: boolean;
-        blurState?: undefined;
-        highlightState?: undefined;
     })[];
+    protected _defaultHoverConfig(selector: string[], finalHoverSpec: IHoverSpec): {
+        seriesId: number;
+        regionId: number;
+        selector: string[];
+        type: string;
+        trigger: EventType;
+        triggerOff: EventType;
+        blurState: STATE_VALUE_ENUM;
+        highlightState: STATE_VALUE_ENUM;
+    };
+    protected _defaultSelectConfig(selector: string[], finalSelectSpec: ISelectSpec): {
+        type: string;
+        seriesId: number;
+        regionId: number;
+        selector: string[];
+        trigger: EventType;
+        triggerOff: EventType;
+        reverseState: STATE_VALUE_ENUM;
+        state: STATE_VALUE_ENUM;
+        isMultiple: boolean;
+    };
     protected _parseInteractionConfig(mainMarks?: IMark[]): void;
     initInteraction(): void;
     initAnimation(): void;

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

@@ -34,7 +34,8 @@ export declare enum SeriesTypeEnum {
     correlation = "correlation",
     liquid = "liquid",
     venn = "venn",
-    mosaic = "mosaic"
+    mosaic = "mosaic",
+    pictogram = "pictogram"
 }
 export declare const enum SeriesMarkNameEnum {
     label = "label",
@@ -99,5 +100,6 @@ export declare const enum SeriesMarkNameEnum {
     liquidOutline = "liquidOutline",
     circle = "circle",
     overlap = "overlap",
-    overlapLabel = "overlapLabel"
+    overlapLabel = "overlapLabel",
+    pictogram = "pictogram"
 }

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

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

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

@@ -0,0 +1,15 @@
+import type { IPathMarkSpec } from '../../typings/visual';
+import type { IMarkSpec, IMarkTheme, ISeriesSpec } from '../../typings/spec/common';
+import type { IAnimationSpec } from '../../animation/spec';
+export interface IPictogramSeriesSpec extends ISeriesSpec, IAnimationSpec<'pictogram', 'fadeIn'> {
+    type: 'pictogram';
+    svg: string;
+    nameField?: string;
+    valueField?: string;
+    pictogram?: IMarkSpec<Omit<IPathMarkSpec, 'smoothScale'>>;
+    defaultFillColor?: string;
+}
+export interface IPictogramThemeSpec {
+    defaultFillColor?: string;
+    pictogram?: Partial<IMarkTheme<Omit<IPathMarkSpec, 'smoothScale'>>>;
+}

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

@@ -0,0 +1,5 @@
+import type { ISeriesSpec } from '../../typings';
+import { BaseSeriesSpecTransformer } from '../base';
+export declare class PictogramSeriesSpecTransformer<T extends ISeriesSpec, K> extends BaseSeriesSpecTransformer<T, K> {
+    protected _getDefaultSpecFromChart(chartSpec: any): any;
+}

package/types/series/pictogram/pictogram.d.ts

@@ -0,0 +1,77 @@
+import type { SVGParsedElement, SVGParserResult } from '@visactor/vdataset';
+import { PanEventParam, ZoomEventParam } from '../../core';
+import { GeoSeries } from '../geo/geo';
+import { ISeriesSeriesInfo, SeriesMarkMap, SeriesTypeEnum } from '../interface';
+import type { IPictogramSeriesSpec } from './interface';
+import { GroupMark } from '../../mark';
+import { PictogramSeriesSpecTransformer } from './pictogram-transformer';
+import { IMatrix } from '@visactor/vutils';
+import type { Datum } from '../../typings';
+import type { Group } from '@visactor/vrender-core';
+import { IHoverSpec, ISelectSpec } from '../../interaction/interface';
+import { STATE_VALUE_ENUM } from '../../compile/mark';
+import { EventType } from '@visactor/vgrammar-core';
+import { IMark } from '../../mark/interface';
+import type { IPoint } from '../../typings/coordinate';
+export interface SVGParsedElementExtend extends SVGParsedElement {
+    _finalAttributes: Record<string, any>;
+    _uniqueId: string;
+}
+export declare class PictogramSeries<T extends IPictogramSeriesSpec = IPictogramSeriesSpec> extends GeoSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    static readonly transformerConstructor: typeof PictogramSeriesSpecTransformer;
+    svg: string;
+    protected _pictogramMark: GroupMark;
+    protected _parsedSvgResult: SVGParserResult;
+    private _labelMark;
+    setAttrFromSpec(): void;
+    getDatumCenter(datum: SVGParsedElementExtend): [number, number];
+    getDatumName(datum: SVGParsedElementExtend): string;
+    getMarksWithoutRoot(): IMark[];
+    protected _buildMarkAttributeContext(): void;
+    protected _defaultHoverConfig(selector: string[], finalHoverSpec: IHoverSpec): {
+        seriesId: number;
+        regionId: number;
+        selector: string[];
+        type: string;
+        trigger: EventType;
+        triggerOff: EventType;
+        blurState: STATE_VALUE_ENUM;
+        highlightState: STATE_VALUE_ENUM;
+    };
+    protected _defaultSelectConfig(selector: string[], finalSelectSpec: ISelectSpec): {
+        type: string;
+        seriesId: number;
+        regionId: number;
+        selector: string[];
+        trigger: EventType;
+        triggerOff: EventType;
+        reverseState: STATE_VALUE_ENUM;
+        state: STATE_VALUE_ENUM;
+        isMultiple: boolean;
+    };
+    initMark(): void;
+    private _initLabelMark;
+    initLabelMarkStyle(): void;
+    initMarkStyle(): void;
+    protected _validElement(element: SVGParsedElement): string;
+    protected initTooltip(): void;
+    dataToPosition(datum: Datum, global?: boolean): IPoint;
+    coordToPosition(point: IPoint): IPoint | undefined;
+    getRootMatrix(): IMatrix;
+    getPictogramRootGraphic(): Group;
+    initData(): void;
+    mapViewDataUpdate(): void;
+    onLayoutEnd(ctx: any): void;
+    updateSVGSize(): void;
+    protected initEvent(): void;
+    handleZoom(e: ZoomEventParam): void;
+    handlePan(e: PanEventParam): void;
+    getMarkData(datum: Datum): any;
+    getMeasureField(): string[];
+    getDimensionField(): string[];
+    protected _getSeriesInfo(field: string, keys: string[]): ISeriesSeriesInfo[];
+}
+export declare const registerPictogramSeries: () => void;

package/types/series/pictogram/svg-source.d.ts

@@ -0,0 +1,7 @@
+import { DataView } from '@visactor/vdataset';
+import type { ISVGSourceOption } from '@visactor/vdataset';
+export declare const svgSourceMap: Map<string, DataView>;
+export declare function registerSVGSource(key: string, source: ISVGSourceOption): void;
+export declare function unregisterSVGSource(key: string): void;
+export declare function getSVGSource(type: string): DataView;
+export declare function clearSVGSource(): void;