@visactor/vchart-types 0.10.0-alpha.2

package/types/plugin/components/tooltip-handler/interface/index.d.ts

@@ -0,0 +1,2 @@
+export * from './style';
+export * from './common';

package/types/plugin/components/tooltip-handler/interface/style.d.ts

@@ -0,0 +1,13 @@
+import type { TooltipAttributes } from '@visactor/vrender-components';
+import type { ITextAttribute, IFillStyle, RichTextWordBreak } from '@visactor/vrender-core';
+export interface ITooltipTextStyle extends Partial<ITextAttribute & IFillStyle> {
+    spacing?: number;
+    multiLine?: boolean;
+    maxWidth?: number;
+    wordBreak?: RichTextWordBreak;
+    autoWidth?: boolean;
+}
+export interface ITooltipAttributes extends TooltipAttributes {
+    panelDomHeight?: number;
+    maxContentHeight?: number;
+}

package/types/plugin/components/tooltip-handler/utils/attribute.d.ts

@@ -0,0 +1,8 @@
+import type { TooltipPanelAttrs } from '@visactor/vrender-components';
+import type { IToolTipActual } from '../../../../typings';
+import type { ITooltipAttributes, ITooltipTextStyle } from '../interface';
+import type { ITheme } from '../../../../theme';
+import type { ITooltipSpec, ITooltipTextTheme, ITooltipTheme } from '../../../../component/tooltip';
+export declare function getTextAttributes(style?: ITooltipTextTheme, globalTheme?: ITheme, defaultAttributes?: Partial<ITooltipTextStyle>): ITooltipTextStyle;
+export declare const getPanelAttributes: (style: ITooltipTheme['panel']) => TooltipPanelAttrs;
+export declare const getTooltipAttributes: (actualTooltip: IToolTipActual, spec: ITooltipSpec, globalTheme: ITheme) => ITooltipAttributes;

package/types/plugin/components/tooltip-handler/utils/common.d.ts

@@ -0,0 +1,20 @@
+import type { Datum } from '@visactor/vgrammar-core';
+import type { IToolTipLinePattern, ITooltipPattern, MaybeArray, TooltipContentProperty, TooltipData, TooltipPatternProperty } from '../../../../typings';
+import type { ITooltipTextStyle } from '../interface/style';
+import type { TooltipRichTextAttrs } from '@visactor/vrender-components';
+import type { TooltipHandlerParams } from '../../../../component/tooltip';
+export declare function escapeHTML(value: any): string;
+export declare const getTooltipContentValue: <T>(field?: TooltipContentProperty<T>, datum?: any, params?: TooltipHandlerParams) => T;
+export declare const getTooltipPatternValue: <T>(field?: TooltipPatternProperty<T>, data?: TooltipData, params?: TooltipHandlerParams) => T;
+export declare const getTooltipContentPattern: (field?: ITooltipPattern['content'], data?: TooltipData, params?: TooltipHandlerParams) => Array<IToolTipLinePattern> | undefined;
+export declare function getFirstDatumFromTooltipData(data: TooltipData): Datum;
+export declare function pickFirstValidValue<T>(isValid: (element?: T) => any, ...elements: T[]): T | undefined;
+export declare function convertToColorString(color: any, defaultColor?: string): string;
+export declare const getScale: (element: HTMLElement, boundingClientRect?: DOMRect) => number;
+interface ITooltipTextInfo {
+    width: number;
+    height: number;
+    text: MaybeArray<number> | MaybeArray<string> | TooltipRichTextAttrs;
+}
+export declare const measureTooltipText: (text: string | TooltipRichTextAttrs, style: ITooltipTextStyle) => ITooltipTextInfo;
+export {};

package/types/plugin/components/tooltip-handler/utils/compose.d.ts

@@ -0,0 +1,4 @@
+import type { IToolTipLinePattern, ITooltipPattern, TooltipData, IToolTipLineActual } from '../../../../typings/tooltip';
+import type { TooltipActualTitleContent, TooltipHandlerParams } from '../../../../component/tooltip';
+export declare const getShowContent: (pattern: ITooltipPattern, data: TooltipData, params: TooltipHandlerParams) => TooltipActualTitleContent | null;
+export declare const getOneLineData: (datum: any, config: IToolTipLinePattern, params: TooltipHandlerParams) => IToolTipLineActual;

package/types/plugin/components/tooltip-handler/utils/get-spec.d.ts

@@ -0,0 +1,5 @@
+import type { TooltipActiveType } from '../../../../typings';
+import type { ISeries } from '../../../../series/interface';
+import type { IDimensionInfo } from '../../../../event/events/dimension/interface';
+import type { ITooltipSpec } from '../../../../component/tooltip';
+export declare const getTooltipSpecForShow: (activeType: TooltipActiveType, globalSpec: ITooltipSpec, series?: ISeries, dimensionInfo?: IDimensionInfo[]) => ITooltipSpec;

package/types/plugin/components/tooltip-handler/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from './common';
+export * from './compose';
+export * from './pattern';
+export * from './get-spec';
+export * from './position';
+export * from './attribute';

package/types/plugin/components/tooltip-handler/utils/pattern.d.ts

@@ -0,0 +1,4 @@
+import type { IDimensionInfo } from '../../../../event/events/dimension/interface';
+import type { ISeries } from '../../../../series/interface';
+import type { ITooltipPattern, TooltipActiveType } from '../../../../typings';
+export declare const makeDefaultPattern: (series: ISeries, activeType: TooltipActiveType, dimensionInfo?: IDimensionInfo[]) => ITooltipPattern | null;

package/types/plugin/components/tooltip-handler/utils/position.d.ts

@@ -0,0 +1,7 @@
+import { TooltipFixedPosition } from '../../../../typings/tooltip/position';
+export declare const getActualTooltipPositionValue: (position: number | ((event: MouseEvent) => number), event: MouseEvent) => number;
+export type TooltipHorizontalPositionType = 'left' | 'right' | 'middle';
+export type TooltipVerticalPositionType = 'top' | 'bottom' | 'middle';
+export declare const positionType: Record<TooltipFixedPosition, [TooltipHorizontalPositionType, TooltipVerticalPositionType]>;
+export declare const getHorizontalPositionType: (position: TooltipFixedPosition, defaultCase?: TooltipHorizontalPositionType) => TooltipHorizontalPositionType;
+export declare const getVerticalPositionType: (position: TooltipFixedPosition, defaultCase?: TooltipVerticalPositionType) => TooltipVerticalPositionType;

package/types/plugin/index.d.ts

@@ -0,0 +1 @@
+export * from './chart';

package/types/plugin/interface.d.ts

@@ -0,0 +1,4 @@
+import type { IChartPlugin, IChartPluginConstructor } from './chart/interface';
+import type { ISeriesPlugin, ISeriesPluginConstructor } from './series/interface';
+export type IPlugin = IChartPlugin | ISeriesPlugin;
+export type IPluginConstructor = IChartPluginConstructor | ISeriesPluginConstructor;

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

@@ -0,0 +1,9 @@
+import type { ISeries } from '../../series/interface';
+export interface ISeriesPlugin {
+    afterSeriesDataInit?: (series: ISeries) => void;
+    afterSeriesMarkInit?: (series: ISeries) => void;
+}
+export interface ISeriesPluginConstructor {
+    readonly type: 'seriesPlugin';
+    new (): ISeriesPlugin;
+}

package/types/region/index.d.ts

@@ -0,0 +1,3 @@
+export * from './interface';
+export * from './region';
+export * from './region-transformer';

package/types/region/interface.d.ts

@@ -0,0 +1,66 @@
+import type { IMark } from '../mark/interface';
+import type { ILayoutModel, IModelConstructor, IModelOption, IModelSpecInfo } from '../model/interface';
+import type { ISeries, SeriesType } from '../series/interface';
+import type { CoordinateType } from '../typings/coordinate';
+import type { IInteraction } from '../interaction/interface';
+import type { IProjectionSpec } from '../component/geo/interface';
+import type { ConvertToMarkStyleSpec, IRectMarkSpec } from '../typings/visual';
+import type { IAnimate } from '../animation/interface';
+import type { IGroupMark } from '../mark/group';
+import type { StringOrNumber } from '../typings';
+import type { ILayoutItemSpec } from '../layout/interface';
+export interface IRegion extends ILayoutModel {
+    animate?: IAnimate;
+    interaction: IInteraction;
+    getStackInverse: () => boolean;
+    getMaxWidth: () => number | undefined;
+    setMaxWidth: (value: number) => void;
+    getMaxHeight: () => number | undefined;
+    setMaxHeight: (value: number) => void;
+    addSeries: (series: ISeries) => void;
+    removeSeries: (series: ISeries) => void;
+    getSeries: (opt?: ISeriesFilter) => ISeries[];
+    getSeriesInName: (name: string) => ISeries;
+    getSeriesInUserId: (userId: string) => ISeries;
+    getSeriesInId: (id: number) => ISeries;
+    getSeriesInType: (type: SeriesType) => ISeries[];
+    getSeriesInCoordinateType: (type: CoordinateType) => ISeries[];
+    getSeriesInDataName: (dataName: string) => ISeries[];
+    getMarks: () => IMark[];
+    getGroupMark: () => IGroupMark;
+    getInteractionMark: () => IGroupMark;
+    getSpecInfo: () => IRegionSpecInfo;
+}
+export type ISeriesFilter = {
+    name?: string;
+    userId?: StringOrNumber | StringOrNumber[];
+    specIndex?: number | number[];
+    id?: number;
+    type?: string;
+    coordinateType?: CoordinateType;
+    dataName?: string;
+};
+export interface IRegionConstructor extends IModelConstructor {
+    new (spec: IRegionSpec, ctx: IModelOption): IRegion;
+}
+export interface IRegionSpec extends ILayoutItemSpec {
+    id?: StringOrNumber;
+    coordinate?: CoordinateType;
+    style?: ConvertToMarkStyleSpec<IRectMarkSpec>;
+    stackInverse?: boolean;
+}
+export interface IGeoRegionSpec extends IRegionSpec {
+    coordinate?: 'geo';
+    roam?: boolean;
+    longitudeField?: string;
+    latitudeField?: string;
+    projection?: Partial<Omit<IProjectionSpec, 'name'>>;
+    zoomLimit?: {
+        min?: number;
+        max?: number;
+    };
+}
+export interface IRegionSpecInfo<T extends IRegionSpec = IRegionSpec> extends IModelSpecInfo {
+    type: 'region';
+    spec: T;
+}

package/types/region/region-transformer.d.ts

@@ -0,0 +1,8 @@
+import { BaseModelSpecTransformer } from '../model/base-model-transformer';
+import type { IRegionSpec } from './interface';
+export declare class RegionSpecTransformer<T extends IRegionSpec = IRegionSpec, K extends Partial<IRegionSpec> = Partial<IRegionSpec>> extends BaseModelSpecTransformer<T, K> {
+    protected _initTheme(spec: T, chartSpec: any): {
+        spec: T;
+        theme: K;
+    };
+}

package/types/region/region.d.ts

@@ -0,0 +1,88 @@
+import type { IGroupMark as IVGrammarGroupMark } from '@visactor/vgrammar-core';
+import type { ISeries } from '../series/interface';
+import type { IModelOption } from '../model/interface';
+import type { CoordinateType } from '../typings/coordinate';
+import type { IRegion, IRegionSpec, IRegionSpecInfo } from './interface';
+import type { IGroupMark } from '../mark/group';
+import type { IInteraction, ITrigger } from '../interaction/interface';
+import type { IRectMark } from '../mark/rect';
+import type { IAnimate } from '../animation/interface';
+import type { ILayoutType, StringOrNumber } from '../typings';
+import { LayoutModel } from '../model/layout-model';
+import { RegionSpecTransformer } from './region-transformer';
+export declare class Region<T extends IRegionSpec = IRegionSpec> extends LayoutModel<T> implements IRegion {
+    static type: string;
+    static readonly transformerConstructor: typeof RegionSpecTransformer;
+    readonly transformerConstructor: any;
+    readonly modelType: string;
+    static specKey: string;
+    specKey: string;
+    type: string;
+    protected _series: ISeries[];
+    layoutType: ILayoutType;
+    layoutZIndex: number;
+    animate?: IAnimate;
+    interaction: IInteraction;
+    getSpecInfo: () => IRegionSpecInfo;
+    getMaxWidth(): number;
+    setMaxWidth(value: number): void;
+    getMaxHeight(): number;
+    setMaxHeight(value: number): void;
+    protected _groupMark: IGroupMark;
+    getGroupMark(): IGroupMark;
+    protected _interactionMark: IGroupMark;
+    getInteractionMark(): IGroupMark;
+    getStackInverse(): boolean;
+    protected _backgroundMark?: IRectMark;
+    protected _foregroundMark?: IRectMark;
+    protected _trigger: ITrigger;
+    constructor(spec: T, ctx: IModelOption);
+    protected _getClipDefaultValue(): boolean;
+    created(): void;
+    private _createGroupMark;
+    init(option: any): void;
+    initMark(): void;
+    protected _initBackgroundMarkStyle(): void;
+    protected _initForegroundMarkStyle(): void;
+    _compareSpec(spec: T, prevSpec: T): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    reInit(spec?: T): void;
+    addSeries(s: ISeries): void;
+    removeSeries(s: ISeries): void;
+    getSeries(opt?: {
+        name?: string;
+        userId?: StringOrNumber | StringOrNumber[];
+        specIndex?: number | number[];
+        id?: StringOrNumber;
+        type?: string;
+        coordinateType?: CoordinateType;
+        dataName?: string;
+    }): ISeries[];
+    getSeriesInName(name: string): ISeries;
+    getSeriesInUserId(userId: string): ISeries;
+    getSeriesInId(id: number): ISeries;
+    getSeriesInType(type: string): ISeries[];
+    getSeriesInCoordinateType(coordinateType: CoordinateType): ISeries[];
+    getSeriesInDataName(dataName: string): ISeries[];
+    onRender(ctx: any): void;
+    initSeriesDataflow(): void;
+    seriesDataFilterOver: () => void;
+    release(): void;
+    createTrigger(): void;
+    initTrigger(): void;
+    initInteraction(): void;
+    compileMarks(group?: string | IVGrammarGroupMark): void;
+    compile(): void;
+    getBoundsInRect: () => {
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+    };
+    onLayoutEnd(ctx: any): void;
+}

package/types/scale/color-ordinal-scale.d.ts

@@ -0,0 +1,8 @@
+import { OrdinalScale } from '@visactor/vscale';
+import type { ColorSchemeItem, ProgressiveDataScheme } from '../theme/color-scheme/interface';
+export declare class ColorOrdinalScale extends OrdinalScale {
+    protected _range: Array<ColorSchemeItem> | ProgressiveDataScheme<ColorSchemeItem>;
+    range(value?: Array<ColorSchemeItem> | ProgressiveDataScheme<ColorSchemeItem>): this | any;
+    domain(value?: any[]): this | any;
+    protected _resetRange(): void;
+}

package/types/scale/global-scale.d.ts

@@ -0,0 +1,37 @@
+import type { IGlobalScale } from './interface';
+import type { IBaseScale } from '@visactor/vscale';
+import type { IChart } from '../chart/interface';
+import type { IChartSpec } from '../typings/spec';
+import type { IVisualScale, IVisualSpecScale } from '../typings';
+import type { StatisticOperations } from '../data/transforms/dimension-statistics';
+export declare class GlobalScale implements IGlobalScale {
+    private _scaleSpecMap;
+    private _scaleMap;
+    private _modelScaleSpecMap;
+    private _markAttributeScaleMap;
+    private _spec;
+    private readonly _chart;
+    constructor(spec: IChartSpec['scales'], chart: IChart);
+    private _createFromSpec;
+    private _setAttrFromSpec;
+    updateSpec(spec: IChartSpec['scales']): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    registerModelScale(spec: IVisualSpecScale<unknown, unknown>): void;
+    removeModelScale(filter: (spec: IVisualSpecScale<unknown, unknown>) => boolean): void;
+    getScale(user_id: string): IBaseScale | null;
+    getScaleSpec(user_id: string): IVisualSpecScale<unknown, unknown> | null;
+    getStatisticalFields: (dataId: string) => {
+        key: string;
+        operations: StatisticOperations;
+    }[];
+    private _getSeriesByRawDataId;
+    private _getSeriesBySeriesId;
+    updateScaleDomain(defaultDomain: unknown[]): void;
+    private _updateMarkScale;
+    registerMarkAttributeScale(spec: IVisualScale, seriesId: number): IBaseScale;
+}

package/types/scale/interface.d.ts

@@ -0,0 +1,18 @@
+import type { IBaseScale } from '@visactor/vscale';
+import type { StatisticOperations } from '../data/transforms/dimension-statistics';
+import type { IChartSpec, IVisualScale, IVisualSpecScale } from '../typings';
+import type { IUpdateSpecResult } from '../model/interface';
+export interface IGlobalScale {
+    color?: any;
+    getScale: (user_id: string) => IBaseScale | null;
+    getScaleSpec: (user_id: string) => IVisualSpecScale<unknown, unknown> | null;
+    getStatisticalFields: (dataId: string) => {
+        key: string;
+        operations: StatisticOperations;
+    }[];
+    updateScaleDomain: (string: unknown[]) => void;
+    registerMarkAttributeScale: (spec: IVisualScale, seriesId: number) => IBaseScale;
+    registerModelScale: (spec: IVisualSpecScale<unknown, unknown>) => void;
+    removeModelScale: (filter: (spec: IVisualSpecScale<unknown, unknown>) => boolean) => void;
+    updateSpec: (spec: IChartSpec['scales']) => IUpdateSpecResult;
+}

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

@@ -0,0 +1,8 @@
+import type { DirectionType } from '../../typings';
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+export interface IAreaAnimationParams {
+    direction: DirectionType;
+}
+export type AreaAppearPreset = 'clipIn' | 'fadeIn' | 'grow';
+export declare function areaPresetAnimation(params: IAreaAnimationParams, preset: AreaAppearPreset | boolean): IAnimationTypeConfig;
+export declare const registerAreaAnimation: () => void;

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

@@ -0,0 +1,7 @@
+import type { IChartSpecInfo } from '../../chart/interface';
+import { LineLikeSeriesSpecTransformer } from '../mixin/line-mixin-transformer';
+import type { IAreaSeriesSpec, IAreaSeriesTheme } from './interface';
+export declare class AreaSeriesSpecTransformer<T extends IAreaSeriesSpec = IAreaSeriesSpec, K extends IAreaSeriesTheme = IAreaSeriesTheme> extends LineLikeSeriesSpecTransformer<T, K> {
+    protected _transformLabelSpec(spec: T): void;
+    protected _transformSpecAfterMergingTheme(spec: T, chartSpec: any, chartSpecInfo?: IChartSpecInfo): void;
+}

package/types/series/area/area.d.ts

@@ -0,0 +1,33 @@
+import type { DataView } from '@visactor/vdataset';
+import { LineLikeSeriesMixin } from '../mixin/line-mixin';
+import type { IAreaMark } from '../../mark/area';
+import { CartesianSeries } from '../cartesian/cartesian';
+import type { Datum } from '../../typings';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { IAreaSeriesSpec } from './interface';
+import type { IMark } from '../../mark/interface';
+import { AreaSeriesSpecTransformer } from './area-transformer';
+export interface AreaSeries<T extends IAreaSeriesSpec = IAreaSeriesSpec> extends Pick<LineLikeSeriesMixin, 'initLineMark' | 'initSymbolMark' | 'initLabelMarkStyle' | 'initLineMarkStyle' | 'initSymbolMarkStyle' | 'encodeDefined' | '_lineMark' | '_symbolMark' | 'addSamplingCompile' | 'addOverlapCompile' | 'reCompileSampling' | 'initLineLabelMarkStyle'>, CartesianSeries<T> {
+}
+export declare class AreaSeries<T extends IAreaSeriesSpec = IAreaSeriesSpec> extends CartesianSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    static readonly transformerConstructor: any;
+    readonly transformerConstructor: typeof AreaSeriesSpecTransformer;
+    protected _areaMark: IAreaMark;
+    protected _supportStack: boolean;
+    protected _sortDataByAxis: boolean;
+    initMark(): void;
+    initMarkStyle(): void;
+    initAnimation(): void;
+    protected initTooltip(): void;
+    viewDataStatisticsUpdate(d: DataView): void;
+    compile(): void;
+    getDefaultShapeType(): string;
+    getActiveMarks(): IMark[];
+    onLayoutEnd(ctx: any): void;
+    getSeriesStyle(datum: Datum): (attribute: string) => any;
+}
+export declare const registerAreaSeries: () => void;

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

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

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

@@ -0,0 +1,26 @@
+import type { ICartesianSeriesSpec } from '../cartesian/interface';
+import type { IMarkSpec, IMarkTheme } from '../../typings/spec/common';
+import type { ISymbolMarkSpec, ILineMarkSpec, IAreaMarkSpec } from '../../typings/visual';
+import type { SeriesMarkNameEnum } from '../interface/type';
+import type { ILineLikeLabelSpec, ILineLikeSeriesTheme } from '../mixin/line-mixin';
+import type { IAnimationSpec } from '../../animation/spec';
+import type { AreaAppearPreset } from './animation';
+import type { IDataSamping, IMarkOverlap, IMarkProgressiveConfig } from '../../mark/interface';
+import type { ILabelSpec } from '../../component';
+export interface IAreaSeriesSpec extends ICartesianSeriesSpec, IAnimationSpec<string, AreaAppearPreset>, IMarkProgressiveConfig, IDataSamping, IMarkOverlap {
+    type: 'area';
+    xField?: string | string[];
+    yField?: string | string[];
+    [SeriesMarkNameEnum.point]?: IMarkSpec<ISymbolMarkSpec>;
+    [SeriesMarkNameEnum.line]?: IMarkSpec<ILineMarkSpec>;
+    [SeriesMarkNameEnum.area]?: IMarkSpec<IAreaMarkSpec>;
+    [SeriesMarkNameEnum.label]?: ILineLikeLabelSpec;
+    [SeriesMarkNameEnum.areaLabel]?: Omit<ILabelSpec, 'position'> & {
+        position?: 'start' | 'end';
+    };
+    seriesMark?: 'point' | 'line' | 'area';
+    activePoint?: boolean;
+}
+export interface IAreaSeriesTheme extends ILineLikeSeriesTheme {
+    [SeriesMarkNameEnum.area]?: Partial<IMarkTheme<IAreaMarkSpec>>;
+}

package/types/series/area/tooltip-helpter.d.ts

@@ -0,0 +1,5 @@
+import type { ISeriesTooltipHelper } from '../interface';
+import { BaseSeriesTooltipHelper } from '../base/tooltip-helper';
+export declare class AreaSeriesTooltipHelper extends BaseSeriesTooltipHelper implements ISeriesTooltipHelper {
+    protected _getSeriesStyle: (datum: any, styleKey: string | string[], defaultValue?: any) => any;
+}

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

@@ -0,0 +1,14 @@
+import type { DirectionType } from '../../typings';
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+export interface IBarAnimationParams {
+    xField: string;
+    yField: string;
+    direction: DirectionType;
+    growFrom: () => number;
+}
+export type BarAppearPreset = 'grow' | 'fadeIn' | 'scaleIn';
+export declare const barGrowIn: (params: IBarAnimationParams, isOverall?: boolean) => IAnimationTypeConfig;
+export declare const barGrowOut: (params: IBarAnimationParams, isOverall?: boolean) => IAnimationTypeConfig;
+export declare function barPresetAnimation(params: IBarAnimationParams, preset: BarAppearPreset | boolean): IAnimationTypeConfig;
+export declare const registerBarAnimation: () => void;
+export declare const registerBar3dAnimation: () => void;

package/types/series/bar/bar-3d.d.ts

@@ -0,0 +1,14 @@
+import { MarkTypeEnum } from '../../mark/interface/type';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum, SeriesMarkNameEnum } from '../interface/type';
+import { BarSeries } from './bar';
+import type { IBar3dSeriesSpec } from './interface';
+import type { AdaptiveSpec } from '../../typings';
+export declare class Bar3dSeries<T extends IBar3dSeriesSpec = IBar3dSeriesSpec> extends BarSeries<AdaptiveSpec<T, 'type'>> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _barMarkName: SeriesMarkNameEnum;
+    protected _barMarkType: MarkTypeEnum;
+}
+export declare const registerBar3dSeries: () => void;

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

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

package/types/series/bar/bar.d.ts

@@ -0,0 +1,67 @@
+import { CartesianSeries } from '../cartesian/cartesian';
+import type { IMark, IMarkProgressiveConfig } from '../../mark/interface';
+import { MarkTypeEnum } from '../../mark/interface/type';
+import type { Datum, DirectionType } from '../../typings';
+import type { IBarSeriesSpec } from './interface';
+import type { IAxisHelper } from '../../component/axis/cartesian/interface';
+import type { IRectMark } from '../../mark/rect';
+import type { IModelInitOption } from '../../model/interface';
+import type { ITextMark } from '../../mark/text';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesMarkNameEnum, SeriesTypeEnum } from '../interface/type';
+import { SeriesData } from '../base/series-data';
+import { DataView } from '@visactor/vdataset';
+import { BarSeriesSpecTransformer } from './bar-transformer';
+export declare const DefaultBandWidth = 6;
+export declare class BarSeries<T extends IBarSeriesSpec = IBarSeriesSpec> extends CartesianSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    protected _barMarkName: SeriesMarkNameEnum;
+    protected _barMarkType: MarkTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    static readonly transformerConstructor: any;
+    readonly transformerConstructor: typeof BarSeriesSpecTransformer;
+    protected _supportStack: boolean;
+    protected _bandPosition: number;
+    protected _barMark: IRectMark;
+    protected _barBackgroundMark: IRectMark;
+    protected _barBackgroundViewData: SeriesData;
+    initMark(): void;
+    protected _initBarBackgroundMark(progressive?: IMarkProgressiveConfig): void;
+    initMarkStyle(): void;
+    initLabelMarkStyle(textMark: ITextMark): void;
+    protected initTooltip(): void;
+    protected _statisticViewData(): void;
+    init(option: IModelInitOption): void;
+    private _shouldDoPreCalculate;
+    private _calculateStackRectPosition;
+    private _calculateRectPosition;
+    protected _dataToPosX(datum: Datum): number;
+    protected _dataToPosX1(datum: Datum): number;
+    protected _dataToPosY(datum: Datum): number;
+    protected _dataToPosY1(datum: Datum): number;
+    initBandRectMarkStyle(): void;
+    protected _initBandBarBackgroundMarkStyle(): void;
+    initLinearRectMarkStyle(): void;
+    protected _initLinearBarBackgroundMarkStyle(): void;
+    initAnimation(): void;
+    protected _getBarWidth(axisHelper: IAxisHelper, scaleDepth?: number): number;
+    protected _getPosition(direction: DirectionType, datum: Datum, scaleDepth?: number, mark?: SeriesMarkNameEnum): number;
+    protected _barBackgroundPositionXEncoder?: (datum: Datum) => number;
+    protected _getBarBackgroundPositionXEncoder: () => (datum: Datum) => number;
+    protected _setBarBackgroundPositionXEncoder: (encoder: (datum: Datum) => number) => void;
+    dataToBarBackgroundPositionX(datum: Datum, scaleDepth?: number): number;
+    protected _barBackgroundPositionYEncoder?: (datum: Datum) => number;
+    protected _getBarBackgroundPositionYEncoder: () => (datum: Datum) => number;
+    protected _setBarBackgroundPositionYEncoder: (encoder: (datum: Datum) => number) => void;
+    dataToBarBackgroundPositionY(datum: Datum, scaleDepth?: number): number;
+    onLayoutEnd(ctx: any): void;
+    compile(): void;
+    getDefaultShapeType(): string;
+    getActiveMarks(): IMark[];
+    compileData(): void;
+    fillData(): void;
+    viewDataUpdate(d: DataView): void;
+    release(): void;
+}
+export declare const registerBarSeries: () => void;

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

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

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

@@ -0,0 +1,42 @@
+import type { ICartesianSeriesSpec, ICartesianSeriesTheme } from '../cartesian/interface';
+import type { IMarkSpec, IMarkTheme } from '../../typings/spec/common';
+import type { IRect3dMarkSpec, IRectMarkSpec } from '../../typings/visual';
+import type { IAnimationSpec } from '../../animation/spec';
+import type { BarAppearPreset } from './animation';
+import type { ILabelSpec } from '../../component/label';
+import type { IDataSamping, IMarkProgressiveConfig } from '../../mark/interface';
+import type { SeriesMarkNameEnum } from '../interface/type';
+import type { Functional } from '@visactor/vrender-components';
+type BarMarks = 'bar';
+export interface IBarSeriesSpec extends ICartesianSeriesSpec, IAnimationSpec<BarMarks, BarAppearPreset>, IMarkProgressiveConfig, IDataSamping {
+    type: 'bar';
+    xField?: string | string[];
+    yField?: string | string[];
+    [SeriesMarkNameEnum.bar]?: IMarkSpec<IRectMarkSpec>;
+    [SeriesMarkNameEnum.barBackground]?: IMarkSpec<IRectMarkSpec> & IBarBackgroundSpec;
+    [SeriesMarkNameEnum.label]?: Omit<ILabelSpec, 'position'> & {
+        position?: Functional<'outside' | 'top' | 'bottom' | 'left' | 'right' | 'inside' | 'inside-top' | 'inside-bottom' | 'inside-right' | 'inside-left' | 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left'>;
+    };
+    barWidth?: number | string;
+    barMinWidth?: number | string;
+    barMaxWidth?: number | string;
+    barGapInGroup?: number | string | (number | string)[];
+    barMinHeight?: number;
+}
+export interface IBarBackgroundSpec {
+    fieldLevel?: number;
+}
+export interface IBarSeriesTheme extends ICartesianSeriesTheme {
+    [SeriesMarkNameEnum.bar]?: Partial<IMarkTheme<IRectMarkSpec>>;
+    [SeriesMarkNameEnum.barBackground]?: Partial<IMarkTheme<IRectMarkSpec>> & IBarBackgroundSpec;
+    barWidth?: number;
+    barMinWidth?: number;
+    barMaxWidth?: number;
+}
+export type IBar3dSeriesSpec = {
+    type: 'bar3d';
+} & Omit<IBarSeriesSpec, 'type'> & ICartesianSeriesSpec & IAnimationSpec<BarMarks, BarAppearPreset>;
+export interface IBar3dSeriesTheme extends ICartesianSeriesTheme {
+    [SeriesMarkNameEnum.bar3d]?: Partial<IMarkTheme<IRect3dMarkSpec>>;
+}
+export {};

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

@@ -0,0 +1,18 @@
+import type { IChartSpecInfo } from '../../chart/interface';
+import type { TransformedLabelSpec } from '../../component/label';
+import type { IBaseModelSpecTransformerResult } from '../../model/interface';
+import { BaseModelSpecTransformer } from '../../model/base-model-transformer';
+import type { ISeriesSpec } from '../../typings';
+import type { SeriesMarkNameEnum } from '../interface';
+import type { ISeries } from '../interface';
+export declare class BaseSeriesSpecTransformer<T extends ISeriesSpec, K> extends BaseModelSpecTransformer<T, K> {
+    markLabelSpec: Partial<Record<SeriesMarkNameEnum, TransformedLabelSpec[]>>;
+    getLabelSpec(markName: string): any;
+    setLabelSpec(markName: string, label: TransformedLabelSpec | TransformedLabelSpec[]): void;
+    addLabelSpec(markName: string, label: TransformedLabelSpec, head?: boolean): void;
+    getTheme(spec: T, chartSpec: any): K;
+    transformSpec(spec: T, chartSpec: any, chartSpecInfo?: IChartSpecInfo): IBaseModelSpecTransformerResult<T, K>;
+    protected _transformLabelSpec(spec: T): void;
+    protected _addMarkLabelSpec<V extends ISeries = ISeries>(spec: T, markName: SeriesMarkNameEnum, labelSpecKey?: keyof T, styleHandlerName?: keyof V, hasAnimation?: boolean, head?: boolean): void;
+    protected _getDefaultSpecFromChart(chartSpec: any): any;
+}