@visactor/vchart-types 0.10.0-alpha.2

package/types/event/events/dimension/util/polar.d.ts

@@ -0,0 +1,4 @@
+import type { IChart } from '../../../../chart/interface';
+import type { IDimensionInfo } from '../interface';
+import type { ILayoutPoint } from '../../../../typings/layout';
+export declare const getPolarDimensionInfo: (chart: IChart | undefined, pos: ILayoutPoint) => IDimensionInfo[] | null;

package/types/event/events/index.d.ts

@@ -0,0 +1,6 @@
+import { DimensionHoverEvent, DimensionClickEvent } from './dimension';
+export * from './dimension';
+export declare const ComposedEventMapper: {
+    dimensionHover: typeof DimensionHoverEvent;
+    dimensionClick: typeof DimensionClickEvent;
+};

package/types/event/index.d.ts

@@ -0,0 +1,2 @@
+export * from './event';
+export * from './events';

package/types/event/interface.d.ts

@@ -0,0 +1,160 @@
+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';
+import type { ILayoutItem } from '../layout/interface';
+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' | 'markArea' | 'markPoint' | '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-simple.d.ts

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

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,10 @@
+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';
+export * from './event';

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 _getDrillTriggerEvent;
+    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,22 @@
+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;
+    private _disableTriggerEvent;
+    setDisableActiveEffect(disable: boolean): void;
+    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,72 @@
+import type { ElementActiveByLegendSpec, ElementActiveSpec, ElementHighlightByGroupSpec, ElementHighlightByKeySpec, ElementHighlightByLegendSpec, ElementHighlightByNameSpec, ElementHighlightSpec, ElementSelectSpec, 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';
+import type { StringOrNumber } from '../typings/common';
+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;
+    setDisableActiveEffect: (disable: boolean) => 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 | number;
+};
+export interface ITriggerSpec {
+    hover?: IHoverSpec | boolean;
+    select?: ISelectSpec | boolean;
+}
+interface IBaseInteractionSpec {
+    markIds?: StringOrNumber[];
+    markNames?: StringOrNumber[];
+}
+export type IElementActiveSpec = IBaseInteractionSpec & Pick<ElementActiveSpec, 'type' | 'trigger' | 'triggerOff' | 'state'>;
+export type IElementSelectSpec = IBaseInteractionSpec & Pick<ElementSelectSpec, 'type' | 'trigger' | 'triggerOff' | 'state' | 'isMultiple' | 'reverseState'>;
+export type IElementHighlightSpec = IBaseInteractionSpec & Pick<ElementHighlightSpec, 'type' | 'blurState' | 'highlightState' | 'triggerOff' | 'trigger'>;
+export type IElementHighlightByKeySpec = IBaseInteractionSpec & Pick<ElementHighlightByKeySpec, 'type' | 'blurState' | 'highlightState' | 'triggerOff' | 'trigger'>;
+export type IElementHighlightByGroup = IBaseInteractionSpec & Pick<ElementHighlightByGroupSpec, 'type' | 'blurState' | 'highlightState' | 'triggerOff' | 'trigger'>;
+export type IElementActiveByLegend = IBaseInteractionSpec & Pick<ElementActiveByLegendSpec, 'type' | 'filterType' | 'state'>;
+export type IElementHighlightByLegend = IBaseInteractionSpec & Pick<ElementHighlightByLegendSpec, 'type' | 'filterType' | 'blurState' | 'highlightState'>;
+export type IElementHighlightByName = IBaseInteractionSpec & Pick<ElementHighlightByNameSpec, 'type' | 'blurState' | 'highlightState' | 'graphicName' | 'parseData'>;
+export interface ICustomInteraction extends IBaseInteractionSpec {
+    type: string;
+}
+export type IInteractionItemSpec = IElementActiveSpec | IElementSelectSpec | IElementHighlightSpec | IElementHighlightByKeySpec | IElementHighlightByGroup | IElementActiveByLegend | IElementHighlightByLegend | IElementHighlightByName;
+export interface IInteractionSpec {
+    hover?: IHoverSpec | boolean;
+    select?: ISelectSpec | boolean;
+    interactions?: IInteractionItemSpec[];
+}
+export {};

package/types/interaction/trigger.d.ts

@@ -0,0 +1,39 @@
+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;
+    private _isHovered?;
+    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,84 @@
+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 _option;
+    private _zoomableTrigger;
+    private _eventObj;
+    private _renderMode;
+    private _gestureController;
+    private _isGestureListener;
+    initZoomable(evt: IEvent, mode?: RenderMode): void;
+    private _getZoomTriggerEvent;
+    private _zoomEventDispatch;
+    private _getRegionOrSeriesLayout;
+    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,77 @@
+import type { utilFunctionCtx } from '../typings/params';
+import type { IChart } from '../chart/interface/chart';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { IBaseLayout, ILayoutItem } from './interface';
+import type { IOrientType, IPadding, IRect } from '../typings/space';
+import type { ILayoutRect } from '../typings/layout';
+export type LayoutSideType = {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+};
+export interface IOffset {
+    offsetLeft: number;
+    offsetRight: number;
+    offsetTop: number;
+    offsetBottom: number;
+}
+type overlapInfo = {
+    items: ILayoutItem[];
+    rect: ILayoutRect;
+};
+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);
+    protected _layoutInit(_chart: IChart, items: ILayoutItem[], chartLayoutRect: IRect, chartViewBox: IBoundsLike): void;
+    protected _layoutNormalItems(items: ILayoutItem[]): void;
+    protected _groupItems(items: ILayoutItem[]): {
+        regionItems: ILayoutItem[];
+        relativeItems: ILayoutItem[];
+        relativeOverlapItems: ILayoutItem[];
+        allRelatives: ILayoutItem[];
+        overlapItems: {
+            left: overlapInfo;
+            top: overlapInfo;
+            right: overlapInfo;
+            bottom: overlapInfo;
+            z: overlapInfo;
+        };
+    };
+    layoutItems(_chart: IChart, items: ILayoutItem[], chartLayoutRect: IRect, chartViewBox: IBoundsLike): void;
+    protected _processAutoIndent(regionItems: ILayoutItem[], relativeItems: ILayoutItem[], relativeOverlapItems: ILayoutItem[], overlapItems: {
+        [key in IOrientType]: overlapInfo;
+    }, allRelatives: ILayoutItem[], layoutTemp: LayoutSideType): void;
+    protected layoutNormalItems(normalItems: ILayoutItem[]): void;
+    protected layoutNormalInlineItems(normalItems: ILayoutItem[]): void;
+    protected _layoutRelativeOverlap(orient: IOrientType, info: overlapInfo): void;
+    protected _layoutRelativeItem(item: ILayoutItem, layoutRect: ILayoutRect): void;
+    protected _layoutRegionItem(regionItems: ILayoutItem[], regionRelativeTotalWidth: number, regionRelativeTotalHeight: number): {
+        regionHeight: number;
+        regionWidth: number;
+    };
+    protected layoutRegionItems(regionItems: ILayoutItem[], regionRelativeItems: ILayoutItem[], regionRelativeOverlapItems: ILayoutItem[], overlapItems?: {
+        [key in IOrientType]: overlapInfo;
+    }): void;
+    protected layoutAbsoluteItems(absoluteItems: ILayoutItem[]): void;
+    filterRegionsWithID(items: ILayoutItem[], 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;
+}
+export {};

package/types/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 { IBaseLayout, IGridLayoutSpec, ElementSpec, ILayoutItem } 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 };