@visactor/vchart-types 0.10.0-alpha.2

package/types/component/axis/base-axis.d.ts

@@ -0,0 +1,151 @@
+import type { ITickDataOpt } from '@visactor/vutils-extension';
+import type { IBaseScale } from '@visactor/vscale';
+import type { IGroup, IGraphic } from '@visactor/vrender-core';
+import type { IOrientType, IPolarOrientType, StringOrNumber, CoordinateType } from '../../typings';
+import { BaseComponent } from '../base/base-component';
+import { CompilableData } from '../../compile/data';
+import type { IAxis, ICommonAxisSpec, ITick } from './interface';
+import type { IComponentOption } from '../interface';
+import type { ISeries } from '../../series/interface';
+import type { ITransformOptions } from '@visactor/vdataset';
+import { DataView } from '@visactor/vdataset';
+import type { IComponentMark } from '../../mark/component';
+export declare abstract class AxisComponent<T extends ICommonAxisSpec & Record<string, any> = any> extends BaseComponent<T> implements IAxis {
+    static specKey: string;
+    specKey: string;
+    protected _orient: IPolarOrientType | IOrientType;
+    getOrient(): IOrientType | IPolarOrientType;
+    protected _scale: IBaseScale;
+    getScale(): IBaseScale;
+    protected _scales: IBaseScale[];
+    getScales(): IBaseScale[];
+    protected _tickData: CompilableData[];
+    getTickData(index?: number): CompilableData;
+    protected _seriesUserId?: StringOrNumber[];
+    protected _seriesIndex?: number[];
+    protected _regionUserId?: StringOrNumber[];
+    protected _regionIndex?: number[];
+    protected _visible: boolean;
+    get visible(): boolean;
+    protected _inverse: boolean;
+    getInverse(): boolean;
+    protected _tick: ITick | undefined;
+    protected abstract computeDomain(data: {
+        min: number;
+        max: number;
+        values: any[];
+    }[]): StringOrNumber[];
+    abstract valueToPosition(value: any): number;
+    protected abstract axisHelper(): any;
+    protected abstract getSeriesStatisticsField(s: ISeries): string[];
+    protected abstract updateSeriesScale(): void;
+    protected abstract collectData(depth: number, rawData?: boolean): {
+        min: number;
+        max: number;
+        values: any[];
+    }[];
+    abstract transformScaleDomain(): void;
+    protected _dataFieldText: string;
+    protected _axisMark: IComponentMark;
+    protected _gridMark: IComponentMark;
+    protected _coordinateType: CoordinateType;
+    constructor(spec: T, options: IComponentOption);
+    protected _getNeedClearVRenderComponents(): IGraphic[];
+    getVRenderComponents(): any[];
+    created(): void;
+    protected _initData(): void;
+    protected isSeriesDataEnable(): boolean;
+    protected setSeriesAndRegionsFromSpec(): void;
+    getBindSeriesFilter(): {
+        userId: StringOrNumber[];
+        specIndex: number[];
+    };
+    protected initEvent(): void;
+    protected updateScaleDomain(): void;
+    protected _clearRawDomain(): void;
+    protected computeData(updateType?: 'domain' | 'range' | 'force'): void;
+    protected initScales(): void;
+    _compareSpec(spec: T, prevSpec: T): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    protected getLabelFormatMethod(): (value: any, datum: any, index: number) => any;
+    protected _delegateAxisContainerEvent(component: IGroup): void;
+    protected _getAxisAttributes(): {
+        orient: IOrientType | IPolarOrientType;
+        select: boolean;
+        hover: boolean;
+        line: any;
+        label: {
+            style: any;
+            formatMethod: (value: any, datum: any, index: number) => any;
+            state: {};
+        };
+        tick: {
+            visible: boolean;
+            length?: undefined;
+            inside?: undefined;
+            alignWithLabel?: undefined;
+            style?: undefined;
+            state?: undefined;
+            dataFilter?: undefined;
+        } | {
+            visible: true;
+            length: number;
+            inside: boolean;
+            alignWithLabel: boolean;
+            style: any;
+            state: {};
+            dataFilter: (data: import("@visactor/vrender-components").AxisItem[]) => import("@visactor/vrender-components").AxisItem[];
+        };
+        subTick: {
+            visible: boolean;
+            length?: undefined;
+            inside?: undefined;
+            count?: undefined;
+            style?: undefined;
+            state?: undefined;
+        } | {
+            visible: true;
+            length: number;
+            inside: boolean;
+            count: number;
+            style: any;
+            state: {};
+        };
+        title: any;
+        panel: {
+            visible: boolean;
+            style?: undefined;
+            state?: undefined;
+        } | {
+            visible: any;
+            style: any;
+            state: {};
+        };
+    };
+    protected _getGridAttributes(): {
+        alternateColor: any;
+        alignWithLabel: any;
+        style: any;
+        subGrid: {
+            visible: boolean;
+            type?: undefined;
+            alternateColor?: undefined;
+            style?: undefined;
+        } | {
+            type: string;
+            visible: any;
+            alternateColor: any;
+            style: any;
+        };
+    };
+    protected _initTickDataSet<T extends ITickDataOpt>(options: T, index?: number): DataView;
+    protected _tickTransformOption(): ITickDataOpt;
+    addTransformToTickData(options: ITransformOptions, execute?: boolean): void;
+    dataToPosition(values: any[]): number;
+}
+export declare const registerAxis: () => void;

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

@@ -0,0 +1,113 @@
+import type { IBoundsLike, Maybe } from '@visactor/vutils';
+import type { IEffect, IModelInitOption, IModelSpecInfo } from '../../../model/interface';
+import type { ICartesianSeries } from '../../../series/interface';
+import type { IRegion } from '../../../region/interface';
+import type { ICartesianAxisCommonSpec, IAxisHelper } from './interface';
+import type { IOrientType, IRect } from '../../../typings/space';
+import type { IBaseScale } from '@visactor/vscale';
+import type { StringOrNumber } from '../../../typings/common';
+import type { IPoint } from '../../../typings/coordinate';
+import type { ILayoutRect, ILayoutType } from '../../../typings/layout';
+import type { IComponentOption } from '../../interface';
+import { ComponentTypeEnum } from '../../interface/type';
+import type { IAxis, ITick } from '../interface';
+import type { ICartesianTickDataOpt } from '@visactor/vutils-extension';
+import type { DataSet } from '@visactor/vdataset';
+import { AxisComponent } from '../base-axis';
+import type { IGraphic } from '@visactor/vrender-core';
+export declare abstract class CartesianAxis<T extends ICartesianAxisCommonSpec = ICartesianAxisCommonSpec> extends AxisComponent<T> implements IAxis {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    static specKey: string;
+    protected readonly _defaultBandPosition = 0.5;
+    protected readonly _defaultBandInnerPadding = 0.1;
+    protected readonly _defaultBandOuterPadding = 0.3;
+    directionStr?: 'l2r' | 'r2l' | 't2b' | 'b2t';
+    layoutType: ILayoutType;
+    layoutZIndex: number;
+    layoutLevel: number;
+    protected _dataSet: DataSet;
+    layout3dBox?: {
+        width: number;
+        height: number;
+        length: number;
+    };
+    protected _orient: IOrientType;
+    getOrient(): IOrientType;
+    protected _autoIndentOnce: boolean;
+    protected _hasAutoIndent: boolean;
+    set autoIndentOnce(v: boolean);
+    protected _scales: IBaseScale[];
+    getScales(): IBaseScale[];
+    protected _tick: ITick | undefined;
+    private _axisStyle;
+    private _latestBounds;
+    private _verticalLimitSize;
+    private _unitText;
+    protected _layoutCache: {
+        width: number;
+        height: number;
+        _lastComputeOutBounds: IBoundsLike;
+    };
+    protected _innerOffset: {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+    constructor(spec: T, options: IComponentOption);
+    static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
+    static createComponent(specInfo: IModelSpecInfo, options: IComponentOption): IAxis;
+    initLayout(): void;
+    setLayout3dBox(box3d: {
+        width: number;
+        height: number;
+        length: number;
+    }): void;
+    effect: IEffect;
+    protected abstract computeDomain(data: {
+        min: number;
+        max: number;
+        values: any[];
+    }[]): StringOrNumber[];
+    abstract valueToPosition(value: any): number;
+    protected updateScaleRange(): boolean;
+    init(option: IModelInitOption): void;
+    setAttrFromSpec(): void;
+    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect, ctx: any): void;
+    protected getSeriesStatisticsField(s: ICartesianSeries): string[];
+    protected _tickTransformOption(): ICartesianTickDataOpt;
+    protected axisHelper(): IAxisHelper;
+    afterCompile(): void;
+    onLayoutEnd(ctx: any): void;
+    onRender(ctx: any): void;
+    changeRegions(regions: IRegion[]): void;
+    update(ctx: IComponentOption): void;
+    resize(ctx: IComponentOption): void;
+    protected collectScale(): IBaseScale[];
+    protected collectData(depth?: number, rawData?: boolean): {
+        min: number;
+        max: number;
+        values: any[];
+    }[];
+    protected updateSeriesScale(): void;
+    _transformLayoutPosition: (pos: Partial<IPoint>) => {
+        x: number;
+        y: number;
+    };
+    _transformLayoutRect: (result: ILayoutRect) => ILayoutRect;
+    getBoundsInRect(rect: ILayoutRect): IBoundsLike;
+    updateLayoutAttribute(): void;
+    private _getTitleLimit;
+    private _getUpdateAttribute;
+    protected getLabelItems(length: number): any[];
+    protected initEvent(): void;
+    protected _getNormalizedValue(values: any[], length: number): number;
+    private _fixAxisOnZero;
+    protected _layoutCacheProcessing(rect: ILayoutRect): ILayoutRect;
+    _clearLayoutCache(): void;
+    onDataUpdate(): void;
+    private _appendAxisUnit;
+    protected _getNeedClearVRenderComponents(): IGraphic[];
+}

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

@@ -0,0 +1,35 @@
+import { BandScale } from '@visactor/vscale';
+import { CartesianAxis } from './axis';
+import type { ICartesianBandAxisSpec } from './interface';
+import { ComponentTypeEnum } from '../../interface';
+import { BandAxisMixin } from '../mixin/band-axis-mixin';
+import type { StringOrNumber } from '../../../typings';
+export interface CartesianBandAxis<T extends ICartesianBandAxisSpec = ICartesianBandAxisSpec> extends Pick<BandAxisMixin, 'valueToPosition' | 'updateGroupScaleRange' | 'getPosition' | 'calcScales' | 'computeBandDomain'>, CartesianAxis<T> {
+}
+export declare class CartesianBandAxis<T extends ICartesianBandAxisSpec = ICartesianBandAxisSpec> extends CartesianAxis<T> {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    static specKey: string;
+    protected _scale: BandScale;
+    protected _scales: BandScale[];
+    protected computeDomain(data: {
+        min: number;
+        max: number;
+        values: any[];
+    }[]): StringOrNumber[];
+    protected updateScaleRange(): boolean;
+    protected initScales(): void;
+    protected axisHelper(): {
+        isContinuous: boolean;
+        dataToPosition: (values: any[]) => number;
+        getScale: (depth: number) => BandScale;
+        getBandwidth: (depth: number) => number;
+        getAxisType: () => ComponentTypeEnum;
+        getAxisId: () => number;
+        isInverse: () => boolean;
+        getSpec: () => T;
+    };
+    transformScaleDomain(): void;
+    updateFixedWholeLength(): void;
+}
+export declare const registerCartesianBandAxis: () => void;

package/types/component/axis/cartesian/config.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_BAND_INNER_PADDING = 0.1;
+export declare const DEFAULT_BAND_OUTER_PADDING = 0.3;
+export declare const DEFAULT_BAND_POSITION = 0.5;

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

@@ -0,0 +1,7 @@
+export * from './axis';
+export * from './linear-axis';
+export * from './band-axis';
+export * from './time-axis';
+export * from './log-axis';
+export * from './symlog-axis';
+export * from './interface';

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

@@ -0,0 +1,48 @@
+import type { SegmentAttributes, AxisLabelOverlap } from '@visactor/vrender-components';
+import type { IBaseScale } from '@visactor/vscale';
+import type { IAxis, IAxisLocationCfg, ICommonAxisSpec, IDomainLine, ILabel, ITickCalculationCfg, ITitle } from '../../interface';
+import type { ITextMarkSpec, StringOrNumber } from '../../../../typings';
+export type ICartesianDomainLineSpec = {
+    startSymbol?: SegmentAttributes['startSymbol'];
+    endSymbol?: SegmentAttributes['endSymbol'];
+    onZero?: boolean;
+    onZeroAxisIndex?: number;
+    onZeroAxisId?: StringOrNumber;
+};
+export type ICartesianDomainLine = IDomainLine & ICartesianDomainLineSpec;
+export type ICartesianTitle = ITitle & {
+    autoRotate?: boolean;
+    inside?: boolean;
+};
+export type ICartesianLabel = ILabel & {
+    flush?: boolean;
+    lastVisible?: boolean | null;
+    containerAlign?: 'left' | 'right' | 'center' | 'top' | 'bottom' | 'middle';
+} & AxisLabelOverlap;
+export interface ILinearAxis extends IAxis {
+    readonly zero: boolean;
+    readonly nice: boolean;
+    setExtendDomain: (key: string, value: number | undefined) => void;
+}
+export interface IAxisHelper {
+    isContinuous: boolean;
+    dataToPosition: (values: any[], cfg?: IAxisLocationCfg) => number;
+    valueToPosition?: (value: any, cfg?: IAxisLocationCfg) => number;
+    getScale?: (depth: number) => IBaseScale;
+    getBandwidth?: (depth: number) => number;
+    setExtendDomain?: (key: string, value: number | undefined) => void;
+    getAxisType: () => string;
+    getAxisId: () => number;
+    getSpec?: () => ICommonAxisSpec;
+    isInverse: () => boolean;
+    getFields?: () => string[];
+}
+export interface ITimeLayerType extends Omit<ITickCalculationCfg, 'noDecimals' | 'tickMode'> {
+    timeFormat?: string;
+    timeFormatMode?: 'utc' | 'local';
+}
+export type ICartesianAxisUnit = {
+    visible: boolean;
+    text?: string | number | number[] | string[];
+    style?: ITextMarkSpec;
+};

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

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

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

@@ -0,0 +1,62 @@
+import type { ILayoutNumber, 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 ICartesianVertical = {
+    orient: 'left' | 'right';
+    innerOffset?: {
+        top?: ILayoutNumber;
+        bottom?: ILayoutNumber;
+    };
+};
+export type ICartesianHorizontal = {
+    orient: 'top' | 'bottom';
+    innerOffset?: {
+        left?: ILayoutNumber;
+        right?: ILayoutNumber;
+    };
+};
+export type ICartesianZ = {
+    orient: 'z';
+};
+export type ICartesianAxisCommonSpec = ICommonAxisSpec & {
+    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;
+    hasDimensionTooltip?: boolean;
+} & (ICartesianVertical | ICartesianHorizontal | ICartesianZ);
+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 { ILayoutNumber, ILayoutPaddingSpec } from '../../../../typings/layout';
+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,29 @@
+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;
+    static specKey: string;
+    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,18 @@
+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;
+    static specKey: string;
+    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,18 @@
+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;
+    static specKey: string;
+    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,23 @@
+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;
+    static specKey: string;
+    protected _layerTickData: CompilableData;
+    protected _zero: boolean;
+    effect: IEffect;
+    setAttrFromSpec(): void;
+    protected _initData(): void;
+    protected computeData(updateType?: 'range' | 'domain' | 'force'): 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,15 @@
+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 getCartesianAxisInfo(spec: ICartesianAxisCommonSpec, isHorizontal?: boolean): {
+    axisType: import("../..").AxisType;
+    componentName: string;
+};

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';