@visactor/vchart-types 0.10.0-alpha.2

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,23 @@
+import type { TooltipContentProperty } from './common';
+import type { ITooltipLabelActual, ITooltipLabelPattern } from './label';
+import type { ITooltipShapeActual, ITooltipShapePattern } from './shape';
+import type { TooltipRichTextAttrs } from '@visactor/vrender-components';
+export interface IToolTipLinePattern extends ITooltipShapePattern, ITooltipLabelPattern {
+    key?: TooltipContentProperty<string>;
+    value?: TooltipContentProperty<string | TooltipRichTextAttrs>;
+    visible?: TooltipContentProperty<boolean>;
+    isKeyAdaptive?: TooltipContentProperty<boolean>;
+    spaceRow?: TooltipContentProperty<number>;
+    keyTimeFormat?: string;
+    keyTimeFormatMode?: 'utc' | 'local';
+    valueTimeFormat?: string;
+    valueTimeFormatMode?: 'utc' | 'local';
+}
+export interface IToolTipLineActual extends ITooltipShapeActual, ITooltipLabelActual {
+    key?: string;
+    value?: string | TooltipRichTextAttrs;
+    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 const 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 const 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;
+}

package/types/typings/visual.d.ts

@@ -0,0 +1,293 @@
+import type { PopTipAttributes } from '@visactor/vrender-components';
+import type { DataView } from '@visactor/vdataset';
+import type { Cursor } from './cursor';
+import type { InterpolateType } from './interpolate';
+import type { ScaleType } from './scale';
+import type { ShapeType } from './shape';
+import type { IPoint } from './coordinate';
+import type { IAttributeOpt, IModelMarkAttributeContext } from '../compile/mark';
+import type { Datum, StringOrNumber } from './common';
+import type { IPadding } from '@visactor/vutils';
+import type { IColorKey } from '../theme/color-scheme/interface';
+import type { IRepeatType, TextAlignType, TextBaselineType, IRichTextCharacter } from '@visactor/vrender-core';
+export interface IVisualSpecBase<D, T> {
+    type: ScaleType;
+    domain: D[];
+    range: T[];
+    specified?: {
+        [key: string]: unknown;
+    };
+}
+export interface IVisualSpecStyle<D, T> extends IVisualSpecBase<D, T> {
+    field?: string;
+}
+export type IDataDomainSpec = {
+    dataId: string;
+    fields: string[];
+};
+export interface IVisualSpecScale<D, T> extends Omit<IVisualSpecBase<D, T>, 'domain'> {
+    id: string;
+    domain: IVisualSpecBase<D, T>['domain'] | IDataDomainSpec[];
+}
+export type IVisual<D = any, R = any> = IVisualSpecStyle<D, R> | IVisualScale;
+export interface IVisualScale {
+    scale: string;
+    field?: string;
+    changeDomain?: 'none' | 'replace' | 'expand';
+}
+export type FunctionType<T> = (datum: Datum, context: IModelMarkAttributeContext, opt?: IAttributeOpt, source?: DataView) => T;
+export type ValueType<T> = T;
+export type VisualType<T> = ValueType<T> | FunctionType<T> | IVisual<unknown, T>;
+export type TextureType = 'circle' | 'dimond' | 'rect' | 'vertical-line' | 'horizontal-line' | 'bias-lr' | 'bias-rl' | 'grid';
+export type ConvertToMarkStyleSpec<T extends Record<string, any>> = {
+    [key in keyof T]: VisualType<T[key]>;
+};
+export interface IBorder {
+    distance: number | string;
+    stroke?: string | IGradient;
+    strokeOpacity?: number;
+    lineWidth?: number;
+    lineDash?: number[];
+    lineDashOffset?: number;
+}
+export interface ICommonSpec {
+    visible?: boolean;
+    x?: number;
+    y?: number;
+    z?: number;
+    stroke?: string | IGradient | false | (number | boolean)[] | IColorKey;
+    strokeOpacity?: number;
+    opacity?: number;
+    lineWidth?: number;
+    lineDash?: number[];
+    lineDashOffset?: number;
+    cursor?: Cursor;
+    zIndex?: number;
+    angle?: number;
+    anchor?: [number, number];
+    scaleX?: number;
+    scaleY?: number;
+    scaleCenter?: [number | string, number | string];
+    beta?: number;
+    alpha?: number;
+    anchor3d?: [number, number];
+    pickMode?: 'accurate' | 'imprecise' | 'custom';
+    boundsMode?: 'accurate' | 'imprecise';
+    pickStrokeBuffer?: number;
+    texture?: TextureType | string;
+    textureColor?: string;
+    textureSize?: number;
+    texturePadding?: number;
+    outerBorder?: IBorder;
+    innerBorder?: IBorder;
+    [key: string]: any;
+}
+export interface IFillMarkSpec extends ICommonSpec {
+    fill?: VisualType<string> | IGradient | false | IColorKey;
+    fillOpacity?: number;
+    background?: string | HTMLImageElement | HTMLCanvasElement | null;
+}
+export interface ISymbolMarkSpec extends IFillMarkSpec {
+    dx?: number;
+    dy?: number;
+    size?: number | number[];
+    shape?: ShapeType | string;
+    symbolType?: ShapeType | string;
+    scaleX?: number;
+    scaleY?: number;
+}
+export interface ILineLikeMarkSpec extends IFillMarkSpec {
+    curveType?: InterpolateType;
+    defined?: boolean;
+}
+export interface IAreaMarkSpec extends ILineLikeMarkSpec {
+    x1?: number;
+    y1?: number;
+    orient?: 'horizontal' | 'vertical';
+}
+export interface ILineMarkSpec extends ILineLikeMarkSpec {
+    lineCap?: LineStrokeCap;
+    lineJoin?: LineStrokeJoin;
+    miterLimit?: number;
+    strokeBoundsBuffer?: number;
+}
+export interface IRuleMarkSpec extends ILineMarkSpec {
+    x1?: number;
+    y1?: number;
+}
+export interface ITextMarkSpec extends IFillMarkSpec {
+    type?: 'html' | 'rich' | 'text';
+    text?: StringOrNumber | string[] | IRichTextCharacter[] | Function;
+    dx?: number;
+    dy?: number;
+    fontSize?: number;
+    textAlign?: TextAlign;
+    textBaseline?: TextBaseLine;
+    fontFamily?: string;
+    fontWeight?: FontWeight;
+    fontStyle?: FontStyle;
+    maxLineWidth?: number;
+    ellipsis?: string;
+    suffixPosition?: 'start' | 'end' | 'middle';
+    lineBreak?: string;
+    underline?: boolean;
+    lineThrough?: boolean;
+    lineHeight?: number | string;
+    poptip?: PopTipAttributes;
+    direction?: 'horizontal' | 'vertical';
+}
+export type IPositionedTextMarkSpec = Omit<ITextMarkSpec, 'align' | 'textAlign' | 'baseline' | 'textBaseline'>;
+export interface IRectMarkSpec extends IFillMarkSpec {
+    cornerRadius?: number | number[];
+    width?: number;
+    height?: number;
+    x1?: number;
+    y1?: number;
+}
+export interface IRect3dMarkSpec extends IRectMarkSpec {
+    length?: number;
+}
+export interface IBoxPlotMarkSpec extends ICommonSpec {
+    lineWidth?: number;
+    boxWidth?: number;
+    shaftWidth?: number;
+    shaftShape?: BoxPlotShaftShape;
+    boxFill?: string;
+    shaftFillOpacity?: number;
+    min?: (datum: Datum) => number;
+    q1?: (datum: Datum) => number;
+    median?: (datum: Datum) => number;
+    q3?: (datum: Datum) => number;
+    max?: (datum: Datum) => number;
+}
+export interface IRippleMarkSpec extends ICommonSpec {
+    ripple?: number;
+    size?: number;
+}
+export interface ILiquidMarkSpec extends ICommonSpec {
+    wave?: number;
+}
+export interface ILiquidOutlineSpec extends ISymbolMarkSpec {
+    lineWidth: number;
+}
+export interface IOutlierMarkSpec {
+    fill?: string;
+    size?: number;
+}
+export interface IPathMarkSpec extends IFillMarkSpec {
+    path?: string;
+    smoothScale?: boolean;
+}
+export interface ILinkPathMarkSpec extends IFillMarkSpec {
+    x0?: number;
+    y0?: number;
+    x1?: number;
+    y1?: number;
+    thickness?: number;
+    curvature?: number;
+    round?: boolean;
+    ratio?: number;
+    align?: 'start' | 'end' | 'center';
+    pathType?: 'line' | 'smooth' | 'polyline';
+    endArrow?: boolean;
+    startArrow?: boolean;
+    backgroundStyle?: any;
+    direction?: 'horizontal' | 'vertical' | 'LR' | 'RL' | 'TB' | 'BL' | 'radial';
+}
+export interface IArcMarkSpec extends IFillMarkSpec {
+    startAngle?: number;
+    endAngle?: number;
+    padAngle?: number;
+    outerRadius?: number;
+    innerRadius?: number;
+    cornerRadius?: number;
+    centerOffset?: number;
+    cap?: boolean | [boolean, boolean];
+    autoCapConical?: boolean;
+}
+export interface IArc3dMarkSpec extends IArcMarkSpec {
+    height?: number;
+}
+export interface IProgressArcMarkSpec extends IArcMarkSpec {
+    innerPadding?: number;
+    outerPadding?: number;
+}
+export interface ICellMarkSpec extends ISymbolMarkSpec {
+    padding?: number | number[] | IPadding;
+}
+export interface IGroupMarkSpec extends IFillMarkSpec {
+    clip?: boolean;
+    width?: number;
+    height?: number;
+    cornerRadius?: number | number[];
+}
+export interface IPolygonMarkSpec extends ICommonSpec, IFillMarkSpec {
+    points?: IPoint[];
+    cornerRadius?: number | number[];
+    scaleX?: number;
+    scaleY?: number;
+}
+export interface IPyramid3dMarkSpec extends IPolygonMarkSpec {
+    points?: IPoint[];
+}
+export type RepeatType = 'no-repeat' | 'repeat-x' | 'repeat-y' | 'repeat';
+export type RepeatXYType = 'no-repeat' | 'repeat' | 'stretch';
+export type ImageOriginType = 'top' | 'bottom';
+export type GradientPropValue<T> = ValueType<T> | FunctionType<T>;
+export type GradientStop = {
+    offset: GradientPropValue<number>;
+    color?: GradientPropValue<string>;
+    opacity?: number;
+};
+export interface IGradientLinear {
+    x0?: GradientPropValue<number>;
+    y0?: GradientPropValue<number>;
+    x1?: GradientPropValue<number>;
+    y1?: GradientPropValue<number>;
+    stops: GradientStop[];
+    gradient: 'linear';
+}
+export interface IGradientRadial {
+    r0?: GradientPropValue<number>;
+    x0?: GradientPropValue<number>;
+    y0?: GradientPropValue<number>;
+    x1?: GradientPropValue<number>;
+    y1?: GradientPropValue<number>;
+    r1?: GradientPropValue<number>;
+    stops: GradientStop[];
+    gradient: 'radial';
+}
+export interface IGradientConical {
+    x?: GradientPropValue<number>;
+    y?: GradientPropValue<number>;
+    startAngle?: GradientPropValue<number>;
+    endAngle?: GradientPropValue<number>;
+    stops: GradientStop[];
+    gradient: 'conical';
+}
+export type GradientType = 'linear' | 'radial' | 'conical';
+export type IGradient = IGradientLinear | IGradientRadial | IGradientConical;
+export type LineStrokeCap = 'butt' | 'round' | 'square';
+export type LineStrokeJoin = 'arcs' | 'bevel' | 'miter' | 'miter-clip' | 'round';
+export type BoxPlotShaftShape = 'line' | 'bar';
+export interface IThresholdStyle extends IVisualSpecStyle<number, string> {
+    domain: number[];
+    field: string;
+    range: string[];
+    type: 'threshold';
+}
+export interface IUnknownMarkSpec extends ICommonSpec {
+    [key: string]: unknown;
+}
+export interface IImageMarkSpec extends IFillMarkSpec {
+    cornerRadius?: number | number[];
+    width?: number;
+    height?: number;
+    repeatX?: IRepeatType;
+    repeatY?: IRepeatType;
+    image: string | HTMLImageElement | HTMLCanvasElement;
+}
+export type TextAlign = TextAlignType;
+export type TextBaseLine = TextBaselineType;
+export type FontStyle = 'normal' | 'italic' | 'oblique' | string;
+export type FontWeight = 'normal' | 'bold' | 'lighter' | 'bolder' | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900;

package/types/util/array.d.ts

@@ -0,0 +1,3 @@
+import { array, last as peek, maxInArray as maxInArr, minInArray as minInArr } from '@visactor/vutils';
+export declare function shallowCompare<T, U>(arrA: T | T[], arrB: U | U[]): boolean;
+export { array, peek, maxInArr, minInArr };

package/types/util/color.d.ts

@@ -0,0 +1 @@
+export { Color } from '@visactor/vutils';

package/types/util/data.d.ts

@@ -0,0 +1,38 @@
+import type { DataView } from '@visactor/vdataset';
+import type { StatisticOperations } from '../data/transforms/dimension-statistics';
+import type { ISeries, ISeriesStackDataMeta } from '../series/interface';
+export declare function mergeFields(targetFields: {
+    key: string;
+    operations: StatisticOperations;
+}[], mergeFields: {
+    key: string;
+    operations: StatisticOperations;
+}[]): {
+    key: string;
+    operations: StatisticOperations;
+}[];
+export declare function getFieldAlias(dataView: DataView, field: string): any;
+export interface IStackCacheNode {
+    values: any[];
+    series: {
+        s: ISeries;
+        values: any[];
+    }[];
+    nodes: {
+        [key: string]: IStackCacheNode;
+    };
+}
+export interface IStackCacheRoot {
+    nodes: {
+        [key: string]: IStackCacheNode;
+    };
+}
+export declare function getRegionStackGroup(region: {
+    getSeries: () => any[];
+}, setInitialValue: boolean, filter?: (s: any) => boolean): {
+    [key: string]: IStackCacheRoot;
+};
+export declare function stackTotal(stackData: IStackCacheNode, valueField: string): void;
+export declare function stackOffsetSilhouette(stackCache: IStackCacheNode): void;
+export declare function stack(stackCache: IStackCacheNode, stackInverse: boolean, hasPercent?: boolean): void;
+export declare function stackGroup(s: ISeries, stackData: ISeriesStackDataMeta, stackCache: IStackCacheNode, valueField: string, setInitialValue: boolean): void;

package/types/util/debug.d.ts

@@ -0,0 +1,9 @@
+export declare const log: (msg: string, ...args: any[]) => import("@visactor/vutils").ILogger;
+export declare const warn: (msg: string, detail?: any) => import("@visactor/vutils").ILogger;
+export declare const error: (msg: string, detail?: any, err?: Error) => void;
+export declare const config: IConfig;
+export interface IConfig {
+    silent: boolean;
+    errorHandler?: (msg: string, detail?: any) => void;
+    warnHandler?: (msg: string, detail?: any) => void;
+}

package/types/util/env.d.ts

@@ -0,0 +1,7 @@
+import type { RenderMode } from '../typings/spec';
+export declare const isBrowser: boolean;
+export declare const domDocument: Document;
+export declare function isTrueBrowser(mode: RenderMode): boolean;
+export declare function isPcLikeMode(mode: RenderMode): boolean;
+export declare function isMobileLikeMode(mode: RenderMode): boolean;
+export declare function isMiniAppLikeMode(mode: RenderMode): boolean;

package/types/util/hierarchy.d.ts

@@ -0,0 +1,3 @@
+export declare const findHierarchyNode: <T>(hierarchyData: T[], key: string, keyField?: string, childrenField?: string) => T;
+export declare const findHierarchyNodeParent: <T>(hierarchyData: T[], key: string, keyField?: string, childrenField?: string) => T;
+export declare const findHierarchyPath: <T>(hierarchyData: T[], key: string, keyField?: string, childrenField?: string) => string[];

package/types/util/id.d.ts

@@ -0,0 +1,2 @@
+export declare function createID(): number;
+export declare function resetID(): void;

package/types/util/image.d.ts

@@ -0,0 +1,4 @@
+import type { utilFunctionCtx } from '../typings/params';
+export declare function URLToImage(name: string, url: string): void;
+export declare function OffscreenCanvasToDataURL(c: OffscreenCanvas): Promise<string>;
+export declare function getCanvasDataURL(c: HTMLCanvasElement | OffscreenCanvas, ctx?: utilFunctionCtx): Promise<string>;

package/types/util/index.d.ts

@@ -0,0 +1,22 @@
+import { TimeUtil } from '../component/axis/cartesian/util/time';
+import { debounce, throttle, clamp } from '@visactor/vutils';
+export { debounce, throttle, clamp };
+export * from './array';
+export * from './color';
+export * from './debug';
+export * from './env';
+export * from './id';
+export * from './math';
+export * from './model';
+export * from './object';
+export * from './scale';
+export * from './space';
+export * from './type';
+export * from './spec';
+export * from './text';
+export * from './data';
+export * from './hierarchy';
+export * from './style';
+export declare const Utils: {
+    TimeUtil: typeof TimeUtil;
+};

package/types/util/math.d.ts

@@ -0,0 +1,28 @@
+import type { IBoundsLike } from '@visactor/vutils';
+import type { IPoint, IPolarPoint, Quadrant } from '../typings';
+import { isNumberClose, isGreater, isLess } from '@visactor/vutils';
+import { normalizeAngle, angleLabelOrientAttribute } from '@visactor/vutils-extension';
+export declare const isClose: typeof isNumberClose;
+export { isGreater, isLess, normalizeAngle, angleLabelOrientAttribute };
+export declare function polarToCartesian(point: IPolarPoint): IPoint;
+export declare function computeQuadrant(angle: number): Quadrant;
+export declare function normalizeStartEndAngle(start: number | null, end: number | null): {
+    startAngle: number;
+    endAngle: number;
+};
+export declare function outOfBounds(bounds: IBoundsLike, x: number, y: number): boolean;
+export declare function min(data: any[], field?: string): number;
+export declare function max(data: any[], field?: string): number;
+export declare function sum(data: any[], field?: string): number;
+export declare function average(data: any[], field?: string): number;
+export declare function variance(data: any[], field?: string): number;
+export declare function standardDeviation(data: any[], field?: string): number;
+export declare function median(data: any[], field?: string): number;
+export declare function regression(data: any[], fieldX?: string, fieldY?: string): any[];
+export declare function radiusLabelOrientAttribute(angle: number): {
+    align: "left" | "right" | "center";
+    baseline: "top" | "bottom" | "middle";
+};
+export declare function vectorAngle(v1: IPoint, v2: IPoint): number;
+export declare function distance(p1: IPoint, p2?: IPoint): number;
+export declare function getPercentValue(valueList: number[], idx: number, precision?: number): number;

package/types/util/model.d.ts

@@ -0,0 +1,5 @@
+import type { IRegion, ISeriesFilter } from '../region/interface';
+import type { ISeries } from '../series/interface';
+export declare function eachSeries(regions: IRegion[], callback: (s: ISeries) => boolean | void, filter?: ISeriesFilter): boolean;
+export declare function getSeries(regions: IRegion[], filter?: ISeriesFilter): ISeries[];
+export declare const getFirstSeries: (regions: IRegion[], coordinateType?: 'cartesian' | 'polar') => ISeries;

package/types/util/object.d.ts

@@ -0,0 +1,3 @@
+import { get, pick, cloneDeep } from '@visactor/vutils';
+export { get, pick, cloneDeep };
+export declare function field(f: string | string[]): (datum: any) => any;

package/types/util/scale.d.ts

@@ -0,0 +1,21 @@
+import type { IGlobalScale } from '../scale/interface';
+import type { IBaseScale } from '@visactor/vscale';
+import { BandScale, LinearScale, OrdinalScale, PointScale, ThresholdScale } from '@visactor/vscale';
+import type { IVisual } from '../typings/visual';
+import { ColorOrdinalScale } from '../scale/color-ordinal-scale';
+declare const defaultScaleMap: {
+    linear: typeof LinearScale;
+    band: typeof BandScale;
+    point: typeof PointScale;
+    ordinal: typeof OrdinalScale;
+    threshold: typeof ThresholdScale;
+    colorOrdinal: typeof ColorOrdinalScale;
+};
+export declare function createScale(type: keyof typeof defaultScaleMap): IBaseScale | null;
+export declare function createScaleWithSpec(spec: IVisual<any>, context: {
+    globalScale: IGlobalScale;
+    seriesId: number;
+}): IBaseScale | null;
+export declare function valueInScaleRange(v: number, s?: IBaseScale): number;
+export declare function isSpecValueWithScale(specValue: any): boolean;
+export {};

package/types/util/space.d.ts

@@ -0,0 +1,13 @@
+import type { IBoundsLike } from '@visactor/vutils';
+import type { IPadding } from '../typings/space';
+import type { IPoint } from '../typings/coordinate';
+import type { ILayoutNumber, ILayoutRect, IPercent, IPercentOffset, ILayoutPaddingSpec, ILayoutOrientPadding } from '../typings/layout';
+export declare function isValidOrient(orient: string): boolean;
+export declare function isPercent(v: any): v is IPercent;
+export declare function isPercentOffset(v: any): v is IPercentOffset;
+export declare function calcLayoutNumber(v: ILayoutNumber | undefined, size: number, callOp?: ILayoutRect): number;
+export declare function calcPadding(paddingSpec: ILayoutOrientPadding, rect: ILayoutRect, callOp: ILayoutRect): IPadding;
+export declare function boundsInRect(bounds: IBoundsLike, rect: ILayoutRect): ILayoutRect;
+export declare function normalizeLayoutPaddingSpec(spec: ILayoutPaddingSpec): ILayoutOrientPadding;
+export declare function convertPoint(point: IPoint, relativePoint: IPoint, convert: boolean): IPoint;
+export declare const getActualNumValue: (originValue: number | string, total: number) => number;

package/types/util/spec/background.d.ts

@@ -0,0 +1,4 @@
+import type { IBackgroundSpec, IBackgroundStyleSpec } from '../../typings';
+export declare function convertBackgroundSpec(bg: IBackgroundSpec): Omit<IBackgroundStyleSpec, 'image'> & {
+    background?: IBackgroundStyleSpec['image'];
+};

package/types/util/spec/clone-deep.d.ts

@@ -0,0 +1 @@
+export declare function cloneDeepSpec(spec: any, excludeKeys?: string[]): any;

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

@@ -0,0 +1,5 @@
+import { DataView } from '@visactor/vdataset';
+import type { ITheme } from '../../theme';
+export declare function isDataView(obj: any): obj is DataView;
+export declare function isHTMLElement(obj: any): obj is Element;
+export declare function getThemeObject(theme?: string | ITheme, transformed?: boolean): ITheme;

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

@@ -0,0 +1,7 @@
+export * from './background';
+export * from './clone-deep';
+export * from './common';
+export * from './merge-spec';
+export * from './merge-theme';
+export * from './preprocess';
+export * from './transform';

package/types/util/spec/merge-spec.d.ts

@@ -0,0 +1,5 @@
+export declare function mergeSpec(target: any, ...sources: any[]): any;
+export declare function mergeSpecWithFilter(target: any, filter: string | {
+    type: string;
+    index: number;
+}, spec: any, forceMerge: boolean): void;

package/types/util/spec/merge-theme.d.ts

@@ -0,0 +1,6 @@
+import type { Maybe } from '@visactor/vutils';
+import type { IGlobalMarkThemeByName, IGlobalMarkThemeByType, ITheme } from '../../theme';
+import type { IThemeColorScheme } from '../../theme/color-scheme/interface';
+export declare function mergeTheme(target: Maybe<ITheme>, ...sources: Maybe<ITheme>[]): Maybe<ITheme>;
+export declare function transformColorSchemeToMerge(colorScheme?: Maybe<IThemeColorScheme>): Maybe<IThemeColorScheme>;
+export declare function transformSeriesThemeToMerge(seriesTheme: any, seriesType: string, markByType: IGlobalMarkThemeByType, markByName: IGlobalMarkThemeByName): any;

package/types/util/spec/preprocess.d.ts

@@ -0,0 +1,3 @@
+import type { IThemeColorScheme } from '../../theme/color-scheme/interface';
+import type { ISeriesSpec } from '../../typings';
+export declare function preprocessTheme(obj: any, colorScheme?: IThemeColorScheme, seriesSpec?: ISeriesSpec): any;

package/types/util/spec/transform.d.ts

@@ -0,0 +1,5 @@
+import type { ISeriesSpec } from '../../typings';
+export declare function specTransform(spec: unknown, special?: {
+    [key: string]: (v: unknown) => unknown;
+}): unknown;
+export declare function functionTransform(spec: ISeriesSpec, VChart: any): any;

package/types/util/style.d.ts

@@ -0,0 +1,4 @@
+export declare function transformComponentStyle(cfg?: any): any;
+export declare function transformStateStyle(stateStyle: any): {};
+export declare function transformAxisLabelStateStyle(stateStyle: any): {};
+export declare function transformToGraphic(style: any): any;

package/types/util/text.d.ts

@@ -0,0 +1,5 @@
+import type { ITextMeasureOption, ITextSize } from '@visactor/vutils';
+import type { TextMeasure } from '@visactor/vutils';
+import type { ITextGraphicAttribute } from '@visactor/vrender-core';
+export declare const initTextMeasure: (textSpec?: Partial<ITextGraphicAttribute>, option?: Partial<ITextMeasureOption>, useNaiveCanvas?: boolean) => TextMeasure<ITextGraphicAttribute>;
+export declare const measureText: (text: string, textSpec?: Partial<ITextGraphicAttribute>, option?: Partial<ITextMeasureOption>, useNaiveCanvas?: boolean) => ITextSize;