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

package/build/es5/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 } from '@visactor/vrender';
+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 ICommonSpec {
+    visible?: boolean;
+    x?: number;
+    y?: number;
+    z?: number;
+    stroke?: string | IGradient | IColorKey;
+    strokeOpacity?: number;
+    opacity?: number;
+    lineWidth?: number;
+    lineDash?: number[];
+    lineDashOffset?: number;
+    cursor?: Cursor;
+    zIndex?: number;
+    borderSize?: number;
+    borderColor?: string;
+    borderSpacing?: number;
+    borderOpacity?: number;
+    angle?: number;
+    anchor?: [number, number];
+    beta?: number;
+    alpha?: number;
+    anchor3d?: [number, number];
+    pickMode?: 'accurate' | 'imprecise' | 'custom';
+    boundsMode?: 'accurate' | 'imprecise';
+    texture?: TextureType | string;
+    textureColor?: string;
+    textureSize?: number;
+    texturePadding?: number;
+    outerBorder?: {
+        distance: number | string;
+        stroke?: string | IGradient;
+        strokeOpacity?: number;
+        lineWidth?: number;
+        lineDash?: number[];
+        lineDashOffset?: number;
+    };
+    innerBorder?: {
+        distance: number | string;
+        stroke?: string | IGradient;
+        strokeOpacity?: number;
+        lineWidth?: number;
+        lineDash?: number[];
+        lineDashOffset?: number;
+    };
+    [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;
+    enableSegments?: 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 {
+    text?: StringOrNumber | string[];
+    dx?: number;
+    dy?: number;
+    fontSize?: number;
+    textAlign?: TextAlign;
+    textBaseline?: TextBaseLine;
+    fontFamily?: string;
+    fontWeight?: FontWeight;
+    fontStyle?: FontStyle;
+    maxLineWidth?: number;
+    ellipsis?: string;
+    lineBreak?: string;
+    underline?: boolean;
+    lineThrough?: boolean;
+    lineHeight?: number;
+    poptip?: PopTipAttributes;
+}
+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 IOutlierMarkSpec {
+    fill?: string;
+    size?: number;
+}
+export interface IPathMarkSpec extends IFillMarkSpec {
+    path?: string;
+    scaleX?: number;
+    scaleY?: number;
+    scaleCenter?: {
+        x: number;
+        y: number;
+    };
+    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 = 'left' | 'right' | 'center';
+export type TextBaseLine = 'top' | 'bottom' | 'middle' | 'alphabetic';
+export type FontStyle = 'normal' | 'italic' | 'oblique' | string;
+export type FontWeight = 'normal' | 'bold' | 'lighter' | 'bolder' | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900;

package/build/es5/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/build/es5/util/color.d.ts

@@ -0,0 +1,3 @@
+import { ColorUtil } from '@visactor/vutils';
+declare const Color: typeof ColorUtil.Color;
+export { Color };

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

@@ -0,0 +1,21 @@
+import type { DataView } from '@visactor/vdataset';
+import type { StatisticOperations } from '../data/transforms/dimension-statistics';
+export declare function mergeFields(targetFields: {
+    key: string;
+    operations: StatisticOperations;
+}[], mergeFields: {
+    key: string;
+    operations: StatisticOperations;
+}[]): {
+    key: string;
+    operations: StatisticOperations;
+}[];
+export declare function findFields(list: {
+    key: string;
+    operations: StatisticOperations;
+}[], fieldKey: string): {
+    key: string;
+    operations: StatisticOperations;
+};
+export declare function getFieldAlias(dataView: DataView, field: string): any;
+export declare function getFieldFormat(dataView: DataView, key: string): any;

package/build/es5/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/build/es5/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/build/es5/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/build/es5/util/id.d.ts

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

package/build/es5/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/build/es5/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/build/es5/util/math.d.ts

@@ -0,0 +1,41 @@
+import { isNumberClose, isGreater, isLess } from '@visactor/vutils';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { IPoint, IPolarPoint, Quadrant, TextAlign } from '../typings';
+export declare const isClose: typeof isNumberClose;
+export { isGreater, isLess };
+export declare function normalizeAngle(angle: number): number;
+export declare const radians: (angle?: number) => number;
+export declare const degrees: (angle?: number) => number;
+export declare function polarToCartesian(point: IPolarPoint): IPoint;
+export declare function circlePoint(x0: number, y0: number, radius: number, radian: number): IPoint;
+export declare function arcConnectLength(radius: number, radian: number): number;
+export declare function lineCirclePoints(a: number, b: number, c: number, x0: number, y0: number, r: number): IPoint[];
+export declare function connectLineRadian(radius: number, length: number): number;
+export declare function computeQuadrant(angle: number): Quadrant;
+export declare function normalizeStartEndAngle(start: number | null, end: number | null): {
+    startAngle: number;
+    endAngle: number;
+};
+export declare function isQuadrantLeft(quadrant: Quadrant): boolean;
+export declare function isQuadrantRight(quadrant: Quadrant): boolean;
+export declare function checkBoundsOverlap(boundsA: IBoundsLike, boundsB: IBoundsLike): boolean;
+export declare function outOfBounds(bounds: IBoundsLike, x: number, y: number): boolean;
+export declare function insideBounds(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 angleLabelOrientAttribute(angle: number): {
+    align: TextAlign;
+    baseline: "top" | "bottom" | "middle";
+};
+export declare function radiusLabelOrientAttribute(angle: number): {
+    align: TextAlign;
+    baseline: "top" | "bottom" | "middle";
+};
+export declare function vectorAngle(v1: IPoint, v2: IPoint): number;
+export declare function distance(p1: IPoint, p2?: IPoint): number;

package/build/es5/util/model.d.ts

@@ -0,0 +1,4 @@
+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[];

package/build/es5/util/object.d.ts

@@ -0,0 +1,5 @@
+import { get, pick, merge, cloneDeep } from '@visactor/vutils';
+export { get, pick, merge, cloneDeep };
+export declare function removeEmpty<T extends object>(obj: T): Partial<T>;
+export declare function sortByKey<T extends object>(object: T, includeKeys?: string[], excludeKeys?: string[]): Partial<T>;
+export declare function field(f: string | string[]): (datum: any) => any;

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

@@ -0,0 +1,25 @@
+import type { DataView } from '@visactor/vdataset';
+import type { IGlobalScale } from '../scale/interface';
+import { BandScale, LinearScale, OrdinalScale, PointScale, ThresholdScale } from '@visactor/vscale';
+import type { IBaseScale } from '@visactor/vscale';
+import type { ScaleType } from '../typings/scale';
+import type { IVisual, IVisualSpecBase } 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;
+    dataStatistics: DataView;
+}): IBaseScale | null;
+export declare function initScaleWithSpec(scale: IBaseScale, spec: IVisualSpecBase<any, any>): void;
+export declare function isValidScaleType(type: ScaleType): boolean;
+export declare function valueInScaleRange(v: number, s?: IBaseScale): number;
+export declare function isSpecValueWithScale(specValue: any): boolean;
+export {};

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

@@ -0,0 +1,19 @@
+import type { ILayoutPaddingSpec } from '../model/interface';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { ILayoutNumber, IPercent, ILayoutOrientPadding, ILayoutRect } from '../model/interface';
+import type { IPadding, IRect } from '../typings/space';
+import { Direction } from '../typings/space';
+import type { IPoint } from '../typings/coordinate';
+export declare function isValidOrient(orient: string): boolean;
+export declare function getSpecPadding(padding: IPadding | number | undefined | null, defaultPadding: IPadding): IPadding;
+export declare function isPointInRect(point: IPoint, rect: IRect): boolean;
+export declare function isPercent(v: any): v is IPercent;
+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 boundsOutViewBox(bounds: IBoundsLike, box: IBoundsLike, direction: Direction): {
+    start: number;
+    end: number;
+};
+export declare function normalizeLayoutPaddingSpec(spec: ILayoutPaddingSpec): ILayoutOrientPadding;
+export declare function convertPoint(point: IPoint, relativePoint: IPoint, convert: boolean): IPoint;

package/build/es5/util/spec.d.ts

@@ -0,0 +1,10 @@
+import type { IBackgroundSpec, IBackgroundStyleSpec } from './../typings/spec/common';
+import { DataView } from '@visactor/vdataset';
+export declare function specTransform(spec: unknown, special?: {
+    [key: string]: (v: unknown) => unknown;
+}): unknown;
+export declare function cloneDeepSpec(spec: any): any;
+export declare function isDataView(obj: any): obj is DataView;
+export declare function convertBackgroundSpec(bg: IBackgroundSpec): Omit<IBackgroundStyleSpec, 'image'> & {
+    background?: IBackgroundStyleSpec['image'];
+};

package/build/es5/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/build/es5/util/text.d.ts

@@ -0,0 +1,9 @@
+import type { ITextMeasureOption } from '@visactor/vutils';
+import { TextMeasure, TestTextMeasure } from '@visactor/vutils';
+import type { IRichTextAttribute } from '@visactor/vrender';
+import type { ITextMarkSpec } from '../typings';
+export declare const initTextMeasure: (textSpec?: Partial<ITextMarkSpec>, option?: Partial<ITextMeasureOption>, useNaiveCanvas?: boolean) => TextMeasure<ITextMarkSpec>;
+export declare const testTextMeasure: (textSpec?: Partial<ITextMarkSpec>, useVRender?: boolean) => TestTextMeasure<any>;
+type IRichTextBoundsParams = Partial<IRichTextAttribute>;
+export declare function getRichTextBounds(params: IRichTextBoundsParams): import("@visactor/vutils").IBounds;
+export {};

package/build/es5/util/type.d.ts

@@ -0,0 +1,7 @@
+import { isObject, isFunction, isArray, isString, isNumber, isRegExp, isBoolean, isDate, isUndefined, isNull, isNil, isValid, isArrayLike, isValidNumber, isPlainObject } from '@visactor/vutils';
+import type { IDataDomainSpec } from '../typings';
+export { isObject, isFunction, isArray, isString, isNumber, isRegExp, isBoolean, isDate, isUndefined, isNull, isNil, isValid, isArrayLike, isValidNumber, isPlainObject };
+export declare function couldBeValidNumber(v: any): boolean;
+export declare function toValidNumber(v: any): number;
+export declare function isNumeric(value: string): boolean;
+export declare function isDataDomainSpec(domain: any): domain is IDataDomainSpec[];

package/build/es5/vchart-all.d.ts

@@ -0,0 +1,2 @@
+import { VChart } from './core';
+export { VChart };

package/build/es5/vchart-simple.d.ts

@@ -0,0 +1,2 @@
+import { VChart } from './core';
+export { VChart };