@visactor/vchart-types 0.10.0-alpha.2

package/types/series/base/base-series.d.ts

@@ -0,0 +1,228 @@
+import { DataView } from '@visactor/vdataset';
+import type { DataSet, ITransformOptions } from '@visactor/vdataset';
+import type { IRegion } from '../../region/interface';
+import type { IMark } from '../../mark/interface';
+import type { CoordinateType, IInvalidType, IPoint, DataKeyType, Datum, Maybe, ISeriesSpec, IGroup, ILayoutType, ILayoutPoint, ILayoutRect } from '../../typings';
+import { BaseModel } from '../../model/base-model';
+import type { ISeriesOption, ISeries, ISeriesMarkInitOption, ISeriesStackData, ISeriesTooltipHelper, SeriesMarkMap, ISeriesMarkInfo, ISeriesSpecInfo } from '../interface';
+import type { IModelEvaluateOption, IModelRenderOption } from '../../model/interface';
+import type { AddVChartPropertyContext } from '../../data/transforms/add-property';
+import type { StatisticOperations } from '../../data/transforms/dimension-statistics';
+import { SeriesData } from './series-data';
+import type { IGroupMark } from '../../mark/group';
+import type { ISeriesMarkAttributeContext } from '../../compile/mark';
+import { STATE_VALUE_ENUM } from '../../compile/mark';
+import { BaseSeriesSpecTransformer } from './base-series-transformer';
+import type { EventType } from '@visactor/vgrammar-core';
+export declare abstract class BaseSeries<T extends ISeriesSpec> extends BaseModel<T> implements ISeries {
+    readonly specKey: string;
+    readonly type: string;
+    layoutType: ILayoutType;
+    readonly modelType: string;
+    readonly name: string | undefined;
+    static readonly mark: SeriesMarkMap;
+    static readonly transformerConstructor: typeof BaseSeriesSpecTransformer;
+    readonly transformerConstructor: any;
+    getSpecInfo: () => ISeriesSpecInfo;
+    protected _option: ISeriesOption;
+    readonly coordinate: CoordinateType;
+    protected _region: IRegion;
+    getRegion(): IRegion;
+    private _layoutStartPoint;
+    getLayoutStartPoint(): ILayoutPoint;
+    private _layoutRect;
+    getLayoutRect: () => ILayoutRect;
+    protected _rootMark: IGroupMark;
+    getRootMark(): IGroupMark;
+    protected _seriesMark: Maybe<IMark>;
+    protected _layoutLevel: number;
+    protected _rawData: DataView;
+    getRawData(): DataView;
+    protected _rawDataStatistics?: DataView;
+    protected _rawStatisticsCache: Record<string, {
+        values?: any[];
+        min?: number;
+        max?: number;
+    }>;
+    protected _viewDataMap: Map<number, DataView>;
+    protected _viewDataFilter: DataView;
+    getViewDataFilter(): DataView;
+    protected _data: SeriesData;
+    getViewData(): DataView;
+    getViewDataProductId(): string;
+    protected _viewDataStatistics: DataView;
+    getViewDataStatistics(): DataView;
+    protected _viewStackData: DataView;
+    getViewStackData(): DataView;
+    protected _seriesField?: string;
+    getSeriesField(): string;
+    setSeriesField(field: string): void;
+    protected _groups?: IGroup;
+    getGroups(): IGroup;
+    protected _stack: boolean;
+    protected _supportStack: boolean;
+    getStack(): boolean;
+    getStackValue(): import("../../typings").StringOrNumber;
+    protected _percent: boolean;
+    getPercent(): boolean;
+    protected _stackOffsetSilhouette: boolean;
+    getStackOffsetSilhouette(): boolean;
+    protected _dataSet: DataSet;
+    protected _tooltipHelper: ISeriesTooltipHelper | undefined;
+    get tooltipHelper(): ISeriesTooltipHelper;
+    layoutZIndex: number;
+    protected _invalidType: IInvalidType;
+    getInvalidType(): IInvalidType;
+    setInvalidType(t: IInvalidType): void;
+    protected _markAttributeContext: ISeriesMarkAttributeContext;
+    getMarkAttributeContext(): ISeriesMarkAttributeContext;
+    constructor(spec: T, options: ISeriesOption);
+    created(): void;
+    protected _buildMarkAttributeContext(): void;
+    setAttrFromSpec(): void;
+    protected initData(): void;
+    protected initGroups(): void;
+    protected initStatisticalData(): void;
+    getRawDataStatisticsByField(field: string, isNumeric?: boolean): {
+        values?: any[];
+        min?: number;
+        max?: number;
+    };
+    protected _statisticViewData(): void;
+    protected createStatisticalData(dataName: string, rawData: DataView, staticFields?: (dataId: string) => {
+        key: string;
+        operations: StatisticOperations;
+    }[]): DataView;
+    private createdStackData;
+    protected _noAnimationDataKey(datum: Datum, index: number): unknown | undefined;
+    protected generateDefaultDataKey(dataKey: DataKeyType): (datum: Datum, index: number, context: AddVChartPropertyContext) => unknown;
+    protected _addDataIndexAndKey(): void;
+    updateRawData(d: any): void;
+    rawDataUpdate(d: DataView): void;
+    viewDataFilterOver(d: DataView): void;
+    viewDataUpdate(d: DataView): void;
+    viewDataStatisticsUpdate(d: DataView): void;
+    getDatumPositionValue(datum: Datum, field: string): any;
+    getDatumPositionValues(datum: Datum, fields: string | string[]): any[];
+    abstract getStatisticFields(): {
+        key: string;
+        operations: StatisticOperations;
+    }[];
+    abstract getGroupFields(): string[];
+    abstract dataToPosition(data: Datum): IPoint;
+    abstract dataToPositionX(data: Datum): number;
+    abstract dataToPositionY(data: Datum): number;
+    abstract valueToPosition(value1: any, value2?: any): IPoint;
+    abstract initMark(): void;
+    abstract initMarkStyle(): void;
+    abstract getStackGroupFields(): string[];
+    abstract getStackValueField(): string | undefined;
+    setValueFieldToStack(): void;
+    setValueFieldToPercent(): void;
+    setValueFieldToStackOffsetSilhouette(): void;
+    abstract getActiveMarks(): IMark[];
+    initRootMark(): void;
+    protected _initExtensionMark(options: {
+        hasAnimation: boolean;
+        depend?: IMark[];
+    }): void;
+    private _createExtensionMark;
+    protected _updateExtensionMarkSpec(lastSpec?: any): void;
+    getStackData(): ISeriesStackData;
+    protected _parseDefaultInteractionConfig(mainMarks?: IMark[]): ({
+        seriesId: number;
+        regionId: number;
+        selector: string[];
+        type: string;
+        trigger: EventType;
+        triggerOff: EventType;
+        blurState: STATE_VALUE_ENUM;
+        highlightState: STATE_VALUE_ENUM;
+        reverseState?: undefined;
+        state?: undefined;
+        isMultiple?: undefined;
+    } | {
+        type: string;
+        seriesId: number;
+        regionId: number;
+        selector: string[];
+        trigger: EventType;
+        triggerOff: EventType;
+        reverseState: STATE_VALUE_ENUM;
+        state: STATE_VALUE_ENUM;
+        isMultiple: boolean;
+        blurState?: undefined;
+        highlightState?: undefined;
+    })[];
+    protected _parseInteractionConfig(mainMarks?: IMark[]): void;
+    initInteraction(): void;
+    initAnimation(): void;
+    initMarkState(): void;
+    initSeriesStyleState(): void;
+    afterInitMark(): void;
+    getMarksWithoutRoot(): IMark[];
+    getMarksInType(type: string | string[]): IMark[];
+    getMarkInName(name: string): IMark | undefined;
+    getMarkInId(markId: number): IMark | undefined;
+    protected initEvent(): void;
+    protected _releaseEvent(): void;
+    protected initTooltip(): void;
+    _compareSpec(spec: T, prevSpec: T, ignoreCheckKeys?: {
+        [key: string]: true;
+    }): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    _updateSpecData(): void;
+    reInit(spec?: T): void;
+    onEvaluateEnd(ctx: IModelEvaluateOption): void;
+    onRender(ctx: IModelRenderOption): void;
+    release(): void;
+    setLayoutStartPosition(pos: Partial<IPoint>): void;
+    setLayoutRect({ width, height }: Partial<ILayoutRect>, levelMap?: Partial<ILayoutRect>): void;
+    getSeriesKeys(): string[];
+    getSeriesStyle(datum: Datum): (attribute: string) => unknown;
+    protected _getSeriesInfo(field: string, keys: string[]): {
+        key: string;
+        style: (attribute: string) => unknown;
+        shapeType: string;
+    }[];
+    getSeriesInfoInField(field: string): {
+        key: string;
+        style: (attribute: string) => unknown;
+        shapeType: string;
+    }[];
+    getSeriesInfoList(): {
+        key: string;
+        style: (attribute: string) => unknown;
+        shapeType: string;
+    }[];
+    protected _getDefaultColorScale(): any;
+    protected _getDataScheme(): import("../..").ColorSchemeItem[] | import("../..").ProgressiveDataScheme<import("../..").ColorSchemeItem>;
+    getDefaultColorDomain(): any[];
+    getColorAttribute(): {
+        scale: any;
+        field: string;
+    };
+    getDimensionField(): string[];
+    getMeasureField(): string[];
+    protected onMarkPositionUpdate(): void;
+    protected onMarkTreePositionUpdate(marks: IMark[]): void;
+    protected _createMark<M extends IMark>(markInfo: ISeriesMarkInfo, option?: ISeriesMarkInitOption): NonNullable<M>;
+    protected _getDataIdKey(): string | ((datum: Datum) => string);
+    protected _getSeriesDataKey(datum: Datum): string;
+    addViewDataFilter(option: ITransformOptions): void;
+    reFilterViewData(): void;
+    reTransformViewData(): void;
+    fillData(): void;
+    compile(): void;
+    getDefaultShapeType(): string;
+    getFieldAlias(field: string): any;
+    getMarkInfoList(): import("../../model/interface").IModelMarkInfo[];
+    protected _getInvalidConnectType(): "none" | "zero" | "connect";
+    protected _getInvalidDefined: (datum: Datum) => boolean;
+    protected _getRelatedComponentSpecInfo(specKey: string): import("../../model/interface").IModelSpecInfo<any>[];
+}

package/types/series/base/constant.d.ts

@@ -0,0 +1,6 @@
+import type { SeriesMarkMap } from '../interface/common';
+export declare const baseSeriesMark: SeriesMarkMap;
+export declare const RECT_X: string;
+export declare const RECT_X1: string;
+export declare const RECT_Y: string;
+export declare const RECT_Y1: string;

package/types/series/base/group.d.ts

@@ -0,0 +1,12 @@
+import { DataSet, DataView } from '@visactor/vdataset';
+import type { IGroup } from '../../typings';
+export declare class Group implements IGroup {
+    protected _fields: string[];
+    get fields(): string[];
+    protected _groupData?: DataView;
+    get groupData(): DataView;
+    constructor(fields: string[]);
+    initData(viewData: DataView, dataSet: DataSet): void;
+    groupDataUpdate(): void;
+    getGroupValueInField(field: string): unknown[];
+}

package/types/series/base/index.d.ts

@@ -0,0 +1,2 @@
+export * from './base-series';
+export * from './base-series-transformer';

package/types/series/base/series-data.d.ts

@@ -0,0 +1,5 @@
+import { CompilableData } from '../../compile/data/compilable-data';
+export declare class SeriesData extends CompilableData {
+    protected _compileProduct(): void;
+    generateProductId(): string;
+}

package/types/series/base/tooltip-helper.d.ts

@@ -0,0 +1,31 @@
+import type { TooltipHandlerParams } from '../../component/tooltip/interface';
+import type { IToolTipLinePattern, ITooltipPattern, ShapeType, TooltipActiveType } from '../../typings';
+import type { ISeries, ISeriesTooltipHelper } from '../interface';
+import { BaseTooltipHelper } from '../../model/tooltip-helper';
+import type { IDimensionInfo } from '../../event/events/dimension/interface';
+import type { Datum } from '@visactor/vgrammar-core';
+interface ISeriesCacheInfo {
+    seriesFields: string[];
+    dimensionFields: string[];
+    measureFields: string[];
+    type: string;
+}
+export declare class BaseSeriesTooltipHelper extends BaseTooltipHelper implements ISeriesTooltipHelper {
+    series: ISeries;
+    protected _seriesCacheInfo: ISeriesCacheInfo;
+    constructor(series: ISeries);
+    updateTooltipSpec(): void;
+    protected _getSeriesCacheInfo: () => ISeriesCacheInfo;
+    protected _getDimensionData: (datum: any) => any;
+    protected _getMeasureData: (datum: any) => any;
+    protected _getSeriesStyle: (datum: any, styleKey: string | string[], defaultValue?: any) => any;
+    contentKeyCallback: (datum: Datum, params?: TooltipHandlerParams) => string | undefined;
+    contentValueCallback: (datum: Datum, params?: TooltipHandlerParams) => string | undefined;
+    contentShapeTypeCallback: (datum: Datum, params?: TooltipHandlerParams) => ShapeType | undefined;
+    contentShapeColorCallback: (datum: Datum, params?: TooltipHandlerParams) => string | undefined;
+    titleValueCallback: (datum: Datum, params?: TooltipHandlerParams) => string | undefined;
+    getDefaultTooltipPattern(activeType: TooltipActiveType, dimensionInfo?: IDimensionInfo[]): ITooltipPattern | null;
+}
+export declare const addExtraInfoToTooltipTitlePattern: <T>(pattern: ITooltipPattern['title'], extraInfo: T | ((line: IToolTipLinePattern) => T), overwrite?: boolean) => ITooltipPattern['title'] | undefined;
+export declare const addExtraInfoToTooltipContentPattern: <T>(pattern: ITooltipPattern['content'], extraInfo: T | ((line: IToolTipLinePattern) => T), overwrite?: boolean) => ITooltipPattern['content'] | undefined;
+export {};

package/types/series/box-plot/box-plot.d.ts

@@ -0,0 +1,62 @@
+import type { IModelEvaluateOption, IModelInitOption } from '../../model/interface';
+import type { BoxPlotShaftShape, IOutlierMarkSpec } from '../../typings';
+import { CartesianSeries } from '../cartesian/cartesian';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { IBoxPlotSeriesSpec } from './interface';
+import { SeriesData } from '../base/series-data';
+import type { IMark } from '../../mark/interface';
+export declare const DEFAULT_FILL_COLOR = "#FFF";
+export declare const DEFAULT_STROKE_COLOR = "#000";
+export declare class BoxPlotSeries<T extends IBoxPlotSeriesSpec = IBoxPlotSeriesSpec> extends CartesianSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _minField: string;
+    getMinField(): string;
+    protected _maxField: string;
+    getMaxField(): string;
+    protected _q1Field: string;
+    getQ1Field(): string;
+    protected _medianField: string;
+    getMedianField(): string;
+    protected _q3Field: string;
+    getQ3Field(): string;
+    protected _outliersField: string;
+    getOutliersField(): string;
+    protected _lineWidth: number;
+    protected _boxWidth: number;
+    protected _shaftShape: BoxPlotShaftShape;
+    getShaftShape(): BoxPlotShaftShape;
+    protected _shaftWidth: number;
+    protected _boxFillColor: string;
+    getBoxFillColor(): string;
+    protected _strokeColor: string;
+    getStrokeColor(): string;
+    protected _shaftFillOpacity: number;
+    protected _outliersStyle: IOutlierMarkSpec;
+    getOutliersStyle(): IOutlierMarkSpec;
+    protected _outlierDataView: SeriesData;
+    private _autoBoxWidth;
+    setAttrFromSpec(): void;
+    private _boxPlotMark?;
+    private _outlierMark?;
+    initMark(): void;
+    initMarkStyle(): void;
+    initBoxPlotMarkStyle(): void;
+    initData(): void;
+    init(option: IModelInitOption): void;
+    private _getMarkWidth;
+    onLayoutEnd(ctx: any): void;
+    private _initAnimationSpec;
+    initAnimation(): void;
+    protected initTooltip(): void;
+    getStatisticFields(): {
+        key: string;
+        operations: import("../../data/transforms/dimension-statistics").StatisticOperations;
+    }[];
+    onEvaluateEnd(ctx: IModelEvaluateOption): void;
+    getDefaultShapeType(): string;
+    getActiveMarks(): IMark[];
+}
+export declare const registerBoxplotSeries: () => void;

package/types/series/box-plot/constant.d.ts

@@ -0,0 +1,2 @@
+import type { SeriesMarkMap } from '../interface/common';
+export declare const boxPlotSeriesMark: SeriesMarkMap;

package/types/series/box-plot/interface.d.ts

@@ -0,0 +1,22 @@
+import type { IAnimationSpec } from '../../animation/spec';
+import type { IMarkProgressiveConfig } from '../../mark/interface';
+import type { DirectionType, IBoxPlotMarkSpec, IOutlierMarkSpec, IMarkSpec, IMarkTheme } from '../../typings';
+import type { ICartesianSeriesSpec, ICartesianSeriesTheme } from '../cartesian/interface';
+import type { SeriesMarkNameEnum } from '../interface/type';
+export interface IBoxPlotSeriesSpec extends Omit<ICartesianSeriesSpec, 'xField' | 'yField' | 'direction'>, IAnimationSpec<string, string>, IMarkProgressiveConfig {
+    type: 'boxPlot';
+    direction?: DirectionType;
+    xField?: string | string[];
+    yField?: string | string[];
+    minField?: string;
+    maxField?: string;
+    q1Field?: string;
+    medianField?: string;
+    q3Field?: string;
+    [SeriesMarkNameEnum.boxPlot]?: IMarkSpec<IBoxPlotMarkSpec>;
+    outliersField?: string;
+    outliersStyle?: IOutlierMarkSpec;
+}
+export interface IBoxPlotSeriesTheme extends ICartesianSeriesTheme {
+    [SeriesMarkNameEnum.boxPlot]?: Partial<IMarkTheme<IBoxPlotMarkSpec>>;
+}

package/types/series/box-plot/tooltip-helper.d.ts

@@ -0,0 +1,12 @@
+import type { ISeriesTooltipHelper } from '../interface';
+import { BaseSeriesTooltipHelper } from '../base/tooltip-helper';
+import type { Datum, ITooltipPattern, TooltipActiveType } from '../../typings';
+import { BOX_PLOT_TOOLTIP_KEYS } from '../../constant/box-plot';
+export declare class BoxPlotSeriesTooltipHelper extends BaseSeriesTooltipHelper implements ISeriesTooltipHelper {
+    getDefaultTooltipPattern(activeType: TooltipActiveType): ITooltipPattern | null;
+    getContentKey: (contentType: BOX_PLOT_TOOLTIP_KEYS) => (datum: any) => string;
+    getContentValue: (contentType: BOX_PLOT_TOOLTIP_KEYS) => (datum: any) => any;
+    contentShapeColorCallback: (datum: Datum) => any;
+    getOutlierFillColor: (datum: Datum) => any;
+    isOutlierMark: (datum: Datum) => boolean;
+}

package/types/series/cartesian/cartesian.d.ts

@@ -0,0 +1,105 @@
+import type { DataView } from '@visactor/vdataset';
+import type { ICartesianSeries } from '../interface';
+import { BaseSeries } from '../base/base-series';
+import type { IPoint } from '../../typings/coordinate';
+import type { IBaseScale } from '@visactor/vscale';
+import type { IAxisHelper } from '../../component/axis/cartesian/interface';
+import type { DirectionType } from '../../typings/space';
+import type { Datum, StringOrNumber } from '../../typings';
+import type { StatisticOperations } from '../../data/transforms/dimension-statistics';
+import type { ICartesianSeriesSpec } from './interface';
+import type { IAxisLocationCfg } from '../../component/axis';
+export declare abstract class CartesianSeries<T extends ICartesianSeriesSpec = ICartesianSeriesSpec> extends BaseSeries<T> implements ICartesianSeries {
+    readonly coordinate: 'cartesian';
+    protected _bandPosition: number;
+    protected _scaleConfig: IAxisLocationCfg;
+    protected _buildScaleConfig(): void;
+    protected _fieldX: string[];
+    get fieldX(): string[];
+    setFieldX(f: string | string[]): void;
+    protected _fieldY: string[];
+    get fieldY(): string[];
+    setFieldY(f: string | string[]): void;
+    protected _fieldZ?: string[];
+    get fieldZ(): string[] | undefined;
+    setFieldZ(f?: string | string[]): void;
+    protected _fieldX2: string;
+    get fieldX2(): string;
+    setFieldX2(f: string): void;
+    protected _fieldY2: string;
+    get fieldY2(): string;
+    setFieldY2(f: string): void;
+    protected _specXField: string[];
+    protected _specYField: string[];
+    protected _direction: DirectionType;
+    get direction(): "vertical" | "horizontal";
+    protected _scaleX: IBaseScale;
+    get scaleX(): IBaseScale;
+    setScaleX(s: IBaseScale): void;
+    protected _scaleY: IBaseScale;
+    get scaleY(): IBaseScale;
+    setScaleY(s: IBaseScale): void;
+    protected _scaleZ?: IBaseScale;
+    get scaleZ(): IBaseScale;
+    setScaleZ(s: IBaseScale): void;
+    _xAxisHelper: IAxisHelper;
+    getXAxisHelper(): IAxisHelper;
+    setXAxisHelper(h: IAxisHelper): void;
+    _yAxisHelper: IAxisHelper;
+    getYAxisHelper(): IAxisHelper;
+    setYAxisHelper(h: IAxisHelper): void;
+    _zAxisHelper?: IAxisHelper;
+    getZAxisHelper(): IAxisHelper;
+    setZAxisHelper(h: IAxisHelper): void;
+    protected _sortDataByAxis: boolean;
+    get sortDataByAxis(): boolean;
+    getStatisticFields(): {
+        key: string;
+        operations: StatisticOperations;
+    }[];
+    getGroupFields(): string[];
+    getStackGroupFields(): string[];
+    getStackValue(): StringOrNumber;
+    getStackValueField(): string;
+    setValueFieldToStack(): void;
+    setValueFieldToPercent(): void;
+    setValueFieldToStackOffsetSilhouette(): void;
+    onXAxisHelperUpdate(): void;
+    onYAxisHelperUpdate(): void;
+    onZAxisHelperUpdate(): void;
+    setAttrFromSpec(): void;
+    dataToPosition(datum: Datum): IPoint | null;
+    protected _buildMarkAttributeContext(): void;
+    valueToPosition(xValue: StringOrNumber | StringOrNumber[], yValue: StringOrNumber | StringOrNumber[]): {
+        x: number;
+        y: number;
+    };
+    protected _axisPosition(helper: IAxisHelper, value: StringOrNumber | StringOrNumber[], datum?: any): number;
+    valueToPositionX(value: StringOrNumber | StringOrNumber[], datum?: any): number;
+    valueToPositionY(value: StringOrNumber | StringOrNumber[], datum?: any): number;
+    protected _dataToPosition(datum: Datum, axisHelper: IAxisHelper, field: string[], scaleDepth: number | undefined, getEncoder: () => (datum: Datum) => number, setEncoder: (encoder: (datum: Datum) => number) => void): number;
+    protected _positionXEncoder?: (datum: Datum) => number;
+    protected _getPositionXEncoder: () => (datum: Datum) => number;
+    protected _setPositionXEncoder: (encoder: (datum: Datum) => number) => void;
+    dataToPositionX(datum: Datum): number;
+    protected _positionYEncoder?: (datum: Datum) => number;
+    protected _getPositionYEncoder: () => (datum: Datum) => number;
+    protected _setPositionYEncoder: (encoder: (datum: Datum) => number) => void;
+    dataToPositionY(datum: Datum): number;
+    dataToPositionZ(datum: Datum): number;
+    dataToPositionX1(datum: Datum): number;
+    dataToPositionY1(datum: Datum): number;
+    positionToData(p: IPoint): IPoint | null;
+    positionToDataX(xPos: number): any | null;
+    positionToDataY(yPos: number): any | null;
+    getRegionRectLeft(): number;
+    getRegionRectRight(): number;
+    afterInitMark(): void;
+    getDimensionField(): string[];
+    getDimensionContinuousField(): string[];
+    getMeasureField(): string[];
+    viewDataUpdate(d: DataView): void;
+    _sortDataInAxisDomain(): void;
+    protected _getInvalidDefined: (datum: Datum) => boolean;
+    reInit(spec: T): void;
+}

package/types/series/cartesian/index.d.ts

@@ -0,0 +1,2 @@
+export * from './cartesian';
+export * from './interface';

package/types/series/cartesian/interface.d.ts

@@ -0,0 +1,15 @@
+import type { ISeriesSpec } from '../../typings/spec/common';
+import type { DirectionType } from '../../typings';
+import type { ILabelSpec } from '../../component/label';
+export interface ICartesianSeriesSpec extends ISeriesSpec {
+    direction?: DirectionType;
+    xField?: string | string[];
+    x2Field?: string;
+    yField?: string | string[];
+    y2Field?: string;
+    zField?: string | string[];
+    sortDataByAxis?: boolean;
+}
+export interface ICartesianSeriesTheme {
+    label?: Partial<ILabelSpec>;
+}

package/types/series/circle-packing/animation.d.ts

@@ -0,0 +1,5 @@
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+export type CirclePackingMark = 'leaf' | 'nonLeaf' | 'label' | 'nonLeafLabel';
+export type CirclePackingAppearPreset = 'growIn' | 'fadeIn';
+export declare const circlePackingPresetAnimation: (preset: CirclePackingAppearPreset) => IAnimationTypeConfig;
+export declare const registerCirclePackingAnimation: () => void;

package/types/series/circle-packing/circle-packing.d.ts

@@ -0,0 +1,45 @@
+import type { ICirclePackingSeriesSpec } from './interface';
+import type { Datum } from '../../typings';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import { CartesianSeries } from '../cartesian/cartesian';
+import type { IMark } from '../../mark/interface';
+export declare class CirclePackingSeries<T extends ICirclePackingSeriesSpec = ICirclePackingSeriesSpec> extends CartesianSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _categoryField: string;
+    protected _valueField: string;
+    private _layoutPadding;
+    private _circlePacking;
+    private _label;
+    private _circlePackingMark;
+    private _labelMark;
+    private _drill?;
+    setCategoryField(f: string): string;
+    getCategoryField(): string;
+    setValueField(f: string): string;
+    getValueField(): string;
+    getDimensionField(): string[];
+    getMeasureField(): string[];
+    setAttrFromSpec(): void;
+    protected initData(): void;
+    protected _addDataIndexAndKey(): void;
+    initMark(): void;
+    initMarkStyle(): void;
+    private _initCirclePackingMark;
+    private _initCirclePackingMarkStyle;
+    private _initLabelMark;
+    private _initLabelMarkStyle;
+    getStatisticFields(): {
+        key: string;
+        operations: import("../../data/transforms/dimension-statistics").StatisticOperations;
+    }[];
+    protected initTooltip(): void;
+    initAnimation(): void;
+    initEvent(): void;
+    onLayoutEnd(ctx: any): void;
+    protected _noAnimationDataKey(datum: Datum, index: number): unknown | undefined;
+    getActiveMarks(): IMark[];
+}
+export declare const registerCirclePackingSeries: () => void;

package/types/series/circle-packing/constant.d.ts

@@ -0,0 +1,2 @@
+import type { SeriesMarkMap } from '../interface/common';
+export declare const circlePackingSeriesMark: SeriesMarkMap;

package/types/series/circle-packing/interface.d.ts

@@ -0,0 +1,20 @@
+import type { IAnimationSpec } from '../../animation/spec';
+import type { IArcMarkSpec, ITextMarkSpec, IMarkSpec, IMarkTheme, ISeriesSpec } from '../../typings';
+import type { SeriesMarkNameEnum } from '../interface/type';
+import type { IPolarSeriesTheme } from '../polar/interface';
+import type { CirclePackingAppearPreset, CirclePackingMark } from './animation';
+export interface ICirclePackingSeriesSpec extends ISeriesSpec, IAnimationSpec<CirclePackingMark, CirclePackingAppearPreset> {
+    type: 'circlePacking';
+    categoryField: string;
+    valueField: string;
+    layoutPadding?: number | number[];
+    [SeriesMarkNameEnum.label]?: IMarkSpec<ITextMarkSpec>;
+    [SeriesMarkNameEnum.circlePacking]?: IMarkSpec<IArcMarkSpec>;
+    drill?: boolean;
+    drillField?: string;
+}
+export interface ICirclePackingSeriesTheme extends Omit<IPolarSeriesTheme, 'label'> {
+    layoutPadding?: number | number[];
+    [SeriesMarkNameEnum.label]?: IMarkTheme<ITextMarkSpec>;
+    [SeriesMarkNameEnum.circlePacking]?: IMarkTheme<IArcMarkSpec>;
+}

package/types/series/circle-packing/tooltip-helper.d.ts

@@ -0,0 +1,5 @@
+import type { Datum } from '../../typings';
+import { BaseSeriesTooltipHelper } from '../base/tooltip-helper';
+export declare class CirclePackingTooltipHelper extends BaseSeriesTooltipHelper {
+    contentKeyCallback: (datum: Datum) => any;
+}

package/types/series/correlation/animation.d.ts

@@ -0,0 +1,8 @@
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+export type CorrelationMarks = 'point' | 'label';
+export type CorrelationAppearPreset = 'scaleIn' | 'fadeIn';
+export interface ICorrelationAnimationParams {
+    [key: string]: object;
+}
+export declare const correlationPresetAnimation: (_params: ICorrelationAnimationParams, preset: CorrelationAppearPreset) => IAnimationTypeConfig;
+export declare const registerCorrelationAnimation: () => void;

package/types/series/correlation/constant.d.ts

@@ -0,0 +1,2 @@
+import type { SeriesMarkMap } from '../interface/common';
+export declare const correlationSeriesMark: SeriesMarkMap;

package/types/series/correlation/correlation-transformer.d.ts

@@ -0,0 +1,5 @@
+import { BaseSeriesSpecTransformer } from '../base';
+import type { ICorrelationSeriesSpec, ICorrelationSeriesTheme } from './interface';
+export declare class CorrelationSeriesSpecTransformer<T extends ICorrelationSeriesSpec = ICorrelationSeriesSpec, K extends ICorrelationSeriesTheme = ICorrelationSeriesTheme> extends BaseSeriesSpecTransformer<T, K> {
+    protected _transformLabelSpec(spec: T): void;
+}