@visactor/vchart-types 0.16.17-alpha.2

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

@@ -0,0 +1,266 @@
+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, 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, 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 { IColorKey } from '../../theme/color-scheme/interface';
+import type { ILayoutOrientPadding, ILayoutPaddingSpec } from '../layout';
+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;
+}
+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 | IColorKey>, '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>[];
+    theme?: Omit<ITheme, 'name'> | string;
+    background?: IBackgroundSpec;
+    stackInverse?: boolean;
+}
+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 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;
+    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>>;
+    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;
+    [MarkTypeEnum.ripple]: IRippleMarkSpec;
+};
+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/types/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/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';

package/types/typings/tooltip/label.d.ts

@@ -0,0 +1,10 @@
+import type { ITooltipTextTheme } from '../../component/tooltip/interface/theme';
+import type { TooltipContentProperty } from './common';
+export interface ITooltipLabelPattern {
+    keyStyle?: TooltipContentProperty<ITooltipTextTheme>;
+    valueStyle?: TooltipContentProperty<ITooltipTextTheme>;
+}
+export interface ITooltipLabelActual {
+    keyStyle?: ITooltipTextTheme;
+    valueStyle?: ITooltipTextTheme;
+}

package/types/typings/tooltip/line.d.ts

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

package/types/typings/tooltip/position.d.ts

@@ -0,0 +1,31 @@
+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",
+    bottom = "bottom",
+    left = "left",
+    right = "right",
+    tl = "tl",
+    lt = "lt",
+    tr = "tr",
+    rt = "rt",
+    bl = "bl",
+    lb = "lb",
+    br = "br",
+    rb = "rb",
+    inside = "inside"
+}
+export declare enum TooltipPositionMode {
+    pointer = "pointer",
+    mark = "mark"
+}
+export type TooltipPosition = ITooltipPositionPattern | TooltipFixedPosition;
+export interface ITooltipPositionActual {
+    x: number;
+    y: number;
+}

package/types/typings/tooltip/shape.d.ts

@@ -0,0 +1,23 @@
+import type { ShapeType } from '../shape';
+import type { TooltipContentProperty } from './common';
+export interface ITooltipShapePattern {
+    seriesId?: number;
+    hasShape?: boolean;
+    shapeType?: TooltipContentProperty<ShapeType | string>;
+    shapeFill?: TooltipContentProperty<string>;
+    shapeStroke?: TooltipContentProperty<string>;
+    shapeLineWidth?: TooltipContentProperty<number>;
+    shapeSize?: TooltipContentProperty<number>;
+    shapeColor?: TooltipContentProperty<string>;
+    shapeHollow?: boolean;
+}
+export interface ITooltipShapeActual {
+    hasShape?: boolean;
+    shapeType?: ShapeType | string;
+    shapeFill?: string;
+    shapeStroke?: string;
+    shapeLineWidth?: number;
+    shapeSize?: number;
+    shapeColor?: string;
+    shapeHollow?: boolean;
+}

package/types/typings/tooltip/tooltip.d.ts

@@ -0,0 +1,26 @@
+import type { MaybeArray } from '../common';
+import type { TooltipPatternProperty, TooltipUpdateCallback } from './common';
+import type { TooltipActiveType, TooltipData } from './handler';
+import type { IToolTipLineActual, IToolTipLinePattern } from './line';
+import type { ITooltipPositionActual, TooltipPositionMode, 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>;
+    positionMode?: TooltipPatternProperty<TooltipPositionMode>;
+    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;
+    data?: TooltipData;
+}