@visactor/vchart-types 0.10.0-alpha.2

package/types/theme/interface.d.ts

@@ -0,0 +1,56 @@
+import type { ISeriesTheme } from '../series/interface';
+import type { IMarkTheme } from '../typings/spec';
+import type { IArcMarkSpec, IAreaMarkSpec, ILineMarkSpec, IRectMarkSpec, ISymbolMarkSpec, ITextMarkSpec, IPathMarkSpec, ILayoutPaddingSpec } from '../typings';
+import type { MarkTypeEnum } from '../mark/interface';
+import type { IColorKey, IThemeColorScheme } from './color-scheme/interface';
+import type { IGradientColor } from '@visactor/vrender-core';
+import type { IComponentTheme } from '../component/interface';
+export interface ITheme {
+    name?: string;
+    description?: string;
+    type?: 'light' | 'dark';
+    background?: string | IGradientColor | IColorKey;
+    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 {
+    defaultFontFamily: string;
+    defaultFontSize: number;
+    l1FontSize: number;
+    l1LineHeight: number | string;
+    l2FontSize: number;
+    l2LineHeight: number | string;
+    l3FontSize: number;
+    l3LineHeight: number | string;
+    l4FontSize: number;
+    l4LineHeight: number | string;
+    l5FontSize: number;
+    l5LineHeight: number | string;
+    l6FontSize: number;
+    l6LineHeight: number | string;
+    axisTickSize: number;
+    areaOpacity: number;
+}

package/types/theme/theme-manager.d.ts

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

package/types/theme/util.d.ts

@@ -0,0 +1,5 @@
+import type { ITheme } from './interface';
+import type { IThemeColorScheme } from './color-scheme/interface';
+import type { IModelOption } from '../model/interface';
+export declare const mergeThemeAndGet: (path: string, currentThemeName?: string, optionTheme?: string | ITheme, specTheme?: string | ITheme, colorScheme?: IThemeColorScheme) => any;
+export declare const getThemeFromOption: (path: string, option: Partial<IModelOption>) => any;

package/types/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/types/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/types/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/types/typings/data.d.ts

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

package/types/typings/event.d.ts

@@ -0,0 +1 @@
+export type IDelayType = 'debounce' | 'throttle';

package/types/typings/geo.d.ts

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

package/types/typings/group.d.ts

@@ -0,0 +1,8 @@
+import type { DataSet, DataView } from '@visactor/vdataset';
+export interface IGroup {
+    fields?: string[];
+    groupData?: DataView;
+    initData?: (viewData: DataView, dataSet: DataSet) => void;
+    groupDataUpdate?: () => void;
+    getGroupValueInField?: (field: string) => any[];
+}

package/types/typings/index.d.ts

@@ -0,0 +1,15 @@
+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';
+export * from './group';
+export * from './layout';

package/types/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/types/typings/layout.d.ts

@@ -0,0 +1,24 @@
+export type ILayoutNumber = number | IPercent | ((layoutRect: ILayoutRect) => number) | IPercentOffset;
+export interface ILayoutPoint {
+    x: number;
+    y: number;
+}
+export interface ILayoutRect {
+    width: number;
+    height: number;
+}
+export type IPercent = `${number}%`;
+export type IPercentOffset = {
+    percent?: number;
+    offset?: number;
+};
+export type ILayoutPercent = IPercent | number;
+export type ILayoutType = 'region-relative' | 'region-relative-overlap' | 'region' | 'normal' | 'absolute' | 'normal-inline';
+export type ILayoutOrientPadding = {
+    left?: ILayoutNumber;
+    right?: ILayoutNumber;
+    top?: ILayoutNumber;
+    bottom?: ILayoutNumber;
+};
+export type ILayoutPaddingSpec = ILayoutOrientPadding | ILayoutNumber | ILayoutNumber[];
+export type ILayoutAlignSelf = 'start' | 'end' | 'middle';

package/types/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/types/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/types/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/types/typings/shape.d.ts

@@ -0,0 +1,6 @@
+import type { SymbolType } from '@visactor/vrender-core';
+export type ShapeType = SymbolType;
+export interface IShapeStyle {
+    shape?: ShapeType;
+    size?: number;
+}

package/types/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 const enum Direction {
+    vertical = "vertical",
+    horizontal = "horizontal"
+}
+export type DirectionType = keyof typeof Direction;

package/types/typings/spec/chart.d.ts

@@ -0,0 +1,62 @@
+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 { ICorrelationChartSpec } from '../../chart/correlation';
+import type { IWordCloudChartSpec, IWordCloud3dChartSpec } from '../../chart/word-cloud';
+import type { IChartSpec } from './common';
+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;
+    readonly correlation: ICorrelationChartSpec;
+}
+export type ISpec = ChartSpecMap[keyof ChartSpecMap] | IChartSpec;

package/types/typings/spec/common.d.ts

@@ -0,0 +1,275 @@
+import type { IFillMarkSpec, IImageMarkSpec } from '../visual';
+import type { LayoutCallBack } from '../../layout/interface';
+import type { IElement, srIOption3DType } from '@visactor/vgrammar-core';
+import type { DataSet, DataView, ISimplifyOptions, IFieldsOptions, IFilterOptions, IFoldOptions, IDsvParserOptions } from '@visactor/vdataset';
+import type { IRegionSpec } from '../../region/interface';
+import type { IHoverSpec, ISelectSpec, IInteractionSpec } 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, IRippleMarkSpec, ITextMarkSpec, IVisualSpecScale } from '../visual';
+import type { StateValue } from '../../compile/mark';
+import type { ISeriesStyle, SeriesType } from '../../series/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';
+import type { ITotalLabelSpec } from '../../component/label';
+import type { ILegendSpec } from '../../component/legend';
+import type { ILayoutOrientPadding, ILayoutPaddingSpec } from '../layout';
+import type { ICustomPath2D } from '@visactor/vrender-core';
+import type { ICommonAxisSpec } from '../../component/axis';
+import type { IMediaQuerySpec } from '..';
+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;
+    theme?: string | ITheme;
+    disableTriggerEvent?: boolean;
+}
+export declare enum RenderModeEnum {
+    'desktop-browser' = "desktop-browser",
+    'mobile-browser' = "mobile-browser",
+    'node' = "node",
+    'worker' = "worker",
+    'miniApp' = "miniApp",
+    'wx' = "wx",
+    '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?: ILegendSpec | ILegendSpec[];
+    crosshair?: ICrosshairSpec | ICrosshairSpec[];
+    tooltip?: ITooltipSpec;
+    player?: IPlayer;
+    dataZoom?: IDataZoomSpec | IDataZoomSpec[];
+    scrollBar?: IScrollBarSpec | IScrollBarSpec[];
+    brush?: IBrushSpec;
+    scales?: IVisualSpecScale<unknown, unknown>[];
+    customMark?: ICustomMarkSpec<EnableMarkType>[];
+    axes?: ICommonAxisSpec[];
+    theme?: Omit<ITheme, 'name'> | string;
+    background?: IBackgroundSpec;
+    stackInverse?: boolean;
+    media?: IMediaQuerySpec;
+}
+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 SheetParseOptions extends CommonParseOptions {
+    type: 'csv' | 'dsv' | 'tsv';
+    options?: IDsvParserOptions;
+}
+export interface CommonParseOptions {
+    clone?: boolean;
+}
+export interface IDataValues {
+    id?: StringOrNumber;
+    values: Datum[] | string;
+    fromDataIndex?: number;
+    fromDataId?: StringOrNumber;
+    transforms?: BuildInTransformOptions[];
+    fields?: Record<string, IFieldsMeta>;
+    parser?: SheetParseOptions | CommonParseOptions;
+}
+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 IInteractionSpec {
+    type: SeriesType;
+    name?: string;
+    id?: StringOrNumber;
+    data?: IDataType;
+    dataIndex?: number;
+    dataId?: StringOrNumber;
+    dataKey?: DataKeyType;
+    regionIndex?: number;
+    regionId?: StringOrNumber;
+    seriesField?: string;
+    seriesStyle?: ISeriesStyle;
+    stack?: boolean;
+    stackValue?: StringOrNumber;
+    totalLabel?: ITotalLabelSpec;
+    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' | 'stackValue'>;
+export type AdaptiveSpec<T, K extends keyof any> = {
+    [key in Exclude<keyof T, K>]: T[key];
+} & {
+    [key in K]: any;
+};
+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>>;
+    stateSort?: (stateA: string, stateB: string) => number;
+    support3d?: boolean;
+    customShape?: (datum: any[], attrs: any, path: ICustomPath2D) => ICustomPath2D;
+} & 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;
+    [MarkTypeEnum.ripple]: IRippleMarkSpec;
+};
+export type EnableMarkType = keyof IBuildinMarkSpec;
+export interface ICustomMarkSpec<T extends EnableMarkType> extends IMarkSpec<IBuildinMarkSpec[T]> {
+    type: T;
+    dataIndex?: number;
+    dataId?: StringOrNumber;
+    componentType?: string;
+}
+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;
+    componentType?: string;
+}
+export interface IExtensionGroupMarkSpec extends ICustomMarkSpec<MarkTypeEnum.group> {
+    children?: ICustomMarkSpec<EnableMarkType>[];
+}

package/types/typings/spec/index.d.ts

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

package/types/typings/spec/media-query.d.ts

@@ -0,0 +1,28 @@
+import type { ComponentTypeEnum } from '../../component/interface';
+import type { IChartSpec, IVChart } from '../../core';
+import type { IModelSpecInfo } from '../../model/interface';
+import type { SeriesTypeEnum } from '../../series';
+export interface IMediaInfo {
+    width: number;
+    height: number;
+}
+export type IMediaQuerySpec = IMediaQueryItem[];
+export interface IMediaQueryItem {
+    query: IMediaQueryCondition;
+    action: IMediaQueryAction | IMediaQueryAction[];
+}
+export interface IMediaQueryCondition {
+    minWidth?: number;
+    maxWidth?: number;
+    minHeight?: number;
+    maxHeight?: number;
+    onResize?: (info: IMediaInfo, vchart: IVChart) => boolean;
+}
+export interface IMediaQueryAction<T extends Record<string, unknown> = any> {
+    spec: Partial<T> | ((filteredModelInfo: IModelSpecInfo<T>[], action: IMediaQueryAction<T>, query: IMediaQueryCondition) => Partial<T>);
+    filterType?: MediaQueryActionFilterType;
+    filter?: MediaQueryActionFilter<T> | Array<MediaQueryActionFilter<T>>;
+    forceAppend?: boolean;
+}
+export type MediaQueryActionFilterType = 'region' | 'series' | 'chart' | `${SeriesTypeEnum}` | `${ComponentTypeEnum}` | keyof IChartSpec;
+export type MediaQueryActionFilter<T extends Record<string, unknown> = any> = Partial<T> | ((modelInfo: IModelSpecInfo<T>, action: IMediaQueryAction<T>, query: IMediaQueryCondition) => boolean);

package/types/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/types/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/types/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';