@visactor/vchart-types 1.6.0

package/types/compile/mark/interface.d.ts

@@ -0,0 +1,154 @@
+import type { IMarkProgressiveConfig, IMarkStateStyle, MarkType } from '../../mark/interface';
+import type { IModel } from '../../model/interface';
+import type { GrammarItemCompileOption, GrammarItemInitOption } from '../interface';
+import type { IGrammarItem } from '../interface';
+import type { MarkStateManager } from './mark-state-manager';
+import type { DataView } from '@visactor/vdataset';
+import type { IAnimate, IAnimateArranger, IElement, IGroupMark, IMark, MarkAnimationSpec, Nil, TransformSpec } from '@visactor/vgrammar-core';
+import type { Maybe, Datum, StringOrNumber } from '../../typings';
+import type { MarkData } from './mark-data';
+import type { ILabelSpec } from '../../component/label';
+import type { IRegion } from '../../region/interface';
+export interface ICompilableMarkOption extends GrammarItemInitOption {
+    key?: string | ((datum: Datum) => string);
+    groupKey?: string;
+    skipBeforeLayouted?: boolean;
+    support3d?: boolean;
+    mode?: '2d' | '3d';
+}
+export interface ICompilableMark extends IGrammarItem {
+    readonly type: MarkType;
+    readonly id: number;
+    readonly name: string;
+    readonly key?: string | ((datum: Datum) => string);
+    readonly model: IModel;
+    getData: () => MarkData | undefined;
+    setData: (d: MarkData) => void;
+    getDataView: () => DataView | undefined;
+    setDataView: (d?: DataView, productId?: string) => void;
+    getFacet: () => string | undefined;
+    setFacet: (facet: string) => void;
+    getLabelSpec: () => ILabelSpec[];
+    setLabelSpec: (label: ILabelSpec | ILabelSpec[]) => void;
+    addLabelSpec: (label: ILabelSpec) => void;
+    state: MarkStateManager;
+    readonly stateStyle: IMarkStateStyle<any>;
+    hasState: (state: string) => boolean;
+    getState: (state: string) => any;
+    updateState: (newState: Record<string, unknown>) => Promise<void>;
+    updateStaticEncode: () => void;
+    compileEncode: () => void;
+    updateLayoutState: (noRender?: boolean, recursion?: boolean) => Promise<void>;
+    updateMarkState: (key: string) => void;
+    setTransform: (transform: TransformSpec[] | Nil) => void;
+    getInteractive: () => boolean;
+    setInteractive: (interactive: boolean) => void;
+    setAnimationConfig: (config: Partial<MarkAnimationSpec>) => void;
+    getAnimationConfig: () => Partial<MarkAnimationSpec>;
+    getZIndex: () => number;
+    setZIndex: (zIndex: number) => void;
+    getVisible: () => boolean;
+    setVisible: (visible: boolean) => void;
+    getMorph: () => boolean;
+    setMorph: (morph: boolean) => void;
+    getProgressiveConfig: () => IMarkProgressiveConfig;
+    setProgressiveConfig: (config: IMarkProgressiveConfig) => void;
+    getMorphKey: () => string | undefined;
+    setMorphKey: (morphKey: string) => void;
+    getMorphElementKey: () => string | undefined;
+    setMorphElementKey: (morphKey: string) => void;
+    getGroupKey: () => string | undefined;
+    setGroupKey: (groupKey: string) => void;
+    getUserId: () => StringOrNumber | undefined;
+    setUserId: (id: StringOrNumber) => void;
+    getSupport3d: () => boolean | undefined;
+    compile: (option?: IMarkCompileOption) => void;
+    getProduct: () => Maybe<IMark>;
+    getMarks: () => ICompilableMark[];
+    setSkipBeforeLayouted: (skip: boolean) => void;
+    getSkipBeforeLayouted: () => boolean;
+    runAnimationByState: (animationState?: string) => IAnimateArranger;
+    stopAnimationByState: (animationState?: string) => IAnimate;
+    pauseAnimationByState: (animationState: string) => IAnimate;
+    resumeAnimationByState: (animationState: string) => IAnimate;
+}
+export interface IMarkDataInitOption extends ICompilableMarkOption {
+    mark: ICompilableMark;
+}
+export interface IMarkCompileOption extends GrammarItemCompileOption {
+    group?: string | IGroupMark;
+    ignoreChildren?: boolean;
+}
+export interface IStateInfo {
+    stateValue: StateValue;
+    fields?: any | null | undefined;
+    datums?: any[] | null | undefined;
+    datumKeys?: string[] | null | undefined;
+    items?: any[] | null | undefined;
+    filter?: ((datum: any, options: Record<string, any>) => boolean) | null | undefined;
+    cache?: {
+        [key: string]: {
+            [key: string]: boolean;
+        };
+    };
+    level?: number | undefined;
+}
+export interface IStateSpec {
+    stateValue: StateValue;
+    datums?: any[] | null | undefined;
+    datumKeys?: string[] | null | undefined;
+    level?: number | undefined;
+}
+export interface IMarkState {
+    readonly id: number;
+    getStates: () => IStateInfo[];
+    getState: (stateValue: StateValue) => IStateInfo | undefined;
+    addState: (stateInfo: IStateInfo) => void;
+    changeState: (stateInfo: Partial<IStateInfo>, update?: boolean) => void;
+    checkState: (item: any, datum: any) => string[];
+    clearState: (stateValues: StateValue[], update?: boolean) => void;
+    update: () => void;
+}
+export declare enum STATE_VALUE_ENUM {
+    STATE_NORMAL = "normal",
+    STATE_HOVER = "hover",
+    STATE_HOVER_REVERSE = "hover_reverse",
+    STATE_DIMENSION_HOVER = "dimension_hover",
+    STATE_DIMENSION_HOVER_REVERSE = "dimension_hover_reverse",
+    STATE_SELECTED = "selected",
+    STATE_SELECTED_REVERSE = "selected_reverse"
+}
+export declare enum STATE_VALUE_ENUM_REVERSE {
+    STATE_HOVER_REVERSE = "hover_reverse",
+    STATE_DIMENSION_HOVER_REVERSE = "dimension_hover_reverse",
+    STATE_SELECTED_REVERSE = "selected_reverse"
+}
+export type STATE_NORMAL = typeof STATE_VALUE_ENUM.STATE_NORMAL;
+export type STATE_HOVER = typeof STATE_VALUE_ENUM.STATE_HOVER;
+export type STATE_HOVER_REVERSE = typeof STATE_VALUE_ENUM.STATE_HOVER_REVERSE;
+export type STATE_CUSTOM = string;
+export type StateValueNot = STATE_HOVER_REVERSE | STATE_CUSTOM;
+export type StateValue = STATE_NORMAL | STATE_HOVER | STATE_CUSTOM;
+export type StateValueType = StateValue | StateValueNot;
+export declare enum STATE_LEVEL {
+    NORMAL = 0,
+    DIMENSION_SELECTED = 1,
+    RELATIONAL_SELECTED = 2,
+    SELECTED = 3,
+    DIMENSION_HOVER = 4,
+    RELATIONAL_HOVER = 5,
+    HOVER = 6
+}
+export interface IAttributeOpt {
+    element: IElement;
+    mark: IElement['mark'];
+    parent: IElement['mark']['group'];
+}
+export interface IModelMarkAttributeContext {
+    [key: string]: unknown;
+}
+export interface ISeriesMarkAttributeContext extends IModelMarkAttributeContext {
+    globalScale: (scaleKey: string, value: string | number) => unknown;
+    seriesColor: (seriesValue?: string | number) => string;
+    getRegion: () => IRegion;
+}

package/types/compile/mark/mark-data.d.ts

@@ -0,0 +1,9 @@
+import { CompilableData } from '../data/compilable-data';
+import type { ICompilableMark, IMarkDataInitOption } from './interface';
+export declare class MarkData extends CompilableData {
+    protected _mark: ICompilableMark;
+    constructor(option: IMarkDataInitOption);
+    setCompiledProductId(name: string): void;
+    generateProductId(): string;
+    protected _compileProduct(): void;
+}

package/types/compile/mark/mark-state-manager.d.ts

@@ -0,0 +1,26 @@
+import type { IElement, IMark as IVGrammarMark } from '@visactor/vgrammar-core';
+import type { Datum, StringOrNumber } from '../../typings';
+import type { IStateManagerOption } from '../signal/interface';
+import { StateManager } from '../signal/state-manager';
+import type { CompilableMark } from './compilable-mark';
+import type { IStateInfo, StateValue } from './interface';
+export declare class MarkStateManager extends StateManager {
+    protected _mark: CompilableMark;
+    private _stateInfoList;
+    getStateInfoList(): IStateInfo[];
+    constructor(option: IStateManagerOption, mark: CompilableMark);
+    protected _getDefaultStateMap(): Record<string, unknown>;
+    getStateInfo(stateValue: StateValue): IStateInfo;
+    addStateInfo(stateInfo: IStateInfo): void;
+    private _clearStateBeforeSet;
+    changeStateInfo(stateInfo: Partial<IStateInfo>): void;
+    clearStateInfo(stateValues: StateValue[]): void;
+    checkOneState(renderNode: IElement, datum: Datum | Datum[], state: IStateInfo, isMultiMark?: boolean): 'in' | 'out' | 'skip';
+    checkState(renderNode: IElement, datum: Datum | Datum[]): StateValue[];
+    checkDatumState(state: IStateInfo, datum: Datum | Datum[], isMultiMark: boolean): boolean;
+    checkItemsState(state: IStateInfo, item: any): boolean | undefined;
+    checkFieldsState(state: IStateInfo, datum: Datum | Datum[], item: any, isMultiMark: boolean): boolean;
+    checkLinearFieldState(domain: StringOrNumber[], key: string, datum: any, item: any, isMultiMark: boolean): boolean;
+    updateLayoutState(noRender?: boolean): Promise<void>;
+    compileState(product: IVGrammarMark): void;
+}

package/types/compile/mark/util.d.ts

@@ -0,0 +1,7 @@
+import type { IAttrs, IMarkStateStyle, MarkType } from '../../mark/interface';
+export declare function isAttrChangeable<T>(key: string, stateStyle: IMarkStateStyle<T>): boolean;
+export declare function isStateAttrChangeable<T>(key: string, stateStyle: Partial<IAttrs<T>>, facetField: string): boolean;
+export declare function needAttrTransform(type: MarkType, attr: string): boolean;
+export declare function attrTransform(type: MarkType, attr: string, value: any): any;
+export declare function stateInDefaultEnum(state: string): boolean;
+export declare function stateToReverse(state: string): any;

package/types/compile/signal/compilable-signal.d.ts

@@ -0,0 +1,21 @@
+import type { ISignal, SignalFunctionType } from '@visactor/vgrammar-core';
+import { GrammarItem } from '../grammar-item';
+import type { Maybe } from '../../typings';
+import type { GrammarItemInitOption } from '../interface';
+import { GrammarType } from '../interface/compilable-item';
+import type { ICompilableSignal } from './interface';
+export declare class CompilableSignal<T> extends GrammarItem implements ICompilableSignal<T> {
+    readonly grammarType = GrammarType.signal;
+    protected _product: Maybe<ISignal<T>>;
+    getProduct: () => Maybe<ISignal<T>>;
+    readonly name: string;
+    protected _value: Maybe<T>;
+    getValue(): T;
+    protected _updateFunc: Maybe<SignalFunctionType<T>>;
+    getUpdateFunc(): SignalFunctionType<T>;
+    constructor(option: GrammarItemInitOption, name: string, value?: T, updateFunc?: SignalFunctionType<T>);
+    updateSignal(value?: T, updateFunc?: SignalFunctionType<T>): void;
+    protected _compileProduct(): void;
+    generateProductId(): string;
+    protected _lookupGrammar(id: string): ISignal<unknown>;
+}

package/types/compile/signal/index.d.ts

@@ -0,0 +1,4 @@
+export * from './compilable-signal';
+export * from './interface';
+export * from './signal-manager';
+export * from './state-manager';

package/types/compile/signal/interface.d.ts

@@ -0,0 +1,12 @@
+import type { SignalFunctionType } from '@visactor/vgrammar-core';
+import type { Maybe } from '../../typings';
+import type { IGrammarItem, ICompilableInitOption } from '../interface';
+export interface IStateManagerOption extends ICompilableInitOption {
+    stateKeyToSignalName?: (key: string) => string;
+}
+export type StateValueMap = Record<string, unknown>;
+export interface ICompilableSignal<T> extends IGrammarItem {
+    updateSignal: (value?: T, updateFunc?: SignalFunctionType<T>) => void;
+    getValue: () => Maybe<T>;
+    getUpdateFunc: () => Maybe<SignalFunctionType<T>>;
+}

package/types/compile/signal/signal-manager.d.ts

@@ -0,0 +1,11 @@
+import type { SignalFunctionType } from '@visactor/vgrammar-core';
+import { CompilableSignal } from './compilable-signal';
+import { CompilableBase } from '../compilable-base';
+export declare class SignalManager extends CompilableBase {
+    protected _signalMap: Record<string, CompilableSignal<any>>;
+    getSignalMap(): Record<string, CompilableSignal<any>>;
+    getSignal(name: string): CompilableSignal<any>;
+    updateSignal(name: string, value: any, updateFunc?: SignalFunctionType<any>): void;
+    compile(): void;
+    release(): void;
+}

package/types/compile/signal/state-manager.d.ts

@@ -0,0 +1,12 @@
+import type { IStateManagerOption, StateValueMap } from './interface';
+import { SignalManager } from './signal-manager';
+export declare class StateManager extends SignalManager {
+    protected _stateMap: StateValueMap;
+    getStateMap(): StateValueMap;
+    protected _getDefaultStateMap(): StateValueMap;
+    protected stateKeyToSignalName: (key: string) => string;
+    constructor(option: IStateManagerOption);
+    initStateMap(state?: StateValueMap): void;
+    compile(stateMap?: StateValueMap): void;
+    updateState(newState: Partial<StateValueMap>, noRender?: boolean): Promise<any>;
+}

package/types/compile/util.d.ts

@@ -0,0 +1,2 @@
+import type { RenderMode } from '../typings/spec';
+export declare function toRenderMode(mode: RenderMode): any;

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

@@ -0,0 +1,149 @@
+import type { IBaseScale } from '@visactor/vscale';
+import type { IGroup, IGraphic } from '@visactor/vrender-core';
+import type { AxisItem } from '@visactor/vrender-components';
+import type { IOrientType, IPolarOrientType, StringOrNumber } from '../../typings';
+import { BaseComponent } from '../base/base-component';
+import type { IPolarAxisCommonTheme } from './polar/interface';
+import type { ICartesianAxisCommonTheme } from './cartesian/interface';
+import type { CompilableData } from '../../compile/data';
+import type { IAxis, ICommonAxisSpec, ITick, StatisticsDomain } from './interface';
+import type { IComponentOption } from '../interface';
+import type { ISeries } from '../../series/interface';
+import type { ITransformOptions } 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;
+    protected _orient: IPolarOrientType | IOrientType;
+    getOrient(): IOrientType | IPolarOrientType;
+    protected _scale: IBaseScale;
+    getScale(): IBaseScale;
+    protected _scales: IBaseScale[];
+    getScales(): IBaseScale[];
+    protected _theme: ICartesianAxisCommonTheme | IPolarAxisCommonTheme;
+    protected _tickData: CompilableData;
+    getTickData(): CompilableData;
+    protected _statisticsDomain: StatisticsDomain;
+    getStatisticsDomain(): StatisticsDomain;
+    protected _seriesUserId?: StringOrNumber[];
+    protected _seriesIndex?: number[];
+    protected _regionUserId?: StringOrNumber[];
+    protected _regionIndex?: number[];
+    protected _visible: boolean;
+    get visible(): 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): {
+        min: number;
+        max: number;
+        values: any[];
+    }[];
+    protected abstract _initData(): void;
+    abstract transformScaleDomain(): void;
+    protected _dataFieldText: string;
+    protected _axisMark: IComponentMark;
+    protected _gridMark: IComponentMark;
+    constructor(spec: T, options: IComponentOption);
+    getVRenderComponents(): IGraphic[];
+    created(): void;
+    protected isSeriesDataEnable(): boolean;
+    protected setSeriesAndRegionsFromSpec(): void;
+    getBindSeriesFilter(): {
+        userId: StringOrNumber[];
+        specIndex: number[];
+    };
+    protected computeStatisticsDomain: () => void;
+    protected initEvent(): void;
+    protected updateScaleDomain(): void;
+    protected computeData(): void;
+    protected initScales(): void;
+    _compareSpec(): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    protected getLabelFormatMethod(): (value: any, datum: any, index: number) => any;
+    protected getLabelItems(length: 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: number;
+            inside: boolean;
+            alignWithLabel: boolean;
+            style: any;
+            state: {};
+            dataFilter: (data: AxisItem[]) => AxisItem[];
+        };
+        subTick: {
+            visible: boolean;
+            length: number;
+            inside: boolean;
+            count: number;
+            style: any;
+            state: {};
+        };
+        title: {
+            visible: any;
+            position: any;
+            space: any;
+            autoRotate: boolean;
+            angle: number;
+            textStyle: any;
+            padding: any;
+            shape: {
+                visible: any;
+                space: any;
+                style: any;
+            };
+            background: {
+                visible: any;
+                style: any;
+            };
+            state: {
+                text: {};
+                shape: {};
+                background: {};
+            };
+            pickable: boolean;
+            childrenPickable: boolean;
+        };
+        panel: {
+            visible: any;
+            style: any;
+            state: {};
+        };
+    };
+    protected _getGridAttributes(): {
+        alternateColor: any;
+        alignWithLabel: any;
+        style: any;
+        subGrid: {
+            type: string;
+            visible: any;
+            alternateColor: any;
+            style: any;
+        };
+    };
+    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,112 @@
+import type { IBoundsLike } from '@visactor/vutils';
+import type { IEffect, IModelInitOption, ILayoutRect } from '../../../model/interface';
+import type { ICartesianSeries } from '../../../series/interface';
+import type { IRegion } from '../../../region/interface';
+import type { ICartesianAxisCommonSpec, IAxisHelper, ICartesianAxisCommonTheme } from './interface';
+import type { IOrientType } from '../../../typings/space';
+import type { IBaseScale } from '@visactor/vscale';
+import type { LayoutItem } from '../../../model/layout-item';
+import type { IPoint, StringOrNumber } from '../../../typings';
+import type { IComponentOption } from '../../interface';
+import { ComponentTypeEnum } from '../../interface/type';
+import type { IAxis, ITick } from '../interface';
+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;
+    protected readonly _defaultBandPosition = 0.5;
+    protected readonly _defaultBandInnerPadding = 0.1;
+    protected readonly _defaultBandOuterPadding = 0.3;
+    directionStr?: 'l2r' | 'r2l' | 't2b' | 'b2t';
+    layoutType: LayoutItem['layoutType'];
+    layoutZIndex: number;
+    layoutLevel: number;
+    protected _dataSet: DataSet;
+    layout3dBox?: {
+        width: number;
+        height: number;
+        length: number;
+    };
+    protected _orient: IOrientType;
+    getOrient(): IOrientType;
+    get layoutOrient(): IOrientType;
+    set layoutOrient(v: IOrientType);
+    protected _scales: IBaseScale[];
+    getScales(): IBaseScale[];
+    protected _theme: ICartesianAxisCommonTheme;
+    protected _statisticsDomain: {
+        domain: any[];
+        index: {
+            [key in StringOrNumber]: number;
+        };
+    };
+    getStatisticsDomain(): {
+        domain: any[];
+        index: {
+            [x: string]: number;
+            [x: number]: number;
+        };
+    };
+    protected _tick: ITick | undefined;
+    private _axisStyle;
+    private _latestBounds;
+    private _verticalLimitSize;
+    private _unitText;
+    protected _layoutCache: {
+        width: number;
+        height: number;
+        _lastComputeOutBounds: IBoundsLike;
+    };
+    constructor(spec: T, options: IComponentOption);
+    static createAxis(spec: any, options: IComponentOption, isHorizontal?: boolean): IAxis;
+    static createComponent(spec: any, options: IComponentOption): IAxis | IAxis[];
+    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;
+    protected getSeriesStatisticsField(s: ICartesianSeries): string[];
+    protected _initTickData(sampling: boolean): void;
+    protected _initData(): void;
+    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): {
+        min: number;
+        max: number;
+        values: any[];
+    }[];
+    protected updateSeriesScale(): void;
+    setLayoutStartPosition(pos: Partial<IPoint>): void;
+    computeBoundsInRect(rect: ILayoutRect): ILayoutRect;
+    _boundsInRect(rect: ILayoutRect): IBoundsLike;
+    updateLayoutAttribute(): void;
+    private _getTitleLimit;
+    private _getUpdateAttribute;
+    protected initEvent(): void;
+    private _fixAxisOnZero;
+    protected _layoutCacheProcessing(rect: ILayoutRect): ILayoutRect;
+    _clearLayoutCache(): void;
+    onDataUpdate(): void;
+    protected _transformSpec(): void;
+    private _appendAxisUnit;
+    getVRenderComponents(): IGraphic[];
+}

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

@@ -0,0 +1,40 @@
+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;
+    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;
+        getStatisticsDomain: () => {
+            domain: any[];
+            index: {
+                [x: string]: number;
+                [x: number]: number;
+            };
+        };
+        getAxisType: () => ComponentTypeEnum;
+        getAxisId: () => number;
+        isInverse: () => boolean;
+    };
+    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,56 @@
+import type { SegmentAttributes, AxisLabelOverlap } from '@visactor/vrender-components';
+import type { IBaseScale } from '@visactor/vscale';
+import type { IAxis, IAxisLocationCfg, IDomainLine, ILabel, ITickCallbackOption, 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;
+    getStatisticsDomain?: () => {
+        domain: any[];
+        index: {
+            [key in StringOrNumber]: number;
+        };
+    };
+    getAxisType: () => string;
+    getAxisId: () => number;
+    isInverse: () => boolean;
+    getFields?: () => string[];
+}
+export interface ITimeLayerType {
+    tickStep?: number;
+    timeFormat?: string;
+    timeFormatMode?: 'utc' | 'local';
+    tickCount?: number | ((option: ITickCallbackOption) => number);
+    forceTickCount?: number;
+}
+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';