@visactor/vchart-types 1.6.0

package/types/event/interface.d.ts

@@ -0,0 +1,160 @@
+import type { ILayoutItem } from './../model/interface';
+import type { IGraphic } from '@visactor/vrender-core';
+import type { IElement } from '@visactor/vgrammar-core';
+import type { IChart } from '../chart/interface';
+import type { IModel } from '../model/interface';
+import type { IMark, MarkType } from '../mark/interface';
+import type { VChart } from '../core/vchart';
+import type { DimensionEventParams } from './events/dimension/interface';
+import type { Datum, IPoint, StringOrNumber } from '../typings';
+import type { ChartEvent, Event_Bubble_Level, Event_Source_Type, VGRAMMAR_HOOK_EVENT } from '../constant';
+import type { SeriesType } from '../series/interface';
+import type { TooltipEventParams } from '../component/tooltip/interface/event';
+export type EventType = 'pointerdown' | 'pointerup' | 'pointerupoutside' | 'pointertap' | 'pointerover' | 'pointermove' | 'pointerenter' | 'pointerleave' | 'pointerout' | 'mousedown' | 'mouseup' | 'mouseupoutside' | 'rightdown' | 'rightup' | 'rightupoutside' | 'click' | 'dblclick' | 'mousemove' | 'mouseover' | 'mouseout' | 'mouseenter' | 'mouseleave' | 'wheel' | 'touchstart' | 'touchend' | 'touchendoutside' | 'touchmove' | 'touchcancel' | 'tap' | 'dragstart' | 'drag' | 'dragenter' | 'dragleave' | 'dragover' | 'dragend' | 'drop' | 'pan' | 'panstart' | 'panend' | 'press' | 'pressup' | 'pressend' | 'pinch' | 'pinchstart' | 'pinchend' | 'swipe' | keyof typeof ChartEvent | keyof typeof VGRAMMAR_HOOK_EVENT | string;
+export type EventBubbleLevel = keyof typeof Event_Bubble_Level;
+export type ComponentType = 'axis' | 'dataZoom' | 'indicator' | 'legend' | 'mapLabel' | 'markLine' | 'tooltip' | 'title' | 'label';
+export type EventTargetType = MarkType | ComponentType | SeriesType;
+export type EventSourceType = keyof typeof Event_Source_Type;
+export type EventQuery = {
+    level?: EventBubbleLevel;
+    source?: EventSourceType;
+    nodeName?: string;
+    markName?: string;
+    type?: EventTargetType;
+    id?: StringOrNumber;
+    filter?: (params: Partial<BaseEventParams>) => boolean;
+    throttle?: number;
+    debounce?: number;
+    consume?: boolean;
+};
+export type EventParams = {
+    event?: SuperEvent;
+    value?: any;
+    mark?: IMark;
+    model?: IModel;
+    chart?: IChart;
+    datum?: Datum;
+    node?: IGraphic;
+};
+type SuperEvent = Event & {
+    [key: string]: any;
+};
+export type BaseEventParams = EventParams & {
+    event: SuperEvent;
+    item: IElement;
+    datum: Datum;
+    source: EventSourceType;
+    itemMap: Map<string, any>;
+};
+export type EventCallback<Params extends EventParams> = (params: Params) => boolean | void;
+export type EventFilter = {
+    source: EventSourceType;
+    level: EventBubbleLevel;
+    type: string | null;
+    markName: string | null;
+    nodeName: string | null;
+    userId: StringOrNumber | null;
+    filter: (params: Partial<BaseEventParams>) => boolean | null;
+};
+export type EventHandler<Params extends EventParams> = {
+    callback: EventCallback<Params>;
+    query: EventQuery | null;
+    wrappedCallback?: EventCallback<Params>;
+    filter?: EventFilter;
+};
+export type ExtendEventParam = EventParams & {
+    event?: Event;
+    item?: any;
+    datum?: Datum;
+    source?: EventSourceType;
+    itemMap?: Map<string, any>;
+};
+export type LayoutEventParam = {
+    elements: (ILayoutItem & {
+        type: string;
+    })[];
+} & Partial<BaseEventParams>;
+export type PanEventParam = ExtendEventParam & {
+    delta: [number, number];
+};
+export type ZoomEventParam = ExtendEventParam & {
+    scale: number;
+    scaleCenter: IPoint;
+};
+export type EventParamsDefinition = {
+    pointerdown: BaseEventParams;
+    pointerup: BaseEventParams;
+    pointerupoutside: BaseEventParams;
+    pointertap: BaseEventParams;
+    pointerover: BaseEventParams;
+    pointermove: BaseEventParams;
+    pointerenter: BaseEventParams;
+    pointerleave: BaseEventParams;
+    pointerout: BaseEventParams;
+    mousedown: BaseEventParams;
+    mouseup: BaseEventParams;
+    mouseupoutside: BaseEventParams;
+    rightdown: BaseEventParams;
+    rightup: BaseEventParams;
+    rightupoutside: BaseEventParams;
+    click: BaseEventParams;
+    dblclick: BaseEventParams;
+    mousemove: BaseEventParams;
+    mouseover: BaseEventParams;
+    mouseout: BaseEventParams;
+    mouseenter: BaseEventParams;
+    mouseleave: BaseEventParams;
+    wheel: BaseEventParams;
+    touchstart: BaseEventParams;
+    touchend: BaseEventParams;
+    touchendoutside: BaseEventParams;
+    touchmove: BaseEventParams;
+    touchcancel: BaseEventParams;
+    dragstart: BaseEventParams;
+    drag: BaseEventParams;
+    dragenter: BaseEventParams;
+    dragleave: BaseEventParams;
+    dragover: BaseEventParams;
+    dragend: BaseEventParams;
+    drop: BaseEventParams;
+    tap: BaseEventParams;
+    pan: BaseEventParams;
+    panstart: BaseEventParams;
+    panend: BaseEventParams;
+    press: BaseEventParams;
+    pressup: BaseEventParams;
+    pressend: BaseEventParams;
+    pinch: BaseEventParams;
+    pinchstart: BaseEventParams;
+    pinchend: BaseEventParams;
+    swipe: BaseEventParams;
+    dimension: DimensionEventParams;
+    tooltipShow: TooltipEventParams;
+    tooltipHide: TooltipEventParams;
+    tooltipRelease: TooltipEventParams;
+    afterLayout: LayoutEventParam;
+    [key: string]: ExtendEventParam;
+};
+export interface IEventDispatcher {
+    globalInstance: VChart;
+    register: <Evt extends EventType>(eType: Evt, handler: EventHandler<EventParamsDefinition[Evt]>) => this;
+    unregister: <Evt extends EventType>(eType: Evt, handler?: EventHandler<EventParamsDefinition[Evt]>) => this;
+    dispatch: <Evt extends EventType>(eType: Evt, params?: EventParamsDefinition[Evt], level?: EventBubbleLevel) => this;
+    release: () => void;
+}
+export interface IEvent {
+    on: (<Evt extends EventType>(eType: Evt, callback: EventCallback<EventParamsDefinition[Evt]>) => this) & (<Evt extends EventType>(eType: Evt, query: EventQuery, callback: EventCallback<EventParamsDefinition[Evt]>) => this);
+    off: (<Evt extends EventType>(eType: Evt, callback?: EventCallback<EventParamsDefinition[Evt]>) => this) & (<Evt extends EventType>(eType: Evt, query: EventQuery, callback: EventCallback<EventParamsDefinition[Evt]>) => this);
+    emit: <Evt extends EventType>(eType: Evt, params: EventParamsDefinition[Evt], level?: EventBubbleLevel) => void;
+    release: () => void;
+    getComposedEventMap: () => Map<EventCallback<EventParams>, {
+        eventType: EventType;
+        event: IComposedEvent;
+    }>;
+}
+export interface IComposedEvent {
+    register: <Evt extends EventType>(eType: Evt, handler: EventHandler<EventParamsDefinition[Evt]>) => void;
+    unregister: () => void;
+    dispatch: (v: unknown, opt: unknown) => unknown;
+}
+export {};

package/types/index-lark.d.ts

@@ -0,0 +1,4 @@
+import { VChart } from './core';
+export { VChart };
+export default VChart;
+export * from './core';

package/types/index-wx.d.ts

@@ -0,0 +1,4 @@
+import { VChart } from './core';
+export { VChart };
+export default VChart;
+export * from './core';

package/types/index.d.ts

@@ -0,0 +1,9 @@
+import { VChart } from './vchart-all';
+export default VChart;
+export * from './core';
+export * from './chart';
+export * from './series';
+export * from './mark';
+export * from './component';
+export * from './layout';
+export * from './env';

package/types/interaction/config.d.ts

@@ -0,0 +1,22 @@
+import type { RenderMode } from '../typings/spec/common';
+export declare function getDefaultInteractionConfigByMode(mode: RenderMode): {
+    hover: {
+        enable: boolean;
+        trigger: string;
+        triggerOff: string[];
+    };
+    select: {
+        enable: boolean;
+        trigger: string;
+    };
+} | {
+    hover: {
+        enable: boolean;
+        trigger: string[];
+        triggerOff: string[];
+    };
+    select: {
+        enable: boolean;
+        trigger: string;
+    };
+};

package/types/interaction/dimension-trigger.d.ts

@@ -0,0 +1,32 @@
+import type { IElement } from '@visactor/vgrammar-core';
+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/types/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/types/interaction/drill/index.d.ts

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

package/types/interaction/interaction.d.ts

@@ -0,0 +1,20 @@
+import type { StateValue } from '../compile/mark';
+import type { IElement } from '@visactor/vgrammar-core';
+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/types/interaction/interface.d.ts

@@ -0,0 +1,49 @@
+import type { IElement } from '@visactor/vgrammar-core';
+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/types/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/types/interaction/zoom/index.d.ts

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

package/types/interaction/zoom/zoomable.d.ts

@@ -0,0 +1,80 @@
+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';
+import type { IDelayType } from '../../typings/event';
+export interface ITriggerOption {
+    delayType: IDelayType;
+    delayTime: number;
+    realTime: boolean;
+}
+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, option?: ITriggerOption) => 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, option?: ITriggerOption) => void;
+    initDragEventOfSeries: (s: ISeries, callback?: (delta: [number, number], e: BaseEventParams['event']) => void, option?: ITriggerOption) => any;
+    initDragEventOfRegions: (regions: IRegion[], filter?: (s: ISeries) => boolean, callback?: (delta: [number, number], e: BaseEventParams['event']) => void, option?: ITriggerOption) => void;
+}
+export declare class Zoomable implements IZoomable {
+    private _clickEnable;
+    private _zoomableTrigger;
+    private _eventObj;
+    private _renderMode;
+    initZoomable(evt: IEvent, mode?: RenderMode): void;
+    private _getTriggerEvent;
+    private _zoomEventDispatch;
+    private _bindZoomEventAsRegion;
+    initZoomEventOfSeries(s: ISeries, callback?: (params: {
+        zoomDelta: number;
+        zoomX: number;
+        zoomY: number;
+    }, e: BaseEventParams['event']) => void, option?: ITriggerOption): void;
+    initZoomEventOfRegions(regions: IRegion[], filter?: (s: ISeries) => boolean, callback?: (params: {
+        zoomDelta: number;
+        zoomX: number;
+        zoomY: number;
+    }, e: BaseEventParams['event']) => void, option?: ITriggerOption): void;
+    private _scrollEventDispatch;
+    private _bindScrollEventAsRegion;
+    initScrollEventOfSeries(s: ISeries, callback?: (params: {
+        scrollX: number;
+        scrollY: number;
+    }, e: BaseEventParams['event']) => void, option?: ITriggerOption): void;
+    initScrollEventOfRegions(regions: IRegion[], filter?: (s: ISeries) => boolean, callback?: (params: {
+        scrollX: number;
+        scrollY: number;
+    }, e: BaseEventParams['event']) => void, option?: ITriggerOption): void;
+    private _bindDragEventAsRegion;
+    initDragEventOfSeries(s: ISeries, callback?: (delta: [number, number], e: BaseEventParams['event']) => void, option?: ITriggerOption): void;
+    initDragEventOfRegions(regions: IRegion[], filter?: (s: ISeries) => boolean, callback?: (delta: [number, number], e: BaseEventParams['event']) => void, option?: ITriggerOption): void;
+    protected _handleDrag(params: ExtendEventParam, callback?: (delta: [number, number], e: BaseEventParams['event']) => void, option?: ITriggerOption): void;
+}

package/types/layout/base-layout.d.ts

@@ -0,0 +1,35 @@
+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 {
+    static type: string;
+    leftCurrent: number;
+    topCurrent: number;
+    rightCurrent: number;
+    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;
+    getItemComputeLayoutRect(item: ILayoutItem): {
+        width: number;
+        height: number;
+    };
+    protected _checkAutoIndent(items: ILayoutItem[], layoutTemp: {
+        top: number;
+        left: number;
+        bottom: number;
+        right: number;
+    }): IPadding;
+    private _getOutInLayout;
+}

package/types/layout/grid-layout/grid-layout.d.ts

@@ -0,0 +1,51 @@
+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: string;
+    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 declare const registerGridLayout: () => void;
+export {};

package/types/layout/index.d.ts

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

package/types/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/types/layout/layout3d/index.d.ts

@@ -0,0 +1,31 @@
+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 {
+    static type: string;
+    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;
+    getItemComputeLayoutRect(item: ILayoutItem, extraOffset?: IOffset): {
+        width: number;
+        height: number;
+    };
+    protected _checkAutoIndent(items: ILayoutItem[]): {
+        top: number;
+        left: number;
+        bottom: number;
+        right: number;
+    };
+}
+export declare const registerLayout3d: () => void;
+export {};

package/types/layout/util.d.ts

@@ -0,0 +1,6 @@
+import type { ILayoutItem } from '../model/interface';
+import type { Layout } from './base-layout';
+export declare function layoutLeftInlineItems(items: ILayoutItem[], layout: Layout, limitHeight: number): void;
+export declare function layoutRightInlineItems(items: ILayoutItem[], layout: Layout, limitHeight: number): void;
+export declare function layoutTopInlineItems(items: ILayoutItem[], layout: Layout, limitWidth: number): void;
+export declare function layoutBottomInlineItems(items: ILayoutItem[], layout: Layout, limitWidth: number): void;

package/types/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/type';
+export type IArc3dMark = IMarkRaw<IArc3dMarkSpec>;
+export declare class Arc3dMark extends BaseArcMark<IArc3dMarkSpec> implements IArc3dMark {
+    static readonly type = MarkTypeEnum.arc3d;
+    readonly type: MarkTypeEnum;
+}