@visactor/vchart 1.2.0-beta.6 → 1.2.0-beta.7

package/build/es5/interaction/config.d.ts

@@ -0,0 +1,57 @@
+export declare const defaultInteractionConfig: {
+    "desktop-miniApp": {
+        hover: {
+            enable: boolean;
+            trigger: string;
+            triggerOff: string[];
+        };
+        select: {
+            enable: boolean;
+            trigger: string;
+        };
+    };
+    "desktop-browser": {
+        hover: {
+            enable: boolean;
+            trigger: string;
+            triggerOff: string[];
+        };
+        select: {
+            enable: boolean;
+            trigger: string;
+        };
+    };
+    "mobile-browser": {
+        hover: {
+            enable: boolean;
+            trigger: string;
+            triggerOff: string;
+        };
+        select: {
+            enable: boolean;
+            trigger: string;
+        };
+    };
+    miniApp: {
+        hover: {
+            enable: boolean;
+            trigger: string;
+            triggerOff: string;
+        };
+        select: {
+            enable: boolean;
+            trigger: string;
+        };
+    };
+    lynx: {
+        hover: {
+            enable: boolean;
+            trigger: string;
+            triggerOff: string;
+        };
+        select: {
+            enable: boolean;
+            trigger: string;
+        };
+    };
+};

package/build/es5/interaction/dimension-trigger.d.ts

@@ -0,0 +1,32 @@
+import type { IElement } from '@visactor/vgrammar';
+import type { DimensionEventParams } from '../event/events/dimension/interface';
+import type { IMark } from '../mark/interface';
+import type { IEvent } from '../event/interface';
+import type { IHoverSpec, IInteraction, ISelectSpec, ITrigger, ITriggerOption } from './interface';
+import { MarkSet } from '../mark/mark-set';
+export declare class DimensionTrigger implements ITrigger {
+    readonly event: IEvent;
+    protected readonly interaction: IInteraction;
+    protected _option: ITriggerOption;
+    protected _marks: MarkSet;
+    protected _markReverse: MarkSet;
+    protected _lastDimensionEvent: DimensionEventParams;
+    private _hover;
+    get hover(): IHoverSpec;
+    private _select;
+    get select(): ISelectSpec;
+    constructor(option: ITriggerOption);
+    setStateKeys(fields: string[]): void;
+    registerMark(mark: IMark): void;
+    init(): void;
+    release(): void;
+    protected initEvent(): void;
+    protected releaseEvent(): void;
+    private initConfig;
+    protected getEventElement(params: DimensionEventParams, reverse?: boolean): {
+        el: IElement;
+        mark: IMark;
+    }[];
+    protected dimensionDataEqual(params: DimensionEventParams): boolean;
+    private onHover;
+}

package/build/es5/interaction/drill/drillable.d.ts

@@ -0,0 +1,28 @@
+import type { DataSet, DataView } from '@visactor/vdataset';
+import type { IEvent } from '../../event/interface';
+import type { RenderMode } from '../../typings/spec';
+interface DrillParams {
+    event: IEvent;
+    mode: RenderMode;
+    drillField: () => string;
+    getRawData: () => DataView;
+}
+export interface IDrillable {
+    initDrillable: (params: DrillParams) => void;
+    initDrillableData: (dataSet: DataSet) => void;
+    bindDrillEvent: () => void;
+    drillUp: () => void;
+    drillDown: (drillPath: string[]) => string[];
+}
+export declare class Drillable implements IDrillable {
+    private _drillParams;
+    private _drillInfo;
+    private _getTriggerEvent;
+    private _hideTooltip;
+    initDrillable(params: DrillParams): void;
+    initDrillableData(dataSet: DataSet): void;
+    bindDrillEvent(): void;
+    drillDown(drillPath?: string[]): string[];
+    drillUp(): string[];
+}
+export {};

package/build/es5/interaction/drill/index.d.ts

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

package/build/es5/interaction/interaction.d.ts

@@ -0,0 +1,20 @@
+import type { StateValue } from '../compile/mark';
+import type { IElement } from '@visactor/vgrammar';
+import type { BaseEventParams } from '../event/interface';
+import type { IMark } from '../mark/interface';
+import type { IInteraction } from './interface';
+export declare class Interaction implements IInteraction {
+    private _stateMarks;
+    private _stateElements;
+    static markStateEnable(mark: IMark, state: string): boolean;
+    registerMark(state: StateValue, mark: IMark): void;
+    getStateMark(state: StateValue): IMark[] | null;
+    filterEventMark(params: BaseEventParams, state: StateValue): boolean;
+    getEventElement(stateValue: StateValue): IElement[];
+    getEventElementData(stateValue: StateValue): any[];
+    exchangeEventElement(stateValue: StateValue, element: IElement): void;
+    removeEventElement(stateValue: StateValue, element: IElement): void;
+    addEventElement(stateValue: StateValue, element: IElement): void;
+    clearEventElement(stateValue: StateValue, clearReverse: boolean): void;
+    reverseEventElement(stateValue: StateValue): void;
+}

package/build/es5/interaction/interface.d.ts

@@ -0,0 +1,49 @@
+import type { IElement } from '@visactor/vgrammar';
+import type { IMark } from '../mark/interface';
+import type { RenderMode } from '../typings/spec/common';
+import type { BaseEventParams, IEventDispatcher, EventType } from '../event/interface';
+import type { IModel } from '../model/interface';
+import type { StateValue } from '../compile/mark';
+export interface IInteraction {
+    registerMark: (state: StateValue, mark: IMark) => void;
+    filterEventMark: (params: BaseEventParams, state: StateValue) => boolean;
+    getStateMark: (state: StateValue) => IMark[] | null;
+    getEventElement: (stateValue: StateValue) => IElement[];
+    getEventElementData: (stateValue: StateValue) => any[];
+    addEventElement: (stateValue: StateValue, element: IElement) => void;
+    removeEventElement: (stateValue: StateValue, elements: IElement) => void;
+    exchangeEventElement: (stateValue: StateValue, elements: IElement) => void;
+    clearEventElement: (stateValue: StateValue, clearReverse: boolean) => void;
+    reverseEventElement: (stateValue: StateValue) => void;
+}
+export interface ITrigger {
+    init: () => void;
+    setStateKeys: (fields: string[]) => void;
+    registerMark: (mark: IMark) => void;
+    release: () => void;
+    hover?: IHoverSpec;
+    select?: ISelectSpec;
+}
+export interface ITriggerOption {
+    mode: RenderMode;
+    interaction: IInteraction;
+    eventDispatcher: IEventDispatcher;
+    model: IModel;
+}
+type Trigger = EventType | EventType[];
+export type IHoverSpec = {
+    enable?: boolean;
+    trigger?: Trigger;
+    triggerOff?: Trigger;
+};
+export type ISelectSpec = {
+    enable?: boolean;
+    mode?: 'single' | 'multiple';
+    trigger?: Trigger;
+    triggerOff?: Trigger;
+};
+export interface ITriggerSpec {
+    hover?: IHoverSpec | boolean;
+    select?: ISelectSpec | boolean;
+}
+export {};

package/build/es5/interaction/trigger.d.ts

@@ -0,0 +1,38 @@
+import type { IMark } from '../mark/interface';
+import type { BaseEventParams, IEvent } from '../event/interface';
+import type { IHoverSpec, IInteraction, ISelectSpec, ITrigger, ITriggerOption, ITriggerSpec } from './interface';
+import { MarkSet } from '../mark/mark-set';
+export declare class Trigger implements ITrigger {
+    readonly event: IEvent;
+    protected readonly interaction: IInteraction;
+    protected _spec: ITriggerSpec;
+    protected _option: ITriggerOption;
+    protected _hover: IHoverSpec;
+    get hover(): IHoverSpec;
+    protected _select: ISelectSpec;
+    get select(): ISelectSpec;
+    protected _fields: string[] | null;
+    protected _marks: MarkSet;
+    protected _markReverse: MarkSet;
+    constructor(spec: ITriggerSpec, option: ITriggerOption);
+    setStateKeys(fields: string[]): void;
+    registerMark(mark: IMark): void;
+    init(): void;
+    release(): void;
+    protected initEvent(): void;
+    protected releaseEvent(): void;
+    private initConfig;
+    private onHover;
+    private onUnHover;
+    private onSelect;
+    private onUnSelect;
+    protected hoverItem(params: BaseEventParams): void;
+    protected unhoverItem(): void;
+    protected handleSingleEventHover(params: BaseEventParams): void;
+    protected selectItems(datums: any[]): void;
+    protected clearSelectedItems(): void;
+    protected unselectItems(params: BaseEventParams): void;
+    protected handleSingleEventSelect(params: BaseEventParams): void;
+    protected filterEventMark(params: BaseEventParams): boolean;
+    protected isDatumEqual(datumA: any, datumB: any): boolean;
+}

package/build/es5/interaction/zoom/index.d.ts

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

package/build/es5/interaction/zoom/zoomable.d.ts

@@ -0,0 +1,72 @@
+import type { BaseEventParams, ExtendEventParam, IEvent } from '../../event/interface';
+import type { IRegion } from '../../region/interface';
+import type { RenderMode } from '../../typings/spec';
+import type { ISeries } from '../../series/interface';
+export interface IZoomEventOptions {
+    shouldZoom?: boolean;
+    zoomCallback?: (params: {
+        zoomDelta: number;
+        zoomX: number;
+        zoomY: number;
+    }, e: BaseEventParams['event']) => void;
+    shouldScroll?: boolean;
+    scrollCallback?: (params: {
+        scrollX: number;
+        scrollY: number;
+    }, e: BaseEventParams['event']) => void;
+}
+export interface IZoomable {
+    initZoomable: (evt: IEvent, mode?: RenderMode) => void;
+    initZoomEventOfSeries: (s: ISeries, callback?: (params: {
+        zoomDelta: number;
+        zoomX: number;
+        zoomY: number;
+    }, e: BaseEventParams['event']) => void) => any;
+    initZoomEventOfRegions: (regions: IRegion[], filter?: (s: ISeries) => boolean, callback?: (params: {
+        zoomDelta: number;
+        zoomX: number;
+        zoomY: number;
+    }, e: BaseEventParams['event']) => void) => void;
+    initScrollEventOfSeries: (s: ISeries, callback?: (params: {
+        scrollX: number;
+        scrollY: number;
+    }, e: BaseEventParams['event']) => void) => any;
+    initScrollEventOfRegions: (regions: IRegion[], filter?: (s: ISeries) => boolean, callback?: (params: {
+        scrollX: number;
+        scrollY: number;
+    }, e: BaseEventParams['event']) => void) => void;
+    initDragEventOfSeries: (s: ISeries, callback?: (delta: [number, number], e: BaseEventParams['event']) => void) => any;
+    initDragEventOfRegions: (regions: IRegion[], filter?: (s: ISeries) => boolean, callback?: (delta: [number, number], e: BaseEventParams['event']) => void) => void;
+}
+export declare class Zoomable implements IZoomable {
+    private _clickEnable;
+    private _zoomableTrigger;
+    private _eventObj;
+    private _renderMode;
+    initZoomable(evt: IEvent, mode?: RenderMode): void;
+    private _getTriggerEvent;
+    private _bindZoomEventAsRegion;
+    initZoomEventOfSeries(s: ISeries, callback?: (params: {
+        zoomDelta: number;
+        zoomX: number;
+        zoomY: number;
+    }, e: BaseEventParams['event']) => void): void;
+    initZoomEventOfRegions(regions: IRegion[], filter?: (s: ISeries) => boolean, callback?: (params: {
+        zoomDelta: number;
+        zoomX: number;
+        zoomY: number;
+    }, e: BaseEventParams['event']) => void): void;
+    initScrollEventOfSeries(s: ISeries, callback?: (params: {
+        scrollX: number;
+        scrollY: number;
+    }, e: BaseEventParams['event']) => void): void;
+    initScrollEventOfRegions(regions: IRegion[], filter?: (s: ISeries) => boolean, callback?: (params: {
+        scrollX: number;
+        scrollY: number;
+    }, e: BaseEventParams['event']) => void): void;
+    private _bindScrollEventAsRegion;
+    private _bindDragEventAsRegion;
+    initDragEventOfSeries(s: ISeries, callback?: (delta: [number, number], e: BaseEventParams['event']) => void): void;
+    initDragEventOfRegions(regions: IRegion[], filter?: (s: ISeries) => boolean, callback?: (delta: [number, number], e: BaseEventParams['event']) => void): void;
+    protected _handleDrag(params: ExtendEventParam, callback?: (delta: [number, number], e: BaseEventParams['event']) => void): void;
+}

package/build/es5/layout/base-layout.d.ts

@@ -0,0 +1,28 @@
+import type { utilFunctionCtx } from './../typings/params';
+import type { IChart } from '../chart/interface/chart';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { ILayoutItem } from '../model/interface';
+import type { IBaseLayout } from './interface';
+import type { IPadding, IRect } from '../typings/space';
+import type { IRegion } from '../region/interface';
+export declare class Layout implements IBaseLayout {
+    protected _leftCurrent: number;
+    protected _topCurrent: number;
+    protected _rightCurrent: number;
+    protected _bottomCurrent: number;
+    _chartLayoutRect: IRect;
+    _chartViewBox: IBoundsLike;
+    protected _onError: (msg: string) => void;
+    constructor(_spec?: unknown, ctx?: utilFunctionCtx);
+    layoutItems(_chart: IChart, items: ILayoutItem[], chartLayoutRect: IRect, chartViewBox: IBoundsLike): void;
+    protected layoutNormalItems(normalItems: ILayoutItem[]): void;
+    protected layoutNormalInlineItems(normalItems: ILayoutItem[]): void;
+    protected layoutRegionItems(regionItems: IRegion[], regionRelativeItems: ILayoutItem[]): void;
+    protected layoutAbsoluteItems(absoluteItems: ILayoutItem[]): void;
+    filterRegionsWithID(regions: IRegion[], id: number): ILayoutItem;
+    protected getItemComputeLayoutRect(item: ILayoutItem): {
+        width: number;
+        height: number;
+    };
+    protected _checkAutoIndent(items: ILayoutItem[]): IPadding;
+}

package/build/es5/layout/grid-layout/grid-layout.d.ts

@@ -0,0 +1,50 @@
+import type { utilFunctionCtx } from './../../typings/params';
+import type { IChart } from '../../chart/interface/chart';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { ILayoutItem } from '../../model/interface';
+import type { IBaseLayout, IGridLayoutSpec, ElementSpec } from '../interface';
+import type { IRect } from '../../typings/space';
+type GridSize = {
+    value: number;
+    isUserSetting: boolean;
+    isLayoutSetting: boolean;
+};
+export declare class GridLayout implements IBaseLayout {
+    static type: 'grid';
+    private _chartLayoutRect;
+    private _chartViewBox;
+    protected _col: number;
+    protected _row: number;
+    protected _colSize: GridSize[];
+    protected _rowSize: GridSize[];
+    protected _colElements: ILayoutItem[][];
+    protected _rowElements: ILayoutItem[][];
+    protected _gridInfo: IGridLayoutSpec;
+    protected _elementMap: Map<ILayoutItem, ElementSpec>;
+    protected _onError: (...args: any[]) => void;
+    constructor(gridInfo: IGridLayoutSpec, ctx: utilFunctionCtx);
+    protected standardizationSpec(gridInfo: IGridLayoutSpec): void;
+    protected initUserSetting(): void;
+    protected setSizeFromUserSetting(userSetting: {
+        index: number;
+        size: number | ((maxSize: number) => number);
+    }[], gridSize: GridSize[], gridMax: number, maxSize: number): void;
+    protected clearLayoutSize(): void;
+    protected getItemGridInfo(item: ILayoutItem): ElementSpec;
+    protected getSizeFromGird(spec: ElementSpec, type: 'col' | 'row'): number | undefined;
+    protected getSizeFromUser(spec: ElementSpec, type: 'col' | 'row'): number | undefined;
+    protected setItemLayoutSizeToGrid(item: ILayoutItem, gridSpec: ElementSpec): void;
+    protected layoutGrid(type: 'col' | 'row'): void;
+    protected getItemPosition(item: ILayoutItem): {
+        x: number;
+        y: number;
+    };
+    protected getItemLayoutRect(item: ILayoutItem): {
+        width: number;
+        height: number;
+    };
+    layoutItems(_chart: IChart, items: ILayoutItem[], chartLayoutRect: IRect, chartViewBox: IBoundsLike): void;
+    private layoutAbsoluteItems;
+    protected layoutOneItem(item: ILayoutItem, sizeType: 'user' | 'grid' | 'colGrid' | 'rowGrid', ignoreTag: boolean): void;
+}
+export {};

package/build/es5/layout/index.d.ts

@@ -0,0 +1,6 @@
+import { Layout } from './base-layout';
+import { GridLayout } from './grid-layout/grid-layout';
+import { Layout3d } from './layout3d';
+import type { ILayoutSpec, IGridLayoutSpec } from './interface';
+export { Layout, GridLayout, Layout3d };
+export type { ILayoutSpec, IGridLayoutSpec };

package/build/es5/layout/interface.d.ts

@@ -0,0 +1,45 @@
+import type { utilFunctionCtx } from './../typings/params';
+import type { IRect } from '../typings/space';
+import type { ILayoutItem } from '../model/interface';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { IChart } from '../chart/interface';
+export interface IBaseLayout {
+    layoutItems: LayoutCallBack;
+}
+export type LayoutCallBack = (chart: IChart, item: ILayoutItem[], chartLayoutRect: IRect, chartViewBox: IBoundsLike) => void;
+export interface ILayoutSpecBase {
+    type: string;
+}
+export type ElementSpec = ({
+    modelKey: string;
+    modelIndex: number;
+} | {
+    modelId: string;
+}) & {
+    col: number;
+    colSpan?: number;
+    row: number;
+    rowSpan?: number;
+};
+export interface IGridLayoutSpec extends ILayoutSpecBase {
+    type: 'grid';
+    col: number;
+    row: number;
+    colWidth?: {
+        index: number;
+        size: number | ((maxSize: number) => number);
+    }[];
+    rowHeight?: {
+        index: number;
+        size: number | ((maxSize: number) => number);
+    }[];
+    elements: ElementSpec[];
+}
+export interface IBaseLayoutSpec extends ILayoutSpecBase {
+    type: 'base';
+}
+export type ILayoutSpec = IBaseLayoutSpec | IGridLayoutSpec;
+export interface ILayoutConstructor {
+    type: string;
+    new (spec: ILayoutSpec | any, ctx?: utilFunctionCtx): IBaseLayout;
+}

package/build/es5/layout/label/arc-label.d.ts

@@ -0,0 +1,42 @@
+import type { DataView } from '@visactor/vdataset';
+import type { IArcSeries } from '../../series/interface';
+export interface IArcLabelOpt {
+    series: IArcSeries;
+}
+export declare const arcLabel: (data: Array<DataView>, op: IArcLabelOpt) => any[];
+export declare class ArcLabelLayout {
+    private _series;
+    private _data;
+    private _ellipsisWidth;
+    private _arcLeft;
+    private _arcRight;
+    private _textMeasure;
+    constructor(series: IArcSeries, data: Array<DataView>);
+    updateLabels(): any[];
+    private _setArcs;
+    private _getArc;
+    private _clearArcs;
+    private _setLabelData;
+    private _layoutLabels;
+    private _layoutInsideLabels;
+    private _layoutOutsideLabels;
+    private _coverLabels;
+    private _computeLayoutRadius;
+    private _computePointB;
+    private _computeX;
+    private _computeAlignOffset;
+    private _adjustY;
+    private _checkYRange;
+    private _computeYRange;
+    private _storeY;
+    private _restoreY;
+    private _findNeighborIndex;
+    private _twoWayShift;
+    private _shiftY;
+    private _findNextVisibleIndex;
+    private _computeAlign;
+    private _getFormatLabelText;
+    private _getMeasureSpec;
+    private _measureTextSize;
+    private _getPlotLayout;
+}

package/build/es5/layout/layout3d/index.d.ts

@@ -0,0 +1,23 @@
+import type { IChart } from './../../chart/interface/chart';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { ILayoutItem } from '../../model/interface';
+import type { IRect } from '../../typings/space';
+import type { IRegion } from '../../region/interface';
+import type { IBaseLayout } from '../interface';
+import { Layout } from '../base-layout';
+interface IOffset {
+    offsetLeft: number;
+    offsetRight: number;
+    offsetTop: number;
+    offsetBottom: number;
+}
+export declare class Layout3d extends Layout implements IBaseLayout {
+    layoutItems(_chart: IChart, items: ILayoutItem[], chartLayoutRect: IRect, chartViewBox: IBoundsLike): void;
+    protected layoutZAxisItems(zItems: ILayoutItem[], zRect: IRect): void;
+    protected layoutRegionItems(regionItems: IRegion[], regionRelativeItems: ILayoutItem[], extraOffset?: IOffset): void;
+    protected getItemComputeLayoutRect(item: ILayoutItem, extraOffset?: IOffset): {
+        width: number;
+        height: number;
+    };
+}
+export {};

package/build/es5/mark/arc-3d.d.ts

@@ -0,0 +1,9 @@
+import type { IArc3dMarkSpec } from '../typings';
+import { BaseArcMark } from './arc';
+import type { IMarkRaw } from './interface';
+import { MarkTypeEnum } from './interface';
+export type IArc3dMark = IMarkRaw<IArc3dMarkSpec>;
+export declare class Arc3dMark extends BaseArcMark<IArc3dMarkSpec> implements IArc3dMark {
+    static readonly type = MarkTypeEnum.arc3d;
+    readonly type: MarkTypeEnum;
+}

package/build/es5/mark/arc.d.ts

@@ -0,0 +1,20 @@
+import type { IArcMarkSpec, Datum, StateValueType } from '../typings';
+import { BaseMark } from './base/base-mark';
+import type { IMarkOption, IMarkRaw, IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface';
+export type IArcMark = IMarkRaw<IArcMarkSpec>;
+export declare class BaseArcMark<T extends IArcMarkSpec> extends BaseMark<T> implements IMarkRaw<T> {
+    readonly type: MarkTypeEnum;
+    _unCompileChannel: {
+        centerOffset: boolean;
+        radiusOffset: boolean;
+    };
+    constructor(name: string, option: IMarkOption);
+    protected _getDefaultStyle(): IMarkStyle<T>;
+    protected computeOuterRadius: (key: string, datum: Datum, states: StateValueType, opt: any, superValue: number) => number;
+    protected computeCenter: (key: 'x' | 'y', datum: Datum, states: StateValueType, opt: any, center: number) => number;
+}
+export declare class ArcMark extends BaseArcMark<IArcMarkSpec> implements IArcMark {
+    static readonly type = MarkTypeEnum.arc;
+    readonly type: MarkTypeEnum;
+}

package/build/es5/mark/area.d.ts

@@ -0,0 +1,11 @@
+import type { IAreaMarkSpec } from '../typings/visual';
+import { BaseLineMark } from './base/base-line';
+import type { IMarkRaw, IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface';
+export type IAreaMark = IMarkRaw<IAreaMarkSpec>;
+export declare class AreaMark extends BaseLineMark<IAreaMarkSpec> implements IAreaMark {
+    static readonly type = MarkTypeEnum.area;
+    readonly type = MarkTypeEnum.area;
+    protected _getDefaultStyle(): IMarkStyle<IAreaMarkSpec>;
+    protected _getIgnoreAttributes(): string[];
+}

package/build/es5/mark/base/base-line.d.ts

@@ -0,0 +1,8 @@
+import type { StateValueType } from '../../compile/mark';
+import type { ConvertToMarkStyleSpec, ILineLikeMarkSpec } from '../../typings/visual';
+import { BaseMark } from './base-mark';
+import type { IMarkStyle } from '../interface';
+export declare abstract class BaseLineMark<T extends ILineLikeMarkSpec = ILineLikeMarkSpec> extends BaseMark<T> {
+    protected abstract _getIgnoreAttributes(): string[];
+    setStyle<T>(style: Partial<ConvertToMarkStyleSpec<T>> | Partial<IMarkStyle<T>>, state?: StateValueType, level?: number, stateStyle?: import("../interface").IMarkStateStyle<T>): void;
+}

package/build/es5/mark/base/base-mark.d.ts

@@ -0,0 +1,38 @@
+import type { IAttributeOpt, IModelMarkAttributeContext } from '../../compile/mark/interface';
+import type { Datum, IMarkSpec, ICommonSpec } from '../../typings';
+import type { IMarkRaw, IMarkStateStyle, IMarkStyle, IMarkOption, StyleConvert, MarkInputStyle } from '../interface';
+import { CompilableMark } from '../../compile/mark/compilable-mark';
+import type { StateValueType } from '../../compile/mark';
+export type ExChannelCall = (key: string | number | symbol, datum: Datum, states: StateValueType, opt: unknown, baseValue: unknown) => unknown;
+export declare class BaseMark<T extends ICommonSpec> extends CompilableMark implements IMarkRaw<T> {
+    stateStyle: IMarkStateStyle<T>;
+    protected _option: IMarkOption;
+    protected _attributeContext: IModelMarkAttributeContext;
+    _extensionChannel: {
+        [key: string | number | symbol]: string[];
+    };
+    _computeExChannel: {
+        [key: string | number | symbol]: ExChannelCall;
+    };
+    constructor(name: string, option: IMarkOption);
+    created(): void;
+    initStyleWithSpec(spec: IMarkSpec<T>, key?: string): void;
+    convertAngleToRadian(styleConverter: StyleConvert<number>): StyleConvert<any>;
+    isUserLevel(level: number): boolean;
+    setStyle<U extends keyof T>(style: Partial<IMarkStyle<T>>, state?: StateValueType, level?: number, stateStyle?: IMarkStateStyle<T>): void;
+    getStyle(key: string, state?: StateValueType): any;
+    protected _filterStyle(style: Partial<IMarkStyle<T>>, state: StateValueType, level: number, stateStyle?: IMarkStateStyle<T>): Partial<IMarkStyle<T>>;
+    protected _filterAttribute<U extends keyof T>(attr: U, style: MarkInputStyle<T[U]>, state: StateValueType, level: number, isUserLevel: boolean, stateStyle?: IMarkStateStyle<T>): StyleConvert<T[U]>;
+    setReferer<U extends keyof T>(mark: IMarkRaw<T>, styleKey?: U, state?: StateValueType, stateStyle?: IMarkStateStyle<T>): void;
+    setPostProcess<U extends keyof T>(key: U, postProcessFunc: any, state?: StateValueType): void;
+    getAttribute<U extends keyof T>(key: U, datum: Datum, state?: StateValueType, opt?: IAttributeOpt): any;
+    setAttribute<U extends keyof T>(attr: U, style: MarkInputStyle<T[U]>, state?: StateValueType, level?: number, stateStyle?: IMarkStateStyle<T>): void;
+    protected _getDefaultStyle(): IMarkStyle<T>;
+    protected _styleConvert<U extends keyof T>(style?: MarkInputStyle<T[U]>): StyleConvert<T[U]> | undefined;
+    protected _computeAttribute<U extends keyof T>(key: U, datum: Datum, state: StateValueType, opt: IAttributeOpt): any;
+    protected _computeStateAttribute<U extends keyof T>(stateStyle: any, key: U, datum: Datum, state: StateValueType, opt: IAttributeOpt): any;
+    private _initStyle;
+    private _initSpecStyle;
+    private _computeGradientAttr;
+    private _computeThresholdAttr;
+}

package/build/es5/mark/base/index.d.ts

@@ -0,0 +1,2 @@
+export * from './base-mark';
+export * from './base-line';

package/build/es5/mark/box-plot.d.ts

@@ -0,0 +1,12 @@
+import type { IBoxPlotMarkSpec } from '../typings/visual';
+import { BaseMark } from './base/base-mark';
+import type { IGroupMark } from '@visactor/vgrammar';
+import type { IMarkRaw, IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface';
+export type IBoxPlotMark = IMarkRaw<IBoxPlotMarkSpec>;
+export declare class BoxPlotMark extends BaseMark<IBoxPlotMarkSpec> implements IBoxPlotMark {
+    static readonly type = MarkTypeEnum.boxPlot;
+    readonly type = MarkTypeEnum.boxPlot;
+    protected _getDefaultStyle(): IMarkStyle<IBoxPlotMarkSpec>;
+    protected _initProduct(group?: string | IGroupMark): void;
+}

package/build/es5/mark/cell.d.ts

@@ -0,0 +1,10 @@
+import type { ICellMarkSpec } from '../typings';
+import type { IMarkRaw, IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface';
+import { BaseSymbolMark } from './symbol';
+export type ICellMark = IMarkRaw<ICellMarkSpec>;
+export declare class CellMark extends BaseSymbolMark<ICellMarkSpec> implements ICellMark {
+    static readonly type = MarkTypeEnum.cell;
+    readonly type = MarkTypeEnum.cell;
+    protected _getDefaultStyle(): IMarkStyle<ICellMarkSpec>;
+}

package/build/es5/mark/component.d.ts

@@ -0,0 +1,14 @@
+import type { IGroupMark } from '@visactor/vgrammar';
+import type { ICommonSpec } from '../typings';
+import { BaseMark } from './base/base-mark';
+import type { IMarkOption, IMarkRaw } from './interface';
+import { MarkTypeEnum } from './interface';
+export type IComponentMark = IMarkRaw<ICommonSpec>;
+export declare class ComponentMark extends BaseMark<ICommonSpec> implements IComponentMark {
+    static readonly type = MarkTypeEnum.component;
+    type: string;
+    private _componentType;
+    private _mode;
+    constructor(name: string, option: IMarkOption);
+    protected _initProduct(group?: string | IGroupMark): void;
+}