@visactor/vchart-types 1.6.0

package/types/component/axis/cartesian/interface/spec.d.ts

@@ -0,0 +1,45 @@
+import type { IOrientType, IRectMarkSpec, StringOrNumber } from '../../../../typings';
+import type { IBandAxisSpec, ILinearAxisSpec, IGrid, ICommonAxisSpec } from '../../interface';
+import type { ICartesianDomainLine, ICartesianLabel, ITimeLayerType, ICartesianTitle, ICartesianAxisUnit } from './common';
+import type { AxisItemStateStyle } from '@visactor/vrender-components';
+export type ICartesianAxisSpec = ICartesianLinearAxisSpec | ICartesianBandAxisSpec | ICartesianTimeAxisSpec | ICartesianLogAxisSpec | ICartesianSymlogAxisSpec;
+export type ICartesianAxisCommonSpec = ICommonAxisSpec & {
+    orient: IOrientType;
+    grid?: IGrid;
+    subGrid?: IGrid;
+    domainLine?: ICartesianDomainLine;
+    label?: ICartesianLabel;
+    title?: ICartesianTitle;
+    autoIndent?: boolean;
+    background?: {
+        visible: boolean;
+        style?: Partial<IRectMarkSpec>;
+        state?: AxisItemStateStyle<Partial<IRectMarkSpec>>;
+    };
+    mode?: '2d' | '3d';
+    depth?: number;
+    unit?: ICartesianAxisUnit;
+};
+export interface ILinearAxisSync {
+    axisId: StringOrNumber;
+    zeroAlign?: boolean;
+    tickAlign?: boolean;
+}
+export type ICartesianLinearAxisSpec = ICartesianAxisCommonSpec & ILinearAxisSpec & {
+    sync?: ILinearAxisSync;
+};
+export type ICartesianBandAxisSpec = ICartesianAxisCommonSpec & IBandAxisSpec & {
+    bandSize?: number;
+    maxBandSize?: number;
+    minBandSize?: number;
+    autoRegionSize?: boolean;
+};
+export type ICartesianTimeAxisSpec = Omit<ICartesianAxisCommonSpec, 'inverse'> & {
+    layers?: ITimeLayerType[];
+};
+export type ICartesianLogAxisSpec = ICartesianLinearAxisSpec & {
+    base?: number;
+};
+export type ICartesianSymlogAxisSpec = ICartesianLinearAxisSpec & {
+    constant?: number;
+};

package/types/component/axis/cartesian/interface/theme.d.ts

@@ -0,0 +1,22 @@
+import type { ILayoutPaddingSpec, ILayoutNumber } from '../../../../model/interface';
+import type { ITick, IGrid } from '../../interface';
+import type { ICartesianAxisUnit, ICartesianDomainLine, ICartesianLabel, ICartesianTitle } from './common';
+import type { ICartesianAxisCommonSpec } from './spec';
+export interface ICartesianAxisCommonTheme {
+    grid?: IGrid;
+    subGrid?: IGrid;
+    domainLine?: ICartesianDomainLine;
+    label?: ICartesianLabel;
+    title?: ICartesianTitle;
+    tick?: ITick;
+    subTick?: ITick;
+    background?: ICartesianAxisCommonSpec['background'];
+    padding?: ILayoutPaddingSpec;
+    width?: ILayoutNumber;
+    maxWidth?: ILayoutNumber;
+    minWidth?: ILayoutNumber;
+    height?: ILayoutNumber;
+    maxHeight?: ILayoutNumber;
+    minHeight?: ILayoutNumber;
+    unit?: ICartesianAxisUnit;
+}

package/types/component/axis/cartesian/linear-axis.d.ts

@@ -0,0 +1,28 @@
+import type { LogScale } from '@visactor/vscale';
+import { LinearScale } from '@visactor/vscale';
+import { CartesianAxis } from './axis';
+import type { IAxisHelper, ICartesianLinearAxisSpec } from './interface';
+import { ComponentTypeEnum } from '../../interface/type';
+import { LinearAxisMixin } from '../mixin/linear-axis-mixin';
+export interface CartesianLinearAxis<T extends ICartesianLinearAxisSpec = ICartesianLinearAxisSpec> extends Pick<LinearAxisMixin, 'setExtraAttrFromSpec' | 'computeLinearDomain' | 'valueToPosition' | 'setScaleNice' | '_domain' | 'transformScaleDomain' | 'setExtendDomain'>, CartesianAxis<T> {
+}
+export declare class CartesianLinearAxis<T extends ICartesianLinearAxisSpec = ICartesianLinearAxisSpec> extends CartesianAxis<T> {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    protected _zero: boolean;
+    protected _nice: boolean;
+    protected _extend: {
+        [key: string]: number;
+    };
+    protected _scale: LinearScale | LogScale;
+    protected _scales: LinearScale[] | LogScale[];
+    setAttrFromSpec(): void;
+    protected initScales(): void;
+    protected computeDomain(data: {
+        min: number;
+        max: number;
+        values: any[];
+    }[]): number[];
+    protected axisHelper(): IAxisHelper;
+}
+export declare const registerCartesianLinearAxis: () => void;

package/types/component/axis/cartesian/log-axis.d.ts

@@ -0,0 +1,17 @@
+import { CartesianLinearAxis } from './linear-axis';
+import { ComponentTypeEnum } from '../../interface/type';
+import { LinearAxisMixin } from '../mixin/linear-axis-mixin';
+import { LogScale } from '@visactor/vscale';
+import type { ICartesianLogAxisSpec } from './interface';
+export interface CartesianLogAxis<T extends ICartesianLogAxisSpec = ICartesianLogAxisSpec> extends Pick<LinearAxisMixin, 'valueToPosition'>, CartesianLinearAxis<T> {
+}
+export declare class CartesianLogAxis<T extends ICartesianLogAxisSpec = ICartesianLogAxisSpec> extends CartesianLinearAxis<T> {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    protected _zero: boolean;
+    protected _scale: LogScale;
+    protected _scales: LogScale[];
+    protected initScales(): void;
+    transformScaleDomain(): void;
+}
+export declare const registerCartesianLogAxis: () => void;

package/types/component/axis/cartesian/symlog-axis.d.ts

@@ -0,0 +1,17 @@
+import { CartesianLinearAxis } from './linear-axis';
+import { ComponentTypeEnum } from '../../interface/type';
+import { LinearAxisMixin } from '../mixin/linear-axis-mixin';
+import { SymlogScale } from '@visactor/vscale';
+import type { ICartesianSymlogAxisSpec } from './interface';
+export interface CartesianSymlogAxis<T extends ICartesianSymlogAxisSpec = ICartesianSymlogAxisSpec> extends Pick<LinearAxisMixin, 'valueToPosition'>, CartesianLinearAxis<T> {
+}
+export declare class CartesianSymlogAxis<T extends ICartesianSymlogAxisSpec = ICartesianSymlogAxisSpec> extends CartesianLinearAxis<T> {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    protected _zero: boolean;
+    protected _scale: SymlogScale;
+    protected _scales: SymlogScale[];
+    protected initScales(): void;
+    transformScaleDomain(): void;
+}
+export declare const registerCartesianSymlogAxis: () => void;

package/types/component/axis/cartesian/time-axis.d.ts

@@ -0,0 +1,22 @@
+import type { IEffect } from '../../../model/interface';
+import { CartesianLinearAxis } from './linear-axis';
+import { ComponentTypeEnum } from '../../interface/type';
+import { CompilableData } from '../../../compile/data/compilable-data';
+import type { LinearAxisMixin } from '../mixin/linear-axis-mixin';
+import type { ICartesianTimeAxisSpec } from './interface';
+export interface CartesianTimeAxis<T extends ICartesianTimeAxisSpec = ICartesianTimeAxisSpec> extends Pick<LinearAxisMixin, 'valueToPosition'>, CartesianLinearAxis<T> {
+}
+export declare class CartesianTimeAxis<T extends ICartesianTimeAxisSpec = ICartesianTimeAxisSpec> extends CartesianLinearAxis<T> {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    protected _layerTickData: CompilableData;
+    protected _zero: boolean;
+    effect: IEffect;
+    setAttrFromSpec(): void;
+    protected _initData(): void;
+    protected computeData(): void;
+    protected getLabelFormatMethod(): any;
+    protected getLabelItems(length: number): any[];
+    transformScaleDomain(): void;
+}
+export declare const registerCartesianTimeAxis: () => void;

package/types/component/axis/cartesian/util/common.d.ts

@@ -0,0 +1,13 @@
+import type { IOrientType } from '../../../../typings';
+import { Direction } from '../../../../typings/space';
+import type { ICartesianAxisCommonSpec } from '../interface';
+export declare function isXAxis(orient: IOrientType): boolean;
+export declare function isYAxis(orient: IOrientType): boolean;
+export declare function isZAxis(orient: IOrientType): boolean;
+export declare function autoAxisType(orient: IOrientType, isHorizontal: boolean): "linear" | "band";
+export declare function getOrient(spec: ICartesianAxisCommonSpec, whiteList?: string[]): IOrientType;
+export declare function getDirectionByOrient(orient: IOrientType): Direction;
+export declare function isOrientInSameDirection(orient1: IOrientType, orient2: IOrientType): boolean;
+export declare function transformInverse(spec: ICartesianAxisCommonSpec, isHorizontal: boolean): boolean;
+export declare function scaleWholeRangeSize(count: number, bandwidth: number, paddingInner: number, paddingOuter: number): number;
+export declare function bandSpace(count: number, paddingInner: number, paddingOuter: number): number;

package/types/component/axis/cartesian/util/index.d.ts

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

package/types/component/axis/cartesian/util/time.d.ts

@@ -0,0 +1,80 @@
+import type { StringOrNumber } from '../../../../typings';
+export declare class TimeUtil {
+    private locale_shortWeekdays;
+    private locale_periods;
+    private locale_weekdays;
+    private locale_shortMonths;
+    private numberRe;
+    private pads;
+    private requoteRe;
+    private periodRe;
+    private periodLookup;
+    private weekdayRe;
+    private weekdayLookup;
+    private shortWeekdayRe;
+    private shortWeekdayLookup;
+    private monthRe;
+    private monthLookup;
+    private shortMonthRe;
+    private shortMonthLookup;
+    private static instance;
+    static getInstance(): TimeUtil;
+    private requoteF;
+    private constructor();
+    private requote;
+    private localDate;
+    private utcDate;
+    private newDate;
+    private formatRe;
+    private formatLookup;
+    private locale_months;
+    private formatShortWeekday;
+    private formatWeekday;
+    private formatShortMonth;
+    private formatMonth;
+    private pad;
+    private formatDayOfMonth;
+    private formatHour24;
+    private formatHour12;
+    private formatMilliseconds;
+    private formatMonthNumber;
+    private formatMinutes;
+    private formatPeriod;
+    private formatSeconds;
+    private formatFullYear;
+    private formatUTCShortWeekday;
+    private formatUTCWeekday;
+    private formatUTCShortMonth;
+    private formatUTCMonth;
+    private formatUTCDayOfMonth;
+    private formatUTCHour24;
+    private formatUTCHour12;
+    private formatUTCMilliseconds;
+    private formatUTCMonthNumber;
+    private formatUTCMinutes;
+    private formatUTCPeriod;
+    private formatUTCSeconds;
+    private formatUTCFullYear;
+    private formats;
+    private utcFormats;
+    private parseShortWeekday;
+    private parseWeekday;
+    private parseShortMonth;
+    private parseMonth;
+    private parseDayOfMonth;
+    private parseHour24;
+    private parseMilliseconds;
+    private parseMonthNumber;
+    private parseMinutes;
+    private parsePeriod;
+    private parseSeconds;
+    private parseFullYear;
+    private parses;
+    private parseSpecifier;
+    private newParse;
+    private newFormat;
+    private getFullTimeStamp;
+    timeFormat: (specifier: string, timeText: StringOrNumber) => string;
+    timeUTCFormat: (specifier: string, timeText: StringOrNumber) => string;
+    timeParse: (specifier: string, timeText: string | string) => Date;
+}

package/types/component/axis/index.d.ts

@@ -0,0 +1,3 @@
+export * from './interface';
+export * from './cartesian/interface/index';
+export * from './polar/interface/index';

package/types/component/axis/interface/common.d.ts

@@ -0,0 +1,38 @@
+import type { IBaseScale } from '@visactor/vscale';
+import type { Datum, IPolarOrientType, StringOrNumber } from '../../../typings';
+import type { IComponent } from '../../interface/common';
+import type { ICartesianAxisSpec } from '../cartesian/interface';
+import type { ITextGraphicAttribute } from '@visactor/vrender-core';
+export interface StatisticsDomain {
+    domain: any[];
+    index: {
+        [key in StringOrNumber]: number;
+    };
+}
+export interface IAxis extends IComponent {
+    valueToPosition: (value: any) => number;
+    getScale: () => IBaseScale;
+    getScales: () => IBaseScale[];
+    getOrient: () => ICartesianAxisSpec['orient'] | IPolarOrientType;
+    visible: boolean;
+    getStatisticsDomain: () => StatisticsDomain;
+}
+export interface IAxisItem<T> {
+    visible?: boolean;
+    style?: Omit<T, 'visible'>;
+}
+export interface IAxisItemTheme<T> {
+    visible?: boolean;
+    style?: Omit<T, 'visible'>;
+}
+export type AxisAnimationPreset = 'groupFadeIn' | 'fadeIn' | 'grow';
+export type ITickCallbackOption = {
+    axisLength?: number;
+    labelStyle?: ITextGraphicAttribute;
+};
+export type StyleCallback<T> = (value: any, index: number, datum: Datum, data: Datum[]) => T;
+export type AxisType = 'linear' | 'ordinal' | 'band' | 'point' | 'time' | 'log' | 'symlog';
+export interface IAxisLocationCfg {
+    bandPosition?: number;
+    datum?: Datum;
+}

package/types/component/axis/interface/index.d.ts

@@ -0,0 +1,3 @@
+export * from './common';
+export * from './spec';
+export * from './theme';

package/types/component/axis/interface/spec.d.ts

@@ -0,0 +1,91 @@
+import type { AxisItem, AxisItemStateStyle } from '@visactor/vrender-components';
+import type { IAnimationSpec } from '../../../animation/spec';
+import type { Datum, IPadding, IRectMarkSpec, IRuleMarkSpec, ISymbolMarkSpec, ITextMarkSpec, StringOrNumber } from '../../../typings';
+import type { IComponentSpec } from '../../base/interface';
+import type { AxisType, IAxisItem, ITickCallbackOption, StyleCallback } from './common';
+export interface ICommonAxisSpec extends Omit<IComponentSpec, 'orient' | 'center'>, IAnimationSpec<string, string> {
+    type?: AxisType;
+    visible?: boolean;
+    inverse?: boolean;
+    tick?: ITick;
+    subTick?: ISubTick;
+    animation?: boolean;
+    select?: boolean;
+    hover?: boolean;
+    sampling?: boolean;
+}
+export interface ILinearAxisSpec {
+    min?: number;
+    max?: number;
+    range?: {
+        min?: number;
+        max?: number;
+    };
+    nice?: boolean;
+    niceType?: 'tickCountFirst' | 'accurateFirst';
+    zero?: boolean;
+    expand?: {
+        min?: number;
+        max?: number;
+    };
+    tooltipFilterRange?: number | [number, number];
+}
+export interface IBandAxisSpec {
+    bandPadding?: number | number[];
+    paddingInner?: number | number[];
+    paddingOuter?: number | number[];
+    domain?: StringOrNumber[];
+    bandPosition?: number;
+}
+export interface IGrid extends IAxisItem<IRuleMarkSpec> {
+    alternateColor?: string | string[];
+    alignWithLabel?: boolean;
+    style?: IRuleMarkSpec | StyleCallback<IRuleMarkSpec | undefined>;
+    zIndex?: number;
+}
+export interface ITick extends IAxisItem<IRuleMarkSpec> {
+    tickSize?: number;
+    inside?: boolean;
+    alignWithLabel?: boolean;
+    tickStep?: number;
+    tickCount?: number | ((option: ITickCallbackOption) => number);
+    forceTickCount?: number;
+    tickMode?: 'average' | 'd3';
+    noDecimals?: boolean;
+    style?: IRuleMarkSpec | StyleCallback<IRuleMarkSpec | undefined>;
+    state?: AxisItemStateStyle<IRuleMarkSpec>;
+    dataFilter?: (data: AxisItem[]) => AxisItem[];
+}
+export interface ISubTick extends IAxisItem<IRuleMarkSpec> {
+    tickCount?: number;
+    inside?: boolean;
+    tickSize?: number;
+    state?: AxisItemStateStyle<IRuleMarkSpec>;
+}
+export interface ILabel extends IAxisItem<ITextMarkSpec> {
+    formatMethod?: (text: string | string[], datum?: Datum) => string | string[];
+    space?: number;
+    inside?: boolean;
+    minGap?: number;
+    style?: ITextMarkSpec | StyleCallback<ITextMarkSpec | undefined>;
+    state?: AxisItemStateStyle<ITextMarkSpec>;
+    dataFilter?: (data: AxisItem[], layer: number) => AxisItem[];
+}
+export interface IDomainLine extends IAxisItem<IRuleMarkSpec> {
+    state?: AxisItemStateStyle<IRuleMarkSpec>;
+}
+export interface ITitle extends IAxisItem<ITextMarkSpec> {
+    position?: 'start' | 'middle' | 'end';
+    space?: number;
+    padding?: IPadding | number | number[];
+    background?: IAxisItem<IRectMarkSpec> & {
+        state?: AxisItemStateStyle<Partial<IRectMarkSpec>>;
+    };
+    shape?: IAxisItem<ISymbolMarkSpec> & {
+        space?: number;
+        state?: AxisItemStateStyle<Partial<ISymbolMarkSpec>>;
+    };
+    text?: string | string[];
+    angle?: number;
+    state?: AxisItemStateStyle<Partial<ITextMarkSpec>>;
+}

package/types/component/axis/interface/theme.d.ts

@@ -0,0 +1,15 @@
+import type { IDomainLine, IGrid, ILabel, ISubTick, ITick, ITitle } from './spec';
+export interface IAxisCommonTheme {
+    grid?: IGrid;
+    subGrid?: IGrid;
+    domainLine?: IDomainLine;
+    label?: ILabel;
+    title?: ITitle;
+    tick?: ITick;
+    subTick?: ISubTick;
+}
+export interface IBandAxisTheme extends IAxisCommonTheme {
+    bandPadding?: number | number[];
+    paddingInner?: number | number[];
+    paddingOuter?: number | number[];
+}

package/types/component/axis/interface.d.ts

@@ -0,0 +1,137 @@
+import type { Datum, IPadding, IPolarOrientType, IRectMarkSpec, IRuleMarkSpec, ISymbolMarkSpec, ITextMarkSpec, StringOrNumber } from '../../typings';
+import type { ICartesianAxisSpec } from './cartesian/interface';
+import type { IComponent } from '../interface';
+import type { IBaseScale } from '@visactor/vscale';
+import type { IAnimationSpec } from '../../animation/spec';
+import type { AxisItem, AxisItemStateStyle } from '@visactor/vrender-components';
+import type { IComponentSpec } from '../base/interface';
+import type { ITextGraphicAttribute } from '@visactor/vrender-core';
+export interface StatisticsDomain {
+    domain: any[];
+    index: {
+        [key in StringOrNumber]: number;
+    };
+}
+export interface IAxis extends IComponent {
+    valueToPosition: (value: any) => number;
+    getScale: () => IBaseScale;
+    getScales: () => IBaseScale[];
+    getOrient: () => ICartesianAxisSpec['orient'] | IPolarOrientType;
+    visible: boolean;
+    getStatisticsDomain: () => StatisticsDomain;
+}
+export interface IAxisItem<T> {
+    visible?: boolean;
+    style?: Omit<T, 'visible'>;
+}
+export interface IAxisItemTheme<T> {
+    visible?: boolean;
+    style?: Omit<T, 'visible'>;
+}
+export type AxisAnimationPreset = 'groupFadeIn' | 'fadeIn' | 'grow';
+export interface ICommonAxisSpec extends Omit<IComponentSpec, 'orient' | 'center'>, IAnimationSpec<string, string> {
+    type?: AxisType;
+    visible?: boolean;
+    inverse?: boolean;
+    tick?: ITick;
+    subTick?: ISubTick;
+    animation?: boolean;
+    select?: boolean;
+    hover?: boolean;
+    sampling?: boolean;
+}
+export interface ILinearAxisSpec {
+    min?: number;
+    max?: number;
+    range?: {
+        min?: number;
+        max?: number;
+    };
+    nice?: boolean;
+    niceType?: 'tickCountFirst' | 'accurateFirst';
+    zero?: boolean;
+    expand?: {
+        min?: number;
+        max?: number;
+    };
+    tooltipFilterRange?: number | [number, number];
+}
+export interface IBandAxisSpec {
+    bandPadding?: number | number[];
+    paddingInner?: number | number[];
+    paddingOuter?: number | number[];
+    domain?: StringOrNumber[];
+    bandPosition?: number;
+}
+export interface IGrid extends IAxisItem<IRuleMarkSpec> {
+    alternateColor?: string | string[];
+    alignWithLabel?: boolean;
+    style?: IRuleMarkSpec | StyleCallback<IRuleMarkSpec | undefined>;
+    zIndex?: number;
+}
+export type ITickCallbackOption = {
+    axisLength?: number;
+    labelStyle?: ITextGraphicAttribute;
+};
+export interface ITick extends IAxisItem<IRuleMarkSpec> {
+    tickSize?: number;
+    inside?: boolean;
+    alignWithLabel?: boolean;
+    tickStep?: number;
+    tickCount?: number | ((option: ITickCallbackOption) => number);
+    forceTickCount?: number;
+    tickMode?: 'average' | 'd3';
+    noDecimals?: boolean;
+    style?: IRuleMarkSpec | StyleCallback<IRuleMarkSpec | undefined>;
+    state?: AxisItemStateStyle<IRuleMarkSpec>;
+    dataFilter?: (data: AxisItem[]) => AxisItem[];
+}
+export interface ISubTick extends IAxisItem<IRuleMarkSpec> {
+    tickCount?: number;
+    inside?: boolean;
+    tickSize?: number;
+    state?: AxisItemStateStyle<IRuleMarkSpec>;
+}
+export interface ILabel extends IAxisItem<ITextMarkSpec> {
+    formatMethod?: (text: string | string[], datum?: Datum) => string | string[];
+    space?: number;
+    inside?: boolean;
+    minGap?: number;
+    style?: ITextMarkSpec | StyleCallback<ITextMarkSpec | undefined>;
+    state?: AxisItemStateStyle<ITextMarkSpec>;
+    dataFilter?: (data: AxisItem[], layer: number) => AxisItem[];
+}
+export interface IDomainLine extends IAxisItem<IRuleMarkSpec> {
+    state?: AxisItemStateStyle<IRuleMarkSpec>;
+}
+export interface ITitle extends IAxisItem<ITextMarkSpec> {
+    position?: 'start' | 'middle' | 'end';
+    space?: number;
+    padding?: IPadding | number | number[];
+    background?: IAxisItem<IRectMarkSpec> & {
+        state?: AxisItemStateStyle<Partial<IRectMarkSpec>>;
+    };
+    shape?: IAxisItem<ISymbolMarkSpec> & {
+        space?: number;
+        state?: AxisItemStateStyle<Partial<ISymbolMarkSpec>>;
+    };
+    text?: string | string[];
+    angle?: number;
+    state?: AxisItemStateStyle<Partial<ITextMarkSpec>>;
+}
+export type StyleCallback<T> = (value: any, index: number, datum: Datum, data: Datum[]) => T;
+export type AxisType = 'linear' | 'ordinal' | 'band' | 'point' | 'time' | 'log' | 'symlog';
+export interface IAxisCommonTheme {
+    grid?: IGrid;
+    subGrid?: IGrid;
+    domainLine?: IDomainLine;
+    label?: ILabel;
+    title?: ITitle;
+    tick?: ITick;
+    subTick?: ISubTick;
+}
+export interface IBandAxisTheme extends IAxisCommonTheme {
+    bandPadding?: number | number[];
+    paddingInner?: number | number[];
+    paddingOuter?: number | number[];
+}

package/types/component/axis/mixin/band-axis-mixin.d.ts

@@ -0,0 +1,42 @@
+import type { BandScale } from '@visactor/vscale';
+import type { StringOrNumber } from '../../../typings';
+import type { IEvent } from '../../../event/interface';
+import type { IAxisLocationCfg } from '../interface';
+export interface BandAxisMixin {
+    _scale: BandScale;
+    _scales: BandScale[];
+    _spec: any;
+    _defaultBandPosition: number;
+    _defaultBandInnerPadding: number;
+    _defaultBandOuterPadding: number;
+    event: IEvent;
+    isSeriesDataEnable: () => boolean;
+    computeStatisticsDomain: () => void;
+    collectData: (depth: number) => {
+        min: number;
+        max: number;
+        values: any[];
+    }[];
+    computeDomain: (data: {
+        min: number;
+        max: number;
+        values: any[];
+    }[]) => StringOrNumber[];
+    transformScaleDomain: () => void;
+}
+export declare class BandAxisMixin {
+    dataToPosition(values: any[], cfg?: IAxisLocationCfg): number;
+    valueToPosition(value: any): number;
+    updateGroupScaleRange(): void;
+    getPosition(values: any[]): {
+        position: number;
+        bandScale: BandScale;
+    };
+    calcScales(DEFAULT_BAND_INNER_PADDING: number, DEFAULT_BAND_OUTER_PADDING: number): void;
+    computeBandDomain(data: {
+        min: number;
+        max: number;
+        values: any[];
+    }[]): StringOrNumber[];
+    protected updateScaleDomain(): void;
+}

package/types/component/axis/mixin/linear-axis-mixin.d.ts

@@ -0,0 +1,57 @@
+import type { LinearScale } from '@visactor/vscale';
+import type { IAxisLocationCfg, ITick } from '../interface';
+import type { IEvent } from '../../../event/interface';
+export declare const e10: number;
+export declare const e5: number;
+export declare const e2: number;
+export interface LinearAxisMixin {
+    _scale: LinearScale;
+    _scales: LinearScale[];
+    _spec: any;
+    _nice: boolean;
+    _zero: boolean;
+    _domain: {
+        min?: number;
+        max?: number;
+    };
+    _expand?: {
+        max?: number;
+        min?: number;
+    };
+    _tick: ITick | undefined;
+    isSeriesDataEnable: any;
+    computeStatisticsDomain: any;
+    computeDomain: any;
+    collectData: any;
+    event: IEvent;
+}
+export declare class LinearAxisMixin {
+    protected _extend: {
+        [key: string]: number;
+    };
+    setExtraAttrFromSpec(): void;
+    transformScaleDomain(): void;
+    setLinearScaleNice(): void;
+    setLogScaleNice(): void;
+    setScaleNice(): void;
+    dataToPosition(values: any[], cfg?: IAxisLocationCfg): number;
+    valueToPosition(value: any): number;
+    computeLinearDomain(data: {
+        min: number;
+        max: number;
+        values: any[];
+    }[]): number[];
+    protected expandDomain(domain: number[]): void;
+    protected niceDomain(domain: number[]): number[];
+    protected includeZero(domain: number[]): void;
+    setExtendDomain(key: string, value: number | undefined): void;
+    protected extendDomain(domain: number[]): void;
+    getDomainSpec(): {
+        min?: number;
+        max?: number;
+    };
+    protected setDomainMinMax(domain: number[]): void;
+    setZero(zero: boolean): void;
+    protected updateScaleDomain(): void;
+    protected updateScaleDomainByModel(domain?: number[]): void;
+}