@visactor/vchart 1.2.0-beta.6 → 1.2.0-beta.7

package/build/es5/theme/index.d.ts

@@ -0,0 +1,3 @@
+export * from './buildin-theme';
+export * from './interface';
+export * from './theme-manager';

package/build/es5/theme/interface.d.ts

@@ -0,0 +1,44 @@
+import type { ILayoutPaddingSpec } from '../model/interface';
+import type { ISeriesTheme } from '../series/interface';
+import type { IMarkTheme } from '../typings/spec';
+import type { IArcMarkSpec, IAreaMarkSpec, ILineMarkSpec, IRectMarkSpec, ISymbolMarkSpec, ITextMarkSpec, IPathMarkSpec } from '../typings';
+import type { MarkTypeEnum } from '../mark/interface';
+import type { IThemeColorScheme } from './color-scheme/interface';
+import type { IGradientColor } from '@visactor/vrender';
+import type { IComponentTheme } from '../component/interface';
+export interface ITheme {
+    name?: string;
+    background?: string | IGradientColor;
+    padding?: ILayoutPaddingSpec;
+    fontFamily?: string;
+    colorScheme?: IThemeColorScheme;
+    mark?: IGlobalMarkThemeByType;
+    markByName?: IGlobalMarkThemeByName;
+    series?: ISeriesTheme;
+    animationThreshold?: number;
+    component?: IComponentTheme;
+}
+export interface IGlobalMarkThemeByType {
+    [MarkTypeEnum.line]?: Partial<IMarkTheme<ILineMarkSpec>>;
+    [MarkTypeEnum.symbol]?: Partial<IMarkTheme<ISymbolMarkSpec>>;
+    [MarkTypeEnum.area]?: Partial<IMarkTheme<IAreaMarkSpec>>;
+    [MarkTypeEnum.rect]?: Partial<IMarkTheme<IRectMarkSpec>>;
+    [MarkTypeEnum.arc]?: Partial<IMarkTheme<IArcMarkSpec>>;
+    [MarkTypeEnum.text]?: Partial<IMarkTheme<ITextMarkSpec>>;
+    [MarkTypeEnum.path]?: Partial<IMarkTheme<IPathMarkSpec>>;
+}
+export interface IGlobalMarkThemeByName {
+    line?: Partial<IMarkTheme<ILineMarkSpec>>;
+    point?: Partial<IMarkTheme<ISymbolMarkSpec>>;
+    area?: Partial<IMarkTheme<IAreaMarkSpec>>;
+    bar?: Partial<IMarkTheme<IRectMarkSpec>>;
+    label?: Partial<IMarkTheme<ITextMarkSpec>>;
+    [markName: string]: Partial<IMarkTheme<any>>;
+}
+export interface IThemeConstants {
+    FONT_FAMILY: string;
+    LABEL_FONT_SIZE: number;
+    MAP_LABEL_FONT_SIZE: number;
+    TITLE_FONT_SIZE: number;
+    AXIS_TICK_SIZE: number;
+}

package/build/es5/theme/theme-manager.d.ts

@@ -0,0 +1,13 @@
+import type { ITheme } from './interface';
+export declare class ThemeManager {
+    static themes: Map<string, ITheme>;
+    private static _currentThemeName;
+    static registerTheme(name: string, theme: Partial<ITheme>): void;
+    static getTheme(name: string): ITheme;
+    static removeTheme(name: string): boolean;
+    static themeExist(name: string): boolean;
+    static getDefaultTheme(): ITheme;
+    static setCurrentTheme(name: string): void;
+    static getCurrentTheme(): ITheme;
+    static getCurrentThemeName(): string;
+}

package/build/es5/typings/common.d.ts

@@ -0,0 +1,7 @@
+export type Datum = {
+    [key: string]: any;
+};
+export type StringOrNumber = string | number;
+export type MaybeArray<T> = T | Array<T>;
+export type Maybe<T> = T | undefined | null;
+export type Quadrant = 1 | 2 | 3 | 4;

package/build/es5/typings/coordinate.d.ts

@@ -0,0 +1,9 @@
+export type CoordinateType = 'cartesian' | 'polar' | 'geo' | 'none';
+export interface IPoint {
+    x: number;
+    y: number;
+}
+export interface IPolarPoint {
+    radius: number;
+    angle: number;
+}

package/build/es5/typings/cursor.d.ts

@@ -0,0 +1 @@
+export type Cursor = 'auto' | 'default' | 'none' | 'context-menu' | 'help' | 'pointer' | 'progress' | 'wait' | 'cell' | 'crosshair' | 'text' | 'vertical-text' | 'alias' | 'copy' | 'move' | 'no-drop' | 'not-allowed' | 'e-resize' | 'n-resize' | 'ne-resize' | 'nw-resize' | 's-resize' | 'se-resize' | 'sw-resize' | 'w-resize' | 'ew-resize' | 'ns-resize' | 'nesw-resize' | 'nwse-resize' | 'col-resize' | 'row-resize' | 'all-scroll' | 'zoom-in' | 'zoom-out' | 'grab' | 'grabbing';

package/build/es5/typings/data.d.ts

@@ -0,0 +1 @@
+export type IInvalidType = 'zero' | 'ignore' | 'link' | 'break';

package/build/es5/typings/geo.d.ts

@@ -0,0 +1,3 @@
+export type GeoJSON = any;
+export type TopoJSON = any;
+export type GeoSourceType = GeoJSON | TopoJSON;

package/build/es5/typings/index.d.ts

@@ -0,0 +1,13 @@
+export * from './cursor';
+export * from './data';
+export * from './interpolate';
+export * from './shape';
+export * from './scale';
+export * from './line-stroke';
+export * from './space';
+export * from './coordinate';
+export * from './tooltip';
+export * from './params';
+export * from './visual';
+export * from './common';
+export * from './spec';

package/build/es5/typings/interpolate.d.ts

@@ -0,0 +1,5 @@
+export type InterpolateType = 'basis' | 'bundle' | 'cardinal' | 'catmullRom' | 'linear' | 'monotone' | 'monotoneX' | 'monotoneY' | 'natural' | 'step' | 'stepAfter' | 'stepBefore' | 'linearClosed' | 'cardinalClosed';
+export declare const DEFAULT_SMOOTH_INTERPOLATE = "monotone";
+export declare const DEFAULT_LINEAR_INTERPOLATE = "linear";
+export declare const DEFAULT_LINEAR_CLOSED_INTERPOLATE = "linearClosed";
+export declare const DEFAULT_CIRCLE_CLOSED_INTERPOLATE = "cardinalClosed";

package/build/es5/typings/line-stroke.d.ts

@@ -0,0 +1,3 @@
+export type ILineStrokeCap = 'butt' | 'round' | 'square';
+export type ILineStrokeJoin = 'arcs' | 'bevel' | 'miter' | 'miter-clip' | 'round';
+export declare const DEFAULT_CLOSE_STROKE_JOIN = "bevel";

package/build/es5/typings/params.d.ts

@@ -0,0 +1,17 @@
+import type { IChart } from '../chart/interface';
+import type { StringOrNumber } from './common';
+import type { TooltipActiveType } from './tooltip';
+export interface IRegionQuerier {
+    regionId?: StringOrNumber;
+    regionIndex?: number;
+}
+export interface IShowTooltipOption extends IRegionQuerier {
+    x?: number;
+    y?: number;
+    alwaysShow?: boolean;
+    activeType?: TooltipActiveType;
+}
+export interface utilFunctionCtx {
+    chart?: IChart;
+    onError?: (...args: any[]) => void;
+}

package/build/es5/typings/scale.d.ts

@@ -0,0 +1,33 @@
+export type DomainType = any;
+export type RangeType = any;
+export type QuantScaleType = 'linear';
+export type DiscreteScaleType = 'ordinal' | 'band' | 'point' | 'threshold';
+export type ScaleType = QuantScaleType | DiscreteScaleType;
+export interface IBaseScaleSpec {
+    name: string;
+    type?: ScaleType;
+    domain?: DomainType[];
+    unknown?: any;
+}
+export interface IContinuousScaleSpec extends IBaseScaleSpec {
+    range?: RangeType[];
+    clamp?: boolean;
+    padding?: number;
+}
+export interface IBaseBandScaleSpec extends IBaseScaleSpec {
+    range?: RangeType[];
+    padding?: number;
+    paddingOuter?: number;
+    align?: number;
+    round?: boolean;
+}
+export type INumericScaleSpec = IContinuousScaleSpec;
+export interface ILinearScaleSpec extends INumericScaleSpec {
+    type: 'linear';
+}
+export interface IPointScaleSpec extends IBaseBandScaleSpec {
+    type: 'point';
+}
+export interface IOrdinalScaleSpec extends IBaseScaleSpec {
+    type: 'ordinal';
+}

package/build/es5/typings/shape.d.ts

@@ -0,0 +1,27 @@
+import type { SymbolType } from '@visactor/vrender';
+export declare enum ShapeTypeEnum {
+    circle = "circle",
+    triangle = "triangle",
+    triangleUp = "triangleUp",
+    triangleLeft = "triangleLeft",
+    triangleRight = "triangleRight",
+    triangleDown = "triangleDown",
+    thinTriangle = "thinTriangle",
+    rect = "rect",
+    diamond = "diamond",
+    square = "square",
+    arrowLeft = "arrowLeft",
+    arrow2Left = "arrow2Left",
+    arrowRight = "arrowRight",
+    arrow2Right = "arrow2Right",
+    cross = "cross",
+    wedge = "wedge",
+    star = "star",
+    wye = "wye"
+}
+export type ShapeType = SymbolType;
+export declare const ShapeTypes: string[];
+export interface IShapeStyle {
+    shape?: ShapeType;
+    size?: number;
+}

package/build/es5/typings/space.d.ts

@@ -0,0 +1,19 @@
+export interface IRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export type IOrientType = 'left' | 'top' | 'right' | 'bottom' | 'z';
+export type IPolarOrientType = 'radius' | 'angle';
+export interface IPadding {
+    top?: number;
+    bottom?: number;
+    left?: number;
+    right?: number;
+}
+export declare enum Direction {
+    vertical = "vertical",
+    horizontal = "horizontal"
+}
+export type DirectionType = keyof typeof Direction;

package/build/es5/typings/spec/chart.d.ts

@@ -0,0 +1,59 @@
+import type { IAreaChartSpec } from '../../chart/area';
+import type { IBarChartSpec, IBar3dChartSpec } from '../../chart/bar';
+import type { IBoxPlotChartSpec } from '../../chart/box-plot';
+import type { ICirclePackingChartSpec } from '../../chart/circle-packing';
+import type { ICommonChartSpec } from '../../chart/common';
+import type { IFunnelChartSpec, IFunnel3dChartSpec } from '../../chart/funnel';
+import type { IGaugeChartSpec } from '../../chart/gauge';
+import type { IHeatmapChartSpec } from '../../chart/heatmap';
+import type { IHistogramChartSpec, IHistogram3dChartSpec } from '../../chart/histogram';
+import type { ILineChartSpec } from '../../chart/line';
+import type { IMapChartSpec } from '../../chart/map';
+import type { IPieChartSpec, IPie3dChartSpec } from '../../chart/pie';
+import type { ICircularProgressChartSpec } from '../../chart/progress/circular';
+import type { ILinearProgressChartSpec } from '../../chart/progress/linear';
+import type { IRadarChartSpec } from '../../chart/radar';
+import type { IRangeAreaChartSpec } from '../../chart/range-area';
+import type { IRangeColumnChartSpec, IRangeColumn3dChartSpec } from '../../chart/range-column';
+import type { IRoseChartSpec } from '../../chart/rose';
+import type { ISankeyChartSpec } from '../../chart/sankey';
+import type { IScatterChartSpec } from '../../chart/scatter';
+import type { ISequenceChartSpec } from '../../chart/sequence';
+import type { ISunburstChartSpec } from '../../chart/sunburst';
+import type { ITreemapChartSpec } from '../../chart/treemap';
+import type { IWaterfallChartSpec } from '../../chart/waterfall';
+import type { IWordCloudChartSpec, IWordCloud3dChartSpec } from '../../chart/word-cloud';
+export interface ChartSpecMap {
+    readonly common: ICommonChartSpec;
+    readonly area: IAreaChartSpec;
+    readonly line: ILineChartSpec;
+    readonly bar: IBarChartSpec;
+    readonly bar3d: IBar3dChartSpec;
+    readonly histogram: IHistogramChartSpec;
+    readonly histogram3d: IHistogram3dChartSpec;
+    readonly rangeColumn: IRangeColumnChartSpec;
+    readonly rangeColumn3d: IRangeColumn3dChartSpec;
+    readonly rangeArea: IRangeAreaChartSpec;
+    readonly map: IMapChartSpec;
+    readonly pie: IPieChartSpec;
+    readonly pie3d: IPie3dChartSpec;
+    readonly radar: IRadarChartSpec;
+    readonly rose: IRoseChartSpec;
+    readonly scatter: IScatterChartSpec;
+    readonly sequence: ISequenceChartSpec;
+    readonly circleProgress: ICircularProgressChartSpec;
+    readonly linearProgress: ILinearProgressChartSpec;
+    readonly wordCloud: IWordCloudChartSpec;
+    readonly wordCloud3d: IWordCloud3dChartSpec;
+    readonly funnel: IFunnelChartSpec;
+    readonly funnel3d: IFunnel3dChartSpec;
+    readonly waterfall: IWaterfallChartSpec;
+    readonly boxplot: IBoxPlotChartSpec;
+    readonly gauge: IGaugeChartSpec;
+    readonly sankey: ISankeyChartSpec;
+    readonly treemap: ITreemapChartSpec;
+    readonly sunburst: ISunburstChartSpec;
+    readonly circlePacking: ICirclePackingChartSpec;
+    readonly heatmap: IHeatmapChartSpec;
+}
+export type ISpec = ChartSpecMap[keyof ChartSpecMap];

package/build/es5/typings/spec/common.d.ts

@@ -0,0 +1,250 @@
+import type { IFillMarkSpec, IImageMarkSpec } from './../visual';
+import type { ILayoutPaddingSpec } from '../../model/interface';
+import type { LayoutCallBack } from '../../layout/interface';
+import type { IElement, srIOption3DType } from '@visactor/vgrammar';
+import type { DataSet, DataView, ISimplifyOptions, IFieldsOptions, IFilterOptions, IFoldOptions, IDsvParserOptions } from '@visactor/vdataset';
+import type { IRegionSpec } from '../../region/interface';
+import type { IDiscreteLegendSpec } from '../../component/legend/discrete/interface';
+import type { IHoverSpec, ISelectSpec, ITriggerSpec } from '../../interaction/interface';
+import type { IRenderOption } from '../../compile/interface';
+import type { ITooltipSpec } from '../../component/tooltip/interface';
+import type { ILayoutSpec } from '../../layout/interface';
+import type { ConvertToMarkStyleSpec, IArc3dMarkSpec, IArcMarkSpec, IAreaMarkSpec, IBoxPlotMarkSpec, ICommonSpec, IGroupMarkSpec, ILineMarkSpec, ILinkPathMarkSpec, IPathMarkSpec, IPolygonMarkSpec, IProgressArcMarkSpec, IPyramid3dMarkSpec, IRect3dMarkSpec, IRectMarkSpec, IRuleMarkSpec, ISymbolMarkSpec, ITextMarkSpec, IVisualSpecScale } from '../visual';
+import type { StateValue } from '../../compile/mark';
+import type { ISeriesStyle, SeriesType } from '../../series/interface';
+import type { ILayoutOrientPadding } from '../../model/interface';
+import type { Datum, StringOrNumber } from '../common';
+import type { IInvalidType } from '../data';
+import type { IMorphSeriesSpec } from '../../animation/spec';
+import type { IPlayer } from '../../component/player';
+import type { IMarkProgressiveConfig, MarkTypeEnum } from '../../mark/interface';
+import type { IDataZoomSpec, IScrollBarSpec } from '../../component/data-zoom';
+import type { ICrosshairSpec } from '../../component/crosshair/interface';
+import type { ITheme } from '../../theme';
+import type { ITitleSpec } from '../../component/title/interface';
+import type { IBrushSpec } from '../../component/brush';
+export type IChartPadding = ILayoutOrientPadding | number;
+export interface IInitOption extends Omit<IRenderOption, 'pluginList'> {
+    dom?: string | HTMLElement;
+    renderCanvas?: string | HTMLCanvasElement;
+    dataSet?: DataSet;
+    autoFit?: boolean;
+    performanceHook?: IPerformanceHook;
+    animation?: boolean;
+    options3d?: srIOption3DType;
+    layout?: LayoutCallBack;
+    poptip?: boolean;
+    onError?: (...args: any[]) => void;
+}
+export declare enum RenderModeEnum {
+    'desktop-browser' = "desktop-browser",
+    'mobile-browser' = "mobile-browser",
+    'node' = "node",
+    'worker' = "worker",
+    'miniApp' = "miniApp",
+    'desktop-miniApp' = "desktop-miniApp",
+    'lynx' = "lynx"
+}
+export type RenderMode = keyof typeof RenderModeEnum;
+export interface IChartSpec {
+    type: string;
+    data?: IData;
+    width?: number;
+    height?: number;
+    autoFit?: boolean;
+    padding?: ILayoutPaddingSpec;
+    color?: string[] | Omit<IVisualSpecScale<unknown, string>, 'id'>;
+    series?: ISeriesSpec[];
+    seriesStyle?: ISeriesStyle;
+    animationThreshold?: number;
+    hover?: boolean | IHoverSpec;
+    select?: boolean | ISelectSpec;
+    region?: IRegionSpec[];
+    title?: ITitleSpec;
+    layout?: ILayoutSpec;
+    legends?: IDiscreteLegendSpec | IDiscreteLegendSpec[];
+    crosshair?: ICrosshairSpec | ICrosshairSpec[];
+    tooltip?: ITooltipSpec;
+    player?: IPlayer;
+    dataZoom?: IDataZoomSpec[];
+    scrollBar?: IScrollBarSpec[];
+    brush?: IBrushSpec;
+    scales?: IVisualSpecScale<unknown, unknown>[];
+    customMark?: ICustomMarkSpec<EnableMarkType>[];
+    theme?: Omit<ITheme, 'name'> | string;
+    background?: IBackgroundSpec;
+}
+export type IBackgroundStyleSpec = ConvertToMarkStyleSpec<Omit<IFillMarkSpec, 'width' | 'height' | 'background'>> & {
+    image?: IRectMarkSpec['background'];
+    cornerRadius?: IRectMarkSpec['cornerRadius'];
+};
+export type IBackgroundSpec = string | IBackgroundStyleSpec;
+export type IDataType = IDataValues | DataView;
+export type IData = IDataType | IDataType[];
+export type DataKeyType = string | string[] | ((data: Datum, index: number) => string);
+export type BuildInTransformOptions = {
+    type: 'simplify';
+    options: ISimplifyOptions;
+} | {
+    type: 'fields';
+    options: IFieldsOptions;
+} | {
+    type: 'filter';
+    options: IFilterOptions;
+} | {
+    type: 'fold';
+    options: IFoldOptions;
+};
+export interface IFieldsMeta {
+    alias?: string;
+    domain?: StringOrNumber[];
+    lockStatisticsByDomain?: boolean;
+    type?: 'ordinal' | 'linear';
+    sortIndex?: number;
+    sortReverse?: boolean;
+}
+export interface IDataValues {
+    id?: StringOrNumber;
+    values: Datum[] | string;
+    fromDataIndex?: number;
+    fromDataId?: StringOrNumber;
+    transforms?: BuildInTransformOptions[];
+    fields?: Record<string, IFieldsMeta>;
+    parser?: {
+        type: 'csv' | 'dsv' | 'tsv';
+        options?: IDsvParserOptions;
+    };
+}
+export type IHierarchyNodeData = {
+    value?: number;
+    children?: IHierarchyNodeData[];
+} & Datum;
+export interface IHierarchyDataValues extends Omit<IDataValues, 'values'> {
+    values: IHierarchyNodeData;
+}
+export type IHierarchyData = DataView | IHierarchyDataValues;
+export interface ISeriesSpec extends ITriggerSpec {
+    type: SeriesType;
+    name?: string;
+    id?: StringOrNumber;
+    data?: IDataType;
+    dataIndex?: number;
+    dataId?: StringOrNumber;
+    dataKey?: DataKeyType;
+    regionIndex?: number;
+    regionId?: StringOrNumber;
+    seriesField?: string;
+    seriesStyle?: ISeriesStyle;
+    stack?: boolean;
+    percent?: boolean;
+    stackOffsetSilhouette?: boolean;
+    invalidType?: IInvalidType;
+    tooltip?: ITooltipSpec;
+    animation?: boolean;
+    animationThreshold?: number;
+    support3d?: boolean;
+    morph?: IMorphSeriesSpec;
+    extensionMark?: (IExtensionMarkSpec<Exclude<EnableMarkType, MarkTypeEnum.group>> | IExtensionGroupMarkSpec)[];
+}
+export type IChartExtendsSeriesSpec<T extends ISeriesSpec> = Omit<T, 'data' | 'morph'>;
+export type IMarkSpec<T extends ICommonSpec = ICommonSpec> = {
+    id?: StringOrNumber;
+    interactive?: boolean;
+    zIndex?: number;
+    visible?: boolean;
+    style?: ConvertToMarkStyleSpec<T>;
+    state?: Record<StateValue, IMarkStateSpec<T> | IMarkStateStyleSpec<T>>;
+    support3d?: boolean;
+} & IMarkProgressiveConfig;
+export type IMarkStateFilter = {
+    fields: {
+        [key in string]: {
+            type: 'ordinal' | 'linear';
+            domain: StringOrNumber[];
+        };
+    };
+} | {
+    datums: Datum[];
+    datumKeys: string[];
+} | {
+    items: IElement[];
+} | ((datum: Datum, options: Record<string, any>) => boolean);
+export interface IMarkStateSpec<T> {
+    filter?: IMarkStateFilter;
+    level?: number | undefined;
+    style: ConvertToMarkStyleSpec<T>;
+}
+export type IMarkStateStyleSpec<T> = ConvertToMarkStyleSpec<T>;
+export type IMarkTheme<T> = {
+    visible?: boolean;
+    style?: T;
+    state?: Record<StateValue, T>;
+    interactive?: boolean;
+};
+export interface IPerformanceHook {
+    beforeInitializeChart?: () => void;
+    afterInitializeChart?: () => void;
+    beforeCompileToVGrammar?: () => void;
+    afterCompileToVGrammar?: () => void;
+    beforeRegionCompile?: () => void;
+    afterRegionCompile?: () => void;
+    beforeSeriesCompile?: () => void;
+    afterSeriesCompile?: () => void;
+    beforeComponentCompile?: () => void;
+    afterComponentCompile?: () => void;
+    beforeResizeWithUpdate?: () => void;
+    afterResizeWithUpdate?: () => void;
+    beforeLayoutWithSceneGraph?: () => void;
+    afterLayoutWithSceneGraph?: () => void;
+    beforeParseView?: () => void;
+    afterParseView?: () => void;
+    beforeCreateRuntime?: () => void;
+    afterCreateRuntime?: () => void;
+    beforeSrViewEvaluateAsync?: () => void;
+    afterSrViewEvaluateAsync?: () => void;
+    beforeSrViewRunAsync?: () => void;
+    afterSrViewRunAsync?: () => void;
+    beforeTransform?: (name: string) => void;
+    afterTransform?: (name: string) => void;
+    beforeCreateVRenderStage?: () => void;
+    afterCreateVRenderStage?: () => void;
+    beforeCreateVRenderMark?: () => void;
+    afterCreateVRenderMark?: () => void;
+    beforeVRenderDraw?: () => void;
+    afterVRenderDraw?: () => void;
+}
+export type IBuildinMarkSpec = {
+    [MarkTypeEnum.group]: IGroupMarkSpec;
+    [MarkTypeEnum.symbol]: ISymbolMarkSpec;
+    [MarkTypeEnum.rule]: IRuleMarkSpec;
+    [MarkTypeEnum.line]: ILineMarkSpec;
+    [MarkTypeEnum.text]: ITextMarkSpec;
+    [MarkTypeEnum.rect]: IRectMarkSpec;
+    [MarkTypeEnum.rect3d]: IRect3dMarkSpec;
+    [MarkTypeEnum.image]: IImageMarkSpec;
+    [MarkTypeEnum.path]: IPathMarkSpec;
+    [MarkTypeEnum.area]: IAreaMarkSpec;
+    [MarkTypeEnum.arc]: IArcMarkSpec;
+    [MarkTypeEnum.arc3d]: IArc3dMarkSpec;
+    [MarkTypeEnum.polygon]: IPolygonMarkSpec;
+    [MarkTypeEnum.pyramid3d]: IPyramid3dMarkSpec;
+    [MarkTypeEnum.boxPlot]: IBoxPlotMarkSpec;
+    [MarkTypeEnum.linkPath]: ILinkPathMarkSpec;
+    [MarkTypeEnum.progressArc]: IProgressArcMarkSpec;
+};
+export type EnableMarkType = keyof IBuildinMarkSpec;
+export interface ICustomMarkSpec<T extends EnableMarkType> extends IMarkSpec<IBuildinMarkSpec[T]> {
+    type: T;
+    dataIndex?: number;
+    dataId?: StringOrNumber;
+}
+export interface ICustomMarkGroupSpec extends ICustomMarkSpec<MarkTypeEnum.group> {
+    children?: ICustomMarkSpec<EnableMarkType>[];
+}
+export interface IExtensionMarkSpec<T extends Exclude<EnableMarkType, MarkTypeEnum.group>> extends ICustomMarkSpec<T> {
+    dataIndex?: number;
+    dataId?: StringOrNumber;
+}
+export interface IExtensionGroupMarkSpec extends ICustomMarkSpec<MarkTypeEnum.group> {
+    children?: ICustomMarkSpec<EnableMarkType>[];
+}

package/build/es5/typings/spec/index.d.ts

@@ -0,0 +1,4 @@
+export * from './common';
+export type { IStateSpec, StateValueType } from '../../compile/mark';
+export * from './chart';
+export type { IRegionSpec, IGeoRegionSpec } from '../../region/interface';

package/build/es5/typings/tooltip/common.d.ts

@@ -0,0 +1,8 @@
+import type { Datum } from '../common';
+import type { TooltipHandlerParams } from '../../component/tooltip/interface';
+import type { TooltipData } from './handler';
+export type TooltipContentProperty<T> = T | TooltipContentCallback<T>;
+export type TooltipContentCallback<T> = (datum?: Datum, params?: TooltipHandlerParams) => T | undefined;
+export type TooltipPatternProperty<T> = T | TooltipPatternCallback<T>;
+export type TooltipPatternCallback<T> = (data?: TooltipData, params?: TooltipHandlerParams) => T | undefined;
+export type TooltipUpdateCallback<T> = (prev: T | undefined, data?: TooltipData, params?: TooltipHandlerParams) => T | undefined;

package/build/es5/typings/tooltip/handler.d.ts

@@ -0,0 +1,8 @@
+import type { ITooltipHandlerSpec } from '../../component/tooltip/interface';
+import type { IDimensionData, IDimensionInfo } from '../../event/events/dimension/interface';
+export interface ITooltipHandler extends ITooltipHandlerSpec {
+    getTooltipContainer?: () => any;
+    reInit?: () => any;
+}
+export type TooltipData = IDimensionInfo[] | IDimensionData[];
+export type TooltipActiveType = 'mark' | 'dimension';

package/build/es5/typings/tooltip/index.d.ts

@@ -0,0 +1,6 @@
+export * from './common';
+export * from './handler';
+export * from './line';
+export * from './position';
+export * from './shape';
+export * from './tooltip';

package/build/es5/typings/tooltip/line.d.ts

@@ -0,0 +1,15 @@
+import type { TooltipContentProperty } from './common';
+import type { ITooltipShapeActual, ITooltipShapePattern } from './shape';
+export interface IToolTipLinePattern extends ITooltipShapePattern {
+    seriesId?: number;
+    key?: TooltipContentProperty<string>;
+    value?: TooltipContentProperty<string>;
+    visible?: TooltipContentProperty<boolean>;
+    isKeyAdaptive?: TooltipContentProperty<boolean>;
+}
+export interface IToolTipLineActual extends ITooltipShapeActual {
+    key?: string;
+    value?: string;
+    visible?: boolean;
+    isKeyAdaptive?: boolean;
+}

package/build/es5/typings/tooltip/position.d.ts

@@ -0,0 +1,19 @@
+export type ITooltipPositionCallback = (event: MouseEvent) => number;
+export interface ITooltipPositionPattern {
+    left?: number | ITooltipPositionCallback;
+    right?: number | ITooltipPositionCallback;
+    top?: number | ITooltipPositionCallback;
+    bottom?: number | ITooltipPositionCallback;
+}
+export declare enum TooltipFixedPosition {
+    top = "top",
+    left = "left",
+    right = "right",
+    bottom = "bottom",
+    inside = "inside"
+}
+export type TooltipPosition = ITooltipPositionPattern | TooltipFixedPosition;
+export interface ITooltipPositionActual {
+    x: number;
+    y: number;
+}

package/build/es5/typings/tooltip/shape.d.ts

@@ -0,0 +1,14 @@
+import type { ShapeType } from '../shape';
+import type { TooltipContentProperty } from './common';
+export interface ITooltipShapePattern {
+    hasShape?: boolean;
+    shapeType?: TooltipContentProperty<ShapeType>;
+    shapeColor?: TooltipContentProperty<string>;
+    shapeHollow?: boolean;
+}
+export interface ITooltipShapeActual {
+    hasShape?: boolean;
+    shapeType?: ShapeType;
+    shapeColor?: string;
+    shapeHollow?: boolean;
+}

package/build/es5/typings/tooltip/tooltip.d.ts

@@ -0,0 +1,24 @@
+import type { MaybeArray } from '../common';
+import type { TooltipPatternProperty, TooltipUpdateCallback } from './common';
+import type { TooltipActiveType } from './handler';
+import type { IToolTipLineActual, IToolTipLinePattern } from './line';
+import type { ITooltipPositionActual, TooltipPosition } from './position';
+import type { ITooltipShapePattern } from './shape';
+export interface ITooltipPattern extends ITooltipShapePattern {
+    visible?: TooltipPatternProperty<boolean>;
+    title?: TooltipPatternProperty<IToolTipLinePattern>;
+    content?: MaybeArray<TooltipPatternProperty<MaybeArray<IToolTipLinePattern>>>;
+    position?: TooltipPatternProperty<TooltipPosition>;
+    updateTitle?: TooltipUpdateCallback<IToolTipLineActual>;
+    updateContent?: TooltipUpdateCallback<IToolTipLineActual[]>;
+    updatePosition?: TooltipUpdateCallback<ITooltipPositionActual>;
+    maxLineCount?: number;
+    activeType?: TooltipActiveType;
+}
+export interface IToolTipActual {
+    visible?: boolean;
+    title?: IToolTipLineActual;
+    content?: IToolTipLineActual[];
+    activeType?: TooltipActiveType;
+    position?: ITooltipPositionActual;
+}