@visactor/vchart-types 0.10.0-alpha.2

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

@@ -0,0 +1,49 @@
+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;
+    getInverse: () => boolean;
+    visible: boolean;
+    directionStr?: 'l2r' | 'r2l' | 't2b' | 'b2t';
+}
+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;
+}
+export interface ITickCalculationCfg {
+    tickStep?: number;
+    tickCount?: number | ((option: ITickCallbackOption) => number);
+    forceTickCount?: number;
+    tickMode?: 'average' | 'd3';
+    noDecimals?: boolean;
+}
+export interface IBandAxisLayer extends Omit<ITickCalculationCfg, 'noDecimals' | 'tickMode'> {
+    visible?: boolean;
+}

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,92 @@
+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, IBandAxisLayer, ITickCalculationCfg, StyleCallback } from './common';
+import type { IRichTextCharacter } from '@visactor/vrender-core';
+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 {
+    trimPadding?: boolean;
+    bandPadding?: number | number[];
+    paddingInner?: number | number[];
+    paddingOuter?: number | number[];
+    domain?: StringOrNumber[];
+    bandPosition?: number;
+    showAllGroupLayers?: boolean;
+    layers?: IBandAxisLayer[];
+}
+export interface IGrid extends IAxisItem<IRuleMarkSpec> {
+    alternateColor?: string | string[];
+    alignWithLabel?: boolean;
+    style?: IRuleMarkSpec | StyleCallback<IRuleMarkSpec | undefined>;
+    zIndex?: number;
+}
+export interface ITick extends IAxisItem<IRuleMarkSpec>, ITickCalculationCfg {
+    tickSize?: number;
+    inside?: boolean;
+    alignWithLabel?: 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> {
+    type?: 'text' | 'rich' | 'html';
+    formatMethod?: (text: string | string[], datum?: Datum) => string | string[] | IRichTextCharacter[];
+    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>>;
+    };
+    type?: 'text' | 'rich' | 'html';
+    text?: string | string[] | IRichTextCharacter[];
+    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,59 @@
+import type { BandScale } from '@visactor/vscale';
+import type { Dict } from '@visactor/vutils';
+import type { IOrientType, IPolarOrientType, StringOrNumber } from '../../../typings';
+import type { IEvent } from '../../../event/interface';
+import type { IAxisLocationCfg } from '../interface';
+import { CompilableData } from '../../../compile/data/compilable-data';
+export interface BandAxisMixin {
+    _orient: IOrientType | IPolarOrientType;
+    _option: any;
+    _scale: BandScale;
+    _scales: BandScale[];
+    _spec: any;
+    _tick: any;
+    _tickData: CompilableData[];
+    _defaultBandPosition: number;
+    _defaultBandInnerPadding: number;
+    _defaultBandOuterPadding: number;
+    event: IEvent;
+    isSeriesDataEnable: () => boolean;
+    collectData: (depth: number, rawData?: boolean) => {
+        min: number;
+        max: number;
+        values: any[];
+    }[];
+    computeDomain: (data: {
+        min: number;
+        max: number;
+        values: any[];
+    }[]) => StringOrNumber[];
+    transformScaleDomain: () => void;
+    _initTickDataSet: (options: any, index?: number) => any;
+    _tickTransformOption: () => any;
+    _forceLayout: () => void;
+    _getNormalizedValue: (values: any[], length: number) => number;
+}
+export declare class BandAxisMixin {
+    private _tickDataMap;
+    protected _initData(): void;
+    protected _rawDomainIndex: {
+        [key: string | number | symbol]: number;
+    }[];
+    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;
+    protected getLabelItems(length: number): Dict<any>[][];
+    protected _updateRawDomain(): void;
+    protected _clearRawDomain(): void;
+}

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

@@ -0,0 +1,64 @@
+import type { LinearScale } from '@visactor/vscale';
+import type { IAxisLocationCfg, ITick } from '../interface';
+import type { IEvent } from '../../../event/interface';
+import type { IOrientType } from '../../../typings/space';
+import type { IComponentOption } from '../../interface/common';
+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;
+    computeDomain: any;
+    collectData: (depth?: number) => {
+        min: number;
+        max: number;
+        values: any[];
+    }[];
+    event: IEvent;
+    _orient: IOrientType;
+    _option: IComponentOption;
+}
+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;
+}

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

@@ -0,0 +1,89 @@
+import type { IBaseScale } from '@visactor/vscale';
+import type { IPolarAxis, IPolarAxisCommonSpec } from './interface';
+import type { IComponentOption } from '../../interface';
+import { ComponentTypeEnum } from '../../interface/type';
+import type { IPolarTickDataOpt } from '@visactor/vutils-extension';
+import type { IPolarSeries } from '../../../series/interface';
+import type { IPoint, IPolarOrientType, IPolarPoint, StringOrNumber, ILayoutType } from '../../../typings';
+import type { Maybe } from '@visactor/vutils';
+import type { IEffect, IModelSpecInfo } from '../../../model/interface';
+import { AxisComponent } from '../base-axis';
+import type { ITick } from '../interface';
+export declare abstract class PolarAxis<T extends IPolarAxisCommonSpec = IPolarAxisCommonSpec> extends AxisComponent<T> implements IPolarAxis {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    static specKey: string;
+    protected readonly _defaultBandPosition = 0;
+    protected readonly _defaultBandInnerPadding = 0;
+    protected readonly _defaultBandOuterPadding = 0;
+    layoutType: ILayoutType;
+    layoutZIndex: number;
+    protected _tick: ITick | undefined;
+    protected _center: IPoint | null;
+    get center(): IPoint;
+    protected _startAngle: number;
+    get startAngle(): number;
+    protected _endAngle: number;
+    get endAngle(): number;
+    protected _orient: IPolarOrientType;
+    getOrient(): IPolarOrientType;
+    protected _groupScales: IBaseScale[];
+    getGroupScales(): IBaseScale[];
+    private _axisStyle;
+    private _gridStyle;
+    static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
+    static createComponent(specInfo: IModelSpecInfo, options: IComponentOption): IPolarAxis;
+    constructor(spec: T, options: IComponentOption);
+    effect: IEffect;
+    setAttrFromSpec(): void;
+    _transformLayoutPosition: (pos: Partial<IPoint>) => Partial<IPoint>;
+    onLayoutEnd(ctx: any): void;
+    onRender(ctx: any): void;
+    changeRegions(): void;
+    protected _tickTransformOption(): IPolarTickDataOpt;
+    afterCompile(): void;
+    protected updateScaleRange(): boolean;
+    protected collectData(depth: number, rawData?: boolean): {
+        min: number;
+        max: number;
+        values: any[];
+    }[];
+    protected abstract computeDomain(data: {
+        min: number;
+        max: number;
+        values: any[];
+    }[]): StringOrNumber[];
+    protected updateSeriesScale(): void;
+    protected getSeriesStatisticsField(s: IPolarSeries): string[];
+    protected initGroupScales(): void;
+    protected axisHelper(): {
+        isContinuous: boolean;
+        dataToPosition: (values: any[]) => number;
+        coordToPoint: (point: IPolarPoint) => IPoint;
+        pointToCoord: (point: IPoint) => IPolarPoint;
+        center: () => IPoint;
+        getScale: (depth: number) => IBaseScale;
+        getAxisId: () => number;
+        getSpec: () => T;
+    };
+    positionToData(position: IPoint): number;
+    coordToPoint(point: IPolarPoint): IPoint;
+    pointToCoord(point: IPoint): IPolarPoint;
+    getCenter(): IPoint;
+    getOuterRadius(): number;
+    getInnerRadius(): number;
+    updateLayoutAttribute(): void;
+    protected _getNormalizedValue(values: any[], length: number): number;
+    protected getLabelItems(length: number): any[];
+    protected _getStartValue(): number;
+    private _layoutAngleAxis;
+    private _layoutRadiusAxis;
+    protected _getRelatedAngleAxis(): IPolarAxis | undefined;
+    private computeLayoutOuterRadius;
+    private computeLayoutInnerRadius;
+    private getRefLayoutRect;
+    private getRefSeriesRadius;
+    private _update;
+    invert(value: number): number;
+}

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

@@ -0,0 +1,35 @@
+import { BandScale } from '@visactor/vscale';
+import { ComponentTypeEnum } from '../../interface/type';
+import { PolarAxis } from './axis';
+import { BandAxisMixin } from '../mixin/band-axis-mixin';
+import type { StringOrNumber } from '../../../typings';
+import type { IPolarBandAxisSpec } from './interface';
+export interface PolarBandAxis<T extends IPolarBandAxisSpec = IPolarBandAxisSpec> extends Pick<BandAxisMixin, 'valueToPosition' | 'updateGroupScaleRange' | 'getPosition' | 'calcScales' | 'computeBandDomain'>, PolarAxis<T> {
+}
+export declare class PolarBandAxis<T extends IPolarBandAxisSpec = IPolarBandAxisSpec> extends PolarAxis<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 axisHelper(): {
+        getBandwidth: (depth: number) => number;
+        isContinuous: boolean;
+        dataToPosition: (values: any[]) => number;
+        coordToPoint: (point: import("../../../typings").IPolarPoint) => import("../../../typings").IPoint;
+        pointToCoord: (point: import("../../../typings").IPoint) => import("../../../typings").IPolarPoint;
+        center: () => import("../../../typings").IPoint;
+        getScale: (depth: number) => import("@visactor/vscale").IBaseScale;
+        getAxisId: () => number;
+        getSpec: () => T;
+    };
+    protected initScales(): void;
+    transformScaleDomain(): void;
+}
+export declare const registerPolarBandAxis: () => void;

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

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

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

@@ -0,0 +1,4 @@
+export * from './axis';
+export * from './linear-axis';
+export * from './band-axis';
+export * from './interface';

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

@@ -0,0 +1,31 @@
+import type { IBaseScale } from '@visactor/vscale';
+import type { IPoint, IPolarOrientType, IPolarPoint } from '../../../../typings';
+import type { IAxis, IGrid } from '../../interface';
+import type { ICompilableData } from '../../../../compile/data';
+export type IPolarGrid = IGrid & {
+    smooth?: boolean;
+};
+export interface IPolarAxisHelper {
+    isContinuous: boolean;
+    dataToPosition: (values: any, cfg?: any) => number;
+    coordToPoint: (point: IPolarPoint) => IPoint;
+    pointToCoord: (point: IPoint) => IPolarPoint;
+    center: () => IPoint;
+    getScale: (depth?: number) => IBaseScale;
+    getBandwidth?: (depth?: number) => number;
+    getAxisId: () => number;
+}
+export interface IPolarAxis extends IAxis {
+    startAngle: number;
+    endAngle: number;
+    getOrient: () => IPolarOrientType;
+    getScale: () => IBaseScale;
+    getCenter: () => IPoint;
+    getOuterRadius: () => number;
+    getInnerRadius: () => number;
+    dataToPosition: (values: any[]) => number;
+    positionToData: (position: IPoint) => any;
+    getTickData: () => ICompilableData;
+    coordToPoint: (point: IPolarPoint) => IPoint;
+    pointToCoord: (point: IPoint) => IPolarPoint;
+}

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

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

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

@@ -0,0 +1,21 @@
+import type { IPoint, IPolarOrientType } from '../../../../typings';
+import type { IBandAxisSpec, IDomainLine, ILinearAxisSpec, ITitle, ILabel, ICommonAxisSpec } from '../../interface';
+import type { IPolarGrid } from './common';
+export type IPolarAxisSpec = IPolarLinearAxisSpec | IPolarBandAxisSpec;
+export type IPolarAxisCommonSpec = Omit<ICommonAxisSpec, 'center'> & {
+    inside?: boolean;
+    orient: IPolarOrientType;
+    grid?: IPolarGrid;
+    radius?: number;
+    subGrid?: IPolarGrid;
+    domainLine?: IDomainLine;
+    label?: ILabel;
+    title?: ITitle;
+    innerRadius?: number;
+    outerRadius?: number;
+    center?: IPoint;
+    startAngle?: number;
+    endAngle?: number;
+};
+export type IPolarLinearAxisSpec = IPolarAxisCommonSpec & ILinearAxisSpec;
+export type IPolarBandAxisSpec = IPolarAxisCommonSpec & IBandAxisSpec;

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

@@ -0,0 +1,11 @@
+import type { IDomainLine, ITick, ITitle, ILabel } from '../../interface';
+import type { IPolarGrid } from './common';
+export interface IPolarAxisCommonTheme {
+    grid?: IPolarGrid;
+    subGrid?: IPolarGrid;
+    domainLine?: IDomainLine;
+    label?: ILabel;
+    title?: ITitle;
+    tick?: ITick;
+    subTick?: ITick;
+}

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

@@ -0,0 +1,24 @@
+import { LinearScale } from '@visactor/vscale';
+import { ComponentTypeEnum } from '../../interface/type';
+import { PolarAxis } from './axis';
+import type { IPolarLinearAxisSpec } from './interface/spec';
+import { LinearAxisMixin } from '../mixin/linear-axis-mixin';
+export interface PolarLinearAxis<T extends IPolarLinearAxisSpec = IPolarLinearAxisSpec> extends Pick<LinearAxisMixin, 'setExtraAttrFromSpec' | 'transformScaleDomain' | 'valueToPosition' | 'computeLinearDomain' | 'setScaleNice'>, PolarAxis<T> {
+}
+export declare class PolarLinearAxis<T extends IPolarLinearAxisSpec = IPolarLinearAxisSpec> extends PolarAxis<T> {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    static specKey: string;
+    protected _zero: boolean;
+    protected _nice: boolean;
+    protected _scale: LinearScale;
+    protected _groupScales: LinearScale[];
+    setAttrFromSpec(): void;
+    protected initScales(): void;
+    protected computeDomain(data: {
+        min: number;
+        max: number;
+        values: any[];
+    }[]): number[];
+}
+export declare const registerPolarLinearAxis: () => void;

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

@@ -0,0 +1,9 @@
+import type { IPolarAxisCommonSpec } from '../interface';
+export declare const getPolarAxisInfo: (spec: IPolarAxisCommonSpec, chartSpec: any) => {
+    axisType: import("../..").AxisType;
+    componentName: string;
+    startAngle: any;
+    endAngle: any;
+    center: any;
+    outerRadius: any;
+};

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

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