@visactor/vchart-types 0.16.17-alpha.0

package/types/component/crosshair/config.d.ts

@@ -0,0 +1,12 @@
+import type { RenderMode } from '../../typings/spec';
+export declare function getDefaultCrosshairTriggerEventByMode(mode: RenderMode): {
+    click: string;
+    hover: string;
+    hoverOut: string;
+    clickOut: string;
+} | {
+    click: string;
+    hover: string[];
+    hoverOut: string;
+    clickOut: string;
+};

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

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

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

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

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

@@ -0,0 +1,71 @@
+import type { IPadding, StringOrNumber, ILineMarkSpec, IRectMarkSpec, ITextMarkSpec } from '../../../typings';
+import type { IAxis } from '../../axis/interface';
+import type { IComponentSpec } from '../../base/interface';
+import type { IComponent } from '../../interface';
+export interface ICrossHair extends IComponent {
+    clearAxisValue?: () => void;
+    setAxisValue?: (v: StringOrNumber, axis: IAxis) => void;
+    layoutByValue?: (v?: number) => void;
+    hide?: () => void;
+}
+export type CrossHairTrigger = 'click' | 'hover' | ['click', 'hover'];
+export interface ICommonCrosshairSpec extends IComponentSpec {
+    trigger?: CrossHairTrigger;
+    triggerOff?: CrossHairTrigger | 'none';
+    labelZIndex?: number;
+    gridZIndex?: number;
+}
+export interface ICartesianCrosshairSpec extends ICommonCrosshairSpec {
+    xField?: ICrosshairCategoryFieldSpec;
+    yField?: ICrosshairCategoryFieldSpec;
+}
+export interface IPolarCrosshairSpec extends ICommonCrosshairSpec {
+    categoryField?: ICrosshairCategoryFieldSpec;
+    valueField?: ICrosshairValueFieldSpec;
+}
+export interface ICrosshairCategoryFieldSpec extends ICrosshairDataBindSpec {
+    visible: boolean;
+    line?: ICrosshairLineSpec | ICrosshairRectSpec;
+    label?: ICrosshairLabelSpec;
+}
+export interface ICrosshairValueFieldSpec {
+    visible: boolean;
+    line?: ICrosshairLineSpec;
+    label?: ICrosshairLabelSpec;
+}
+export type ICrosshairLineStyle = Pick<ILineMarkSpec, 'stroke' | 'strokeOpacity' | 'opacity' | 'lineDash' | 'lineWidth'>;
+export type ICrosshairRectStyle = ICrosshairLineStyle & Pick<IRectMarkSpec, 'fill' | 'fillOpacity' | 'cornerRadius'>;
+export interface ICrosshairLineSpec {
+    visible?: boolean;
+    type?: 'line';
+    width?: number;
+    smooth?: boolean;
+    style?: ICrosshairLineStyle;
+}
+export interface ICrosshairRectSpec {
+    visible?: boolean;
+    type?: 'rect';
+    width?: number | string;
+    style?: ICrosshairRectStyle;
+}
+export interface ICrosshairLabelSpec {
+    visible?: boolean;
+    formatMethod?: (text: StringOrNumber | string[]) => string | string[];
+    style?: Partial<ITextMarkSpec>;
+    labelBackground?: ICrosshairLabelBackgroundSpec;
+}
+export interface ICrosshairLabelBackgroundSpec {
+    visible?: boolean;
+    minWidth?: number;
+    maxWidth?: number;
+    padding?: IPadding | number | number[];
+    style: Partial<IRectMarkSpec>;
+}
+export interface ICrosshairDataBindSpec {
+    bindingAxesIndex?: number[];
+    defaultSelect?: {
+        axisIndex: number;
+        datum: StringOrNumber;
+    };
+}
+export type ICrosshairSpec = ICartesianCrosshairSpec | IPolarCrosshairSpec;

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

@@ -0,0 +1,9 @@
+import type { ICartesianCrosshairSpec, ICommonCrosshairSpec, ICrosshairCategoryFieldSpec, ICrosshairValueFieldSpec, IPolarCrosshairSpec } from '.';
+export interface ICrosshairTheme extends ICommonCrosshairSpec {
+    bandField?: Partial<ICrosshairCategoryFieldSpec>;
+    linearField?: Partial<ICrosshairValueFieldSpec>;
+    xField?: Partial<ICartesianCrosshairSpec['xField']>;
+    yField?: Partial<ICartesianCrosshairSpec['yField']>;
+    categoryField?: Partial<IPolarCrosshairSpec['categoryField']>;
+    valueField?: Partial<IPolarCrosshairSpec['valueField']>;
+}

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

@@ -0,0 +1,78 @@
+import type { IComponentOption } from '../interface';
+import { ComponentTypeEnum } from '../interface/type';
+import type { IPolarCrosshairSpec } from './interface';
+import type { IPolarAxis } from '../axis/polar/interface';
+import type { IPoint, StringOrNumber } from '../../typings';
+import type { IHair } from './base';
+import { BaseCrossHair } from './base';
+import type { IGraphic } from '@visactor/vrender-core';
+type IBound = {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+};
+type IAxisInfo = Map<number, IBound & {
+    axis: IPolarAxis;
+}>;
+export declare class PolarCrossHair<T extends IPolarCrosshairSpec = IPolarCrosshairSpec> extends BaseCrossHair<T> {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    currValueX: Map<number, {
+        v: StringOrNumber;
+        axis: IPolarAxis;
+        [key: string]: any;
+    }>;
+    currValueY: Map<number, {
+        v: StringOrNumber;
+        axis: IPolarAxis;
+        [key: string]: any;
+    }>;
+    xHair: IHair | undefined;
+    yHair: (IHair & {
+        smooth: boolean;
+    }) | undefined;
+    private _cacheXCrossHairInfo;
+    private _cacheYCrossHairInfo;
+    private _radiusCrosshair;
+    private _radiusLabelCrosshair;
+    private _angleCrosshair;
+    private _angleLabelCrosshair;
+    static createComponent(spec: any, options: IComponentOption): PolarCrossHair<any> | PolarCrossHair<IPolarCrosshairSpec>[];
+    constructor(spec: T, options: IComponentOption);
+    protected _showDefaultCrosshair(): void;
+    hide(): void;
+    findAllAxisContains(relativeX: number, relativeY: number): {
+        xAxisMap: Map<number, {
+            x1: number;
+            y1: number;
+            x2: number;
+            y2: number;
+        } & {
+            axis: IPolarAxis;
+        }>;
+        yAxisMap: Map<number, {
+            x1: number;
+            y1: number;
+            x2: number;
+            y2: number;
+        } & {
+            axis: IPolarAxis;
+        }>;
+    };
+    getAllAxisValues(axisMap: IAxisInfo, point: IPoint, currValue: Map<number, {
+        v: StringOrNumber;
+        axis: IPolarAxis;
+        [key: string]: any;
+    }>): boolean;
+    protected _layoutCrosshair(relativeX: number, relativeY: number): void;
+    private layoutByValue;
+    private _layoutVertical;
+    private _layoutHorizontal;
+    protected _parseFieldInfo(): void;
+    private _updateCrosshairLabel;
+    getVRenderComponents(): IGraphic[];
+}
+export declare const registerPolarCrossHair: () => void;
+export {};

package/types/component/crosshair/util.d.ts

@@ -0,0 +1,10 @@
+import type { Tag } from '@visactor/vrender-components';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { Datum } from '../../typings';
+import type { IChart } from '../../chart/interface';
+import type { ICrosshairTheme } from './interface';
+import type { IModelOption } from '../../model/interface';
+export declare function limitTagInBounds(shape: Tag, bounds: IBoundsLike): void;
+export declare function getDatumByValue(data: Datum[], value: number, startField: string, endField?: string): Datum | null;
+export declare const getCartesianCrosshairTheme: (option: Partial<IModelOption>, chart: IChart) => ICrosshairTheme;
+export declare const getPolarCrosshairTheme: (option: Partial<IModelOption>, chart: IChart) => ICrosshairTheme;

package/types/component/custom-mark/custom-mark.d.ts

@@ -0,0 +1,34 @@
+import { BaseComponent } from '../base/base-component';
+import { ComponentTypeEnum } from '../interface/type';
+import type { IComponentOption } from '../interface';
+import type { IRegion } from '../../region/interface';
+import type { IModelRenderOption } from '../../model/interface';
+import type { LayoutItem } from '../../model/layout-item';
+import type { EnableMarkType, ICustomMarkGroupSpec, ICustomMarkSpec } from '../../typings';
+import type { MarkTypeEnum } from '../../mark/interface';
+import type { IGraphic } from '@visactor/vrender-core';
+export declare class CustomMark extends BaseComponent<any> {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    layoutType: LayoutItem['layoutType'];
+    layoutZIndex: LayoutItem['layoutZIndex'];
+    layoutLevel: number;
+    protected _spec: (ICustomMarkSpec<Exclude<EnableMarkType, MarkTypeEnum.group>> | ICustomMarkGroupSpec)[];
+    static createComponent(spec: any, options: IComponentOption): CustomMark[];
+    created(): void;
+    protected initMarks(): void;
+    private _createExtensionMark;
+    initEvent(): void;
+    _compareSpec(): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    changeRegions(regions: IRegion[]): void;
+    getVRenderComponents(): IGraphic[];
+    onRender(ctx: IModelRenderOption): void;
+    private _getMarkAttributeContext;
+}
+export declare const registerCustomMark: () => void;

package/types/component/custom-mark/index.d.ts

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

package/types/component/data-zoom/constant.d.ts

@@ -0,0 +1,4 @@
+export declare enum IFilterMode {
+    filter = "filter",
+    axis = "axis"
+}

package/types/component/data-zoom/data-filter-base-component.d.ts

@@ -0,0 +1,122 @@
+import { BaseComponent } from '../base/base-component';
+import type { IEffect, IModelInitOption, ILayoutRect } from '../../model/interface';
+import type { LayoutItem } from '../../model/layout-item';
+import type { IComponent, IComponentOption } from '../interface';
+import type { AdaptiveSpec, IOrientType, StringOrNumber } from '../../typings';
+import type { IBaseScale } from '@visactor/vscale';
+import type { ICartesianBandAxisSpec } from '../axis/cartesian';
+import type { IBoundsLike } from '@visactor/vutils';
+import { IFilterMode } from './constant';
+import type { IDataFilterComponent, IDataFilterComponentSpec, IRoamDragSpec, IRoamScrollSpec, IRoamZoomSpec } from './interface';
+import type { BaseEventParams } from '../../event/interface';
+import type { AbstractComponent } from '@visactor/vrender-components';
+export declare abstract class DataFilterBaseComponent<T extends IDataFilterComponentSpec = IDataFilterComponentSpec> extends BaseComponent<AdaptiveSpec<T, 'width' | 'height'>> implements IDataFilterComponent {
+    layoutType: LayoutItem['layoutType'];
+    protected _component: AbstractComponent;
+    protected _orient: IOrientType;
+    protected _isHorizontal: boolean;
+    protected _auto?: boolean;
+    protected _fixedBandSize?: number;
+    protected _cacheRect?: ILayoutRect;
+    protected _cacheVisibility?: boolean;
+    get orient(): IOrientType;
+    get layoutOrient(): IOrientType;
+    set layoutOrient(v: IOrientType);
+    protected _stateScale: IBaseScale;
+    protected _relatedAxisComponent: IComponent;
+    protected _originalStateFields: Record<number, string | number>;
+    protected _seriesUserId?: StringOrNumber[];
+    protected _seriesIndex?: number[];
+    protected _regionUserId: string[];
+    protected _regionIndex: number[];
+    protected _newDomain: any[];
+    protected _startValue: number | string;
+    protected _endValue: number | string;
+    protected _start: number;
+    protected _end: number;
+    protected _minSpan: number;
+    protected _maxSpan: number;
+    protected _field: string | undefined;
+    protected _stateField: string;
+    protected _valueField?: string;
+    protected _width: number;
+    protected _height: number;
+    protected _filterMode: IFilterMode;
+    protected _activeRoam: boolean;
+    protected _zoomAttr: IRoamZoomSpec;
+    protected _dragAttr: IRoamDragSpec;
+    protected _scrollAttr: IRoamScrollSpec;
+    setStartAndEnd(start: number, end: number): void;
+    enableInteraction(): void;
+    disableInteraction(): void;
+    zoomIn(location?: {
+        x: number;
+        y: number;
+    }): void;
+    zoomOut(location?: {
+        x: number;
+        y: number;
+    }): void;
+    protected abstract _getComponentAttrs(): any;
+    protected abstract _createOrUpdateComponent(): void;
+    protected abstract _computeWidth(): number;
+    protected abstract _computeHeight(): number;
+    protected abstract _handleDataCollectionChange(): void;
+    protected _handleChange(start: number, end: number, updateComponent?: boolean): void;
+    effect: IEffect;
+    protected _visible: boolean;
+    get visible(): boolean;
+    constructor(spec: T, options: IComponentOption);
+    created(): void;
+    protected _setAxisFromSpec(): void;
+    protected _setRegionsFromSpec(): void;
+    onDataUpdate(): void;
+    protected _computeDomainOfStateScale(isContinuous?: boolean): any;
+    protected _initEvent(): void;
+    protected _initData(): void;
+    setAttrFromSpec(): void;
+    protected _statePointToData(state: number): any;
+    protected _dataToStatePoint(data: number | string): number;
+    protected _modeCheck(statePoint: 'start' | 'end', mode: string): any;
+    protected _setStateFromSpec(): void;
+    private _parseFieldOfSeries;
+    protected _initStateScale(): void;
+    init(option: IModelInitOption): void;
+    protected _addTransformToSeries(): void;
+    onRender(ctx: any): void;
+    _compareSpec(): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    reInit(theme?: any): void;
+    changeRegions(): void;
+    protected update(ctx: IComponentOption): void;
+    protected resize(ctx: IComponentOption): void;
+    protected _parseDomainFromState(startValue: number | string, endValue: number | string): any;
+    protected _handleStateChange: (startValue: number, endValue: number) => boolean;
+    protected _handleChartZoom: (params: {
+        zoomDelta: number;
+        zoomX?: number;
+        zoomY?: number;
+    }) => void;
+    protected _handleChartScroll: (params: {
+        scrollX: number;
+        scrollY: number;
+    }, e: BaseEventParams['event']) => void;
+    protected _handleChartDrag: (delta: [number, number], e: BaseEventParams['event']) => void;
+    protected _handleChartMove: (value: number, rate: number) => void;
+    protected _initCommonEvent(): void;
+    updateLayoutAttribute(): void;
+    _boundsInRect(rect: ILayoutRect): IBoundsLike;
+    hide(): void;
+    show(): void;
+    protected _getAxisBandSize(axisSpec?: ICartesianBandAxisSpec): {
+        bandSize: number;
+        maxBandSize: number;
+        minBandSize: number;
+    };
+    protected _autoUpdate(rect?: ILayoutRect): boolean;
+}

package/types/component/data-zoom/data-zoom/data-zoom.d.ts

@@ -0,0 +1,65 @@
+import type { IComponentOption } from '../../interface';
+import { ComponentTypeEnum } from '../../interface/type';
+import { DataFilterBaseComponent } from '../data-filter-base-component';
+import { DataZoom as DataZoomComponent } from '@visactor/vrender-components';
+import type { IRectGraphicAttribute, ISymbolGraphicAttribute, IGraphic } from '@visactor/vrender-core';
+import type { Datum } from '../../../typings';
+import type { ILinearScale, IBaseScale } from '@visactor/vscale';
+import type { IDataZoomSpec } from './interface';
+export declare class DataZoom<T extends IDataZoomSpec = IDataZoomSpec> extends DataFilterBaseComponent<T> {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    layoutZIndex: number;
+    layoutLevel: number;
+    protected _component: DataZoomComponent;
+    protected _valueScale: ILinearScale;
+    protected _backgroundSize: number;
+    protected _middleHandlerSize: number;
+    protected _startHandlerSize: number;
+    protected _endHandlerSize: number;
+    static createComponent(spec: any, options: IComponentOption): DataZoom<any> | DataZoom<IDataZoomSpec>[];
+    constructor(spec: T, options: IComponentOption);
+    created(): void;
+    setAttrFromSpec(): void;
+    protected _prepareSpecBeforeMergingTheme(originalSpec: T): T;
+    onLayoutEnd(ctx: any): void;
+    protected _initValueScale(): void;
+    protected _updateScaleRange(): void;
+    protected _computeDomainOfValueScale(): number[];
+    protected _computeMiddleHandlerSize(): number;
+    protected _computeWidth(): number;
+    protected _computeHeight(): number;
+    protected _isScaleValid(scale: IBaseScale | ILinearScale): boolean;
+    protected _dataToPositionX: (datum: Datum) => number;
+    protected _dataToPositionX2: (datum: Datum) => number;
+    protected _dataToPositionY: (datum: Datum) => number;
+    protected _dataToPositionY2: (datum: Datum) => number;
+    protected _createOrUpdateComponent(): void;
+    protected _handleChange(start: number, end: number, updateComponent?: boolean): void;
+    protected _handleDataCollectionChange(): void;
+    protected _getComponentAttrs(): {
+        backgroundStyle: IRectGraphicAttribute;
+        startHandlerStyle: ISymbolGraphicAttribute;
+        middleHandlerStyle: {
+            visible: boolean;
+            icon: ISymbolGraphicAttribute;
+            background: any;
+        };
+        endHandlerStyle: ISymbolGraphicAttribute;
+        startTextStyle: unknown;
+        endTextStyle: unknown;
+        selectedBackgroundStyle: IRectGraphicAttribute;
+        dragMaskStyle: IRectGraphicAttribute;
+        backgroundChartStyle: {
+            line: any;
+            area: any;
+        };
+        selectedBackgroundChartStyle: {
+            line: any;
+            area: any;
+        };
+    };
+    getVRenderComponents(): IGraphic[];
+}
+export declare const registerDataZoom: () => void;

package/types/component/data-zoom/data-zoom/index.d.ts

@@ -0,0 +1,2 @@
+export * from './data-zoom';
+export * from './interface';

package/types/component/data-zoom/data-zoom/interface.d.ts

@@ -0,0 +1,59 @@
+import type { IMarkSpec } from '../../../typings/spec';
+import type { IAreaMarkSpec, ILineMarkSpec, IRectMarkSpec, ISymbolMarkSpec, ITextMarkSpec } from '../../../typings/visual';
+import type { IComponentSpec } from '../../base/interface';
+import type { IComponent } from '../../interface';
+import type { IFilterMode } from '../constant';
+import type { IDataFilterComponentSpec } from '../interface';
+export type IDataZoom = IComponent;
+export interface IDataZoomStyle {
+    showDetail?: 'auto' | boolean;
+    middleHandler?: {
+        visible?: boolean;
+        icon?: ISymbolMarkSpec;
+        background?: {
+            size?: number;
+        } & IRectMarkSpec;
+    };
+    background?: {
+        size?: number;
+    } & IRectMarkSpec;
+    startHandler?: ISymbolMarkSpec;
+    endHandler?: ISymbolMarkSpec;
+    startText?: {
+        padding?: number;
+    } & ITextMarkSpec;
+    endText?: {
+        padding?: number;
+    } & ITextMarkSpec;
+    dragMask?: IRectMarkSpec;
+    selectedBackground?: IRectMarkSpec;
+    backgroundChart?: {
+        line?: ILineMarkSpec;
+        area?: IAreaMarkSpec;
+    };
+    selectedBackgroundChart?: {
+        line?: ILineMarkSpec;
+        area?: IAreaMarkSpec;
+    };
+}
+export interface IDataZoomSpec extends IDataZoomStyle, IDataFilterComponentSpec {
+    filterMode?: IFilterMode;
+    valueField?: string;
+    startText?: {
+        padding?: number;
+        style?: IMarkSpec<ITextMarkSpec>;
+        formatMethod?: (text: string | number) => string | string[];
+    };
+    endText?: {
+        padding?: number;
+        style?: IMarkSpec<ITextMarkSpec>;
+        formatMethod?: (text: string | number) => string | string[];
+    };
+    brushSelect?: boolean;
+}
+export type IDataZoomTheme = IComponentSpec & IDataZoomStyle & {
+    orient?: IDataZoomSpec['orient'];
+    width?: IDataZoomSpec['width'];
+    height?: IDataZoomSpec['height'];
+    brushSelect?: boolean;
+};

package/types/component/data-zoom/index.d.ts

@@ -0,0 +1,2 @@
+export * from './data-zoom';
+export * from './scroll-bar';

package/types/component/data-zoom/interface.d.ts

@@ -0,0 +1,59 @@
+import type { IOrientType } from '../../typings';
+import type { IDelayType } from '../../typings/event';
+import type { IComponentSpec } from '../base/interface';
+import type { IComponent } from '../interface';
+export interface IDataFilterComponentSpec extends Omit<IComponentSpec, 'width' | 'height'> {
+    visible?: boolean;
+    orient?: IOrientType;
+    width?: 'auto' | number;
+    height?: 'auto' | number;
+    field?: string;
+    axisId?: string;
+    axisIndex?: number;
+    regionIndex?: number | number[];
+    start?: number;
+    end?: number;
+    startValue?: number | string;
+    endValue?: number | string;
+    valueField?: string;
+    rangeMode?: [string, string];
+    autoIndent?: boolean;
+    auto?: boolean;
+    zoomLock?: boolean;
+    minSpan?: number;
+    maxSpan?: number;
+    minValueSpan?: number;
+    maxValueSpan?: number;
+    delayType?: IDelayType;
+    delayTime?: number;
+    roamZoom?: IRoamZoomSpec | boolean;
+    roamDrag?: IRoamDragSpec | boolean;
+    roamScroll?: IRoamScrollSpec | boolean;
+    realTime?: boolean;
+}
+export interface IRoamDragSpec extends IRoamSpec {
+    reverse?: boolean;
+}
+export interface IRoamScrollSpec extends IRoamSpec {
+    reverse?: boolean;
+}
+export interface IRoamZoomSpec extends IRoamSpec {
+    focus?: boolean;
+}
+export interface IRoamSpec {
+    enable?: boolean;
+    rate?: number;
+}
+export interface IDataFilterComponent extends IComponent {
+    setStartAndEnd: (start: number, end: number) => void;
+    enableInteraction: () => void;
+    disableInteraction: () => void;
+    zoomIn: (location?: {
+        x: number;
+        y: number;
+    }) => void;
+    zoomOut: (location?: {
+        x: number;
+        y: number;
+    }) => void;
+}

package/types/component/data-zoom/scroll-bar/index.d.ts

@@ -0,0 +1,2 @@
+export * from './interface';
+export * from './scroll-bar';

package/types/component/data-zoom/scroll-bar/interface.d.ts

@@ -0,0 +1,23 @@
+import type { ILayoutItemSpec } from '../../../model/interface';
+import type { IPadding } from '../../../typings';
+import type { IRectMarkSpec } from '../../../typings/visual';
+import type { IFilterMode } from '../constant';
+import type { IDataFilterComponentSpec } from '../interface';
+export interface IScrollBarStyle {
+    rail?: Omit<IRectMarkSpec, 'width' | 'height'>;
+    slider?: Omit<IRectMarkSpec, 'width' | 'height'>;
+}
+export interface IScrollBarSpec extends IDataFilterComponentSpec, IScrollBarStyle {
+    filterMode?: IFilterMode;
+    round?: boolean;
+    innerPadding?: number | number[] | IPadding;
+    range?: [number, number];
+    limitRange?: [number, number];
+}
+export type IScrollBarTheme = ILayoutItemSpec & IScrollBarStyle & {
+    orient?: IScrollBarSpec['orient'];
+    width?: IScrollBarSpec['width'];
+    height?: IScrollBarSpec['height'];
+    round?: IScrollBarSpec['round'];
+    innerPadding?: IScrollBarSpec['innerPadding'];
+};

package/types/component/data-zoom/scroll-bar/scroll-bar.d.ts

@@ -0,0 +1,29 @@
+import type { IComponentOption } from '../../interface';
+import { ComponentTypeEnum } from '../../interface/type';
+import { DataFilterBaseComponent } from '../data-filter-base-component';
+import type { ScrollBarAttributes } from '@visactor/vrender-components';
+import { ScrollBar as ScrollBarComponent } from '@visactor/vrender-components';
+import type { IGraphic } from '@visactor/vrender-core';
+import type { IScrollBarSpec } from './interface';
+export declare class ScrollBar<T extends IScrollBarSpec = IScrollBarSpec> extends DataFilterBaseComponent<T> {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    layoutZIndex: number;
+    layoutLevel: number;
+    protected _component: ScrollBarComponent;
+    static createComponent(spec: any, options: IComponentOption): ScrollBar<any> | ScrollBar<IScrollBarSpec>[];
+    constructor(spec: T, options: IComponentOption);
+    setAttrFromSpec(): void;
+    onLayoutEnd(ctx: any): void;
+    protected _updateScaleRange(): void;
+    protected _computeWidth(): number;
+    protected _computeHeight(): number;
+    protected _createOrUpdateComponent(): void;
+    protected _handleChange(start: number, end: number, updateComponent?: boolean): void;
+    protected _handleDataCollectionChange(): void;
+    protected _initCommonEvent(): void;
+    protected _getComponentAttrs(): Partial<ScrollBarAttributes>;
+    getVRenderComponents(): IGraphic[];
+}
+export declare const registerScrollBar: () => void;

package/types/component/data-zoom/util.d.ts

@@ -0,0 +1,19 @@
+export interface IDataFilterWithNewDomainOption {
+    getNewDomain: () => any[];
+    isContinuous: () => boolean;
+    field: () => string;
+}
+export declare const dataFilterWithNewDomain: (data: Array<any>, op: IDataFilterWithNewDomainOption) => any[];
+export interface IDataFilterComputeDomainOption {
+    input: {
+        dataCollection: any[];
+        stateFields: string[];
+        valueFields: string[];
+        method: 'sum';
+    };
+    output: {
+        stateField: string;
+        valueField: string;
+    };
+}
+export declare const dataFilterComputeDomain: (data: Array<any>, op: IDataFilterComputeDomainOption) => any[];