dockview-core/dist/cjs/dockview/dockviewGroupPanelModel.d.ts

Zero dependency layout manager supporting tabs, groups, grids and splitviews for vanilla TypeScript

import { DockviewApi } from '../api/component.api';
import { PanelTransfer } from '../dnd/dataTransfer';
import { Position } from '../dnd/droptarget';
import { DockviewComponent } from './dockviewComponent';
import { DockviewEvent, Event } from '../events';
import { DockviewGroupDropLocation, DockviewWillShowOverlayLocationEvent } from './events';
import { IViewSize } from '../gridview/gridview';
import { CompositeDisposable } from '../lifecycle';
import { IPanel, PanelInitParameters, PanelUpdateEvent, Parameters } from '../panel/types';
import { GroupDragEvent, TabDragEvent } from './components/titlebar/tabsContainer';
import { DockviewGroupPanel } from './dockviewGroupPanel';
import { IDockviewPanel } from './dockviewPanel';
import { DockviewDndOverlayEvent, DockviewHeaderDirection, DockviewHeaderPosition } from './options';
import { OverlayRenderContainer } from '../overlay/overlayRenderContainer';
import { TitleEvent } from '../api/dockviewPanelApi';
import { Contraints } from '../gridview/gridviewPanel';
import { DropTargetAnchorContainer } from '../dnd/dropTargetAnchorContainer';
import { ITabGroup, SerializedTabGroup, TabGroupOptions } from './tabGroup';
import { EdgeGroupPosition } from './dockviewShell';
interface GroupMoveEvent {
    groupId: string;
    itemId?: string;
    target: Position;
    index?: number;
    tabGroupId?: string;
}
interface CoreGroupOptions {
    locked?: DockviewGroupPanelLocked;
    hideHeader?: boolean;
    headerPosition?: 'top' | 'bottom' | 'left' | 'right';
    skipSetActive?: boolean;
    constraints?: Partial<Contraints>;
    initialWidth?: number;
    initialHeight?: number;
}
export interface GroupOptions extends CoreGroupOptions {
    readonly panels?: IDockviewPanel[];
    readonly activePanel?: IDockviewPanel;
    readonly id?: string;
}
export interface GroupPanelViewState extends CoreGroupOptions {
    views: string[];
    activeView?: string;
    id: string;
    tabGroups?: SerializedTabGroup[];
}
export interface DockviewGroupChangeEvent {
    readonly panel: IDockviewPanel;
}
export interface CreateTabGroupOptions extends TabGroupOptions {
    id?: string;
}
export declare class DockviewDidDropEvent extends DockviewEvent {
    private readonly options;
    /**
     * `PointerEvent` for touch drags has no `dataTransfer`; use
     * `getData()` for the dockview payload regardless of input method.
     */
    get nativeEvent(): DragEvent | PointerEvent;
    get position(): Position;
    get panel(): IDockviewPanel | undefined;
    get group(): DockviewGroupPanel | undefined;
    get api(): DockviewApi;
    constructor(options: {
        readonly nativeEvent: DragEvent | PointerEvent;
        readonly position: Position;
        readonly panel?: IDockviewPanel;
        getData(): PanelTransfer | undefined;
        group?: DockviewGroupPanel;
        api: DockviewApi;
    });
    getData(): PanelTransfer | undefined;
}
export declare class DockviewWillDropEvent extends DockviewDidDropEvent {
    private readonly _kind;
    get kind(): DockviewGroupDropLocation;
    constructor(options: {
        readonly nativeEvent: DragEvent | PointerEvent;
        readonly position: Position;
        readonly panel?: IDockviewPanel;
        getData(): PanelTransfer | undefined;
        kind: DockviewGroupDropLocation;
        group?: DockviewGroupPanel;
        api: DockviewApi;
    });
}
export interface IHeader {
    hidden: boolean;
    direction: DockviewHeaderDirection;
}
export type DockviewGroupPanelLocked = boolean | 'no-drop-target';
export interface IDockviewGroupPanelModel extends IPanel {
    readonly isActive: boolean;
    readonly size: number;
    readonly panels: IDockviewPanel[];
    readonly activePanel: IDockviewPanel | undefined;
    readonly header: IHeader;
    readonly isContentFocused: boolean;
    readonly onDidDrop: Event<DockviewDidDropEvent>;
    readonly onWillDrop: Event<DockviewWillDropEvent>;
    readonly onDidAddPanel: Event<DockviewGroupChangeEvent>;
    readonly onDidRemovePanel: Event<DockviewGroupChangeEvent>;
    readonly onDidActivePanelChange: Event<DockviewGroupChangeEvent>;
    readonly onMove: Event<GroupMoveEvent>;
    locked: DockviewGroupPanelLocked;
    headerPosition: DockviewHeaderPosition;
    setActive(isActive: boolean): void;
    initialize(): void;
    isPanelActive: (panel: IDockviewPanel) => boolean;
    indexOf(panel: IDockviewPanel): number;
    openPanel(panel: IDockviewPanel, options?: {
        index?: number;
        skipFocus?: boolean;
        skipSetPanelActive?: boolean;
        skipSetGroupActive?: boolean;
    }): void;
    closePanel(panel: IDockviewPanel): void;
    closeAllPanels(): void;
    containsPanel(panel: IDockviewPanel): boolean;
    removePanel: (panelOrId: IDockviewPanel | string) => IDockviewPanel;
    moveToNext(options?: {
        panel?: IDockviewPanel;
        suppressRoll?: boolean;
    }): void;
    moveToPrevious(options?: {
        panel?: IDockviewPanel;
        suppressRoll?: boolean;
    }): void;
    canDisplayOverlay(event: DragEvent | PointerEvent, position: Position, target: DockviewGroupDropLocation): boolean;
}
export type DockviewGroupLocation = {
    type: 'grid';
} | {
    type: 'floating';
} | {
    type: 'popout';
    getWindow: () => Window;
    popoutUrl?: string;
} | {
    type: 'edge';
    position: EdgeGroupPosition;
};
export declare class DockviewGroupPanelModel extends CompositeDisposable implements IDockviewGroupPanelModel {
    private readonly container;
    private readonly accessor;
    id: string;
    private readonly options;
    private readonly groupPanel;
    private readonly tabsContainer;
    private readonly contentContainer;
    private _activePanel;
    private watermark?;
    private _isGroupActive;
    private _locked;
    private _rightHeaderActions;
    private _leftHeaderActions;
    private _prefixHeaderActions;
    private readonly _rightHeaderActionsDisposable;
    private readonly _leftHeaderActionsDisposable;
    private readonly _prefixHeaderActionsDisposable;
    private _headerPosition;
    private _location;
    private mostRecentlyUsed;
    private _overwriteRenderContainer;
    private _overwriteDropTargetContainer;
    private readonly _onDidChange;
    readonly onDidChange: Event<IViewSize | undefined>;
    private _width;
    private _height;
    private readonly _panels;
    private readonly _panelDisposables;
    private readonly _tabGroupDisposables;
    private readonly _pendingMicrotaskDisposables;
    private readonly _onMove;
    readonly onMove: Event<GroupMoveEvent>;
    private readonly _onDidDrop;
    readonly onDidDrop: Event<DockviewDidDropEvent>;
    private readonly _onWillDrop;
    readonly onWillDrop: Event<DockviewWillDropEvent>;
    private readonly _onWillShowOverlay;
    readonly onWillShowOverlay: Event<DockviewWillShowOverlayLocationEvent>;
    private readonly _onTabDragStart;
    readonly onTabDragStart: Event<TabDragEvent>;
    private readonly _onGroupDragStart;
    readonly onGroupDragStart: Event<GroupDragEvent>;
    private readonly _onDidAddPanel;
    readonly onDidAddPanel: Event<DockviewGroupChangeEvent>;
    private readonly _onDidPanelTitleChange;
    readonly onDidPanelTitleChange: Event<TitleEvent>;
    private readonly _onDidPanelParametersChange;
    readonly onDidPanelParametersChange: Event<Parameters>;
    private readonly _onDidRemovePanel;
    readonly onDidRemovePanel: Event<DockviewGroupChangeEvent>;
    private readonly _onDidActivePanelChange;
    readonly onDidActivePanelChange: Event<DockviewGroupChangeEvent>;
    private readonly _onUnhandledDragOverEvent;
    readonly onUnhandledDragOverEvent: Event<DockviewDndOverlayEvent>;
    private readonly _tabGroups;
    private readonly _tabGroupMap;
    private readonly _panelToTabGroup;
    private _tabGroupIdCounter;
    private _pendingTabGroupUpdate;
    private readonly _onDidCreateTabGroup;
    readonly onDidCreateTabGroup: Event<{
        tabGroup: ITabGroup;
    }>;
    private readonly _onDidDestroyTabGroup;
    readonly onDidDestroyTabGroup: Event<{
        tabGroup: ITabGroup;
    }>;
    private readonly _onDidAddPanelToTabGroup;
    readonly onDidAddPanelToTabGroup: Event<{
        tabGroup: ITabGroup;
        panelId: string;
    }>;
    private readonly _onDidRemovePanelFromTabGroup;
    readonly onDidRemovePanelFromTabGroup: Event<{
        tabGroup: ITabGroup;
        panelId: string;
    }>;
    private readonly _onDidTabGroupChange;
    readonly onDidTabGroupChange: Event<{
        tabGroup: ITabGroup;
    }>;
    private readonly _onDidTabGroupCollapsedChange;
    readonly onDidTabGroupCollapsedChange: Event<{
        tabGroup: ITabGroup;
    }>;
    private readonly _api;
    get tabGroups(): readonly ITabGroup[];
    get element(): HTMLElement;
    get activePanel(): IDockviewPanel | undefined;
    get locked(): DockviewGroupPanelLocked;
    set locked(value: DockviewGroupPanelLocked);
    get isActive(): boolean;
    get panels(): IDockviewPanel[];
    get size(): number;
    get isEmpty(): boolean;
    get hasWatermark(): boolean;
    get header(): IHeader;
    get isContentFocused(): boolean;
    get headerPosition(): DockviewHeaderPosition;
    set headerPosition(value: DockviewHeaderPosition);
    get location(): DockviewGroupLocation;
    set location(value: DockviewGroupLocation);
    constructor(container: HTMLElement, accessor: DockviewComponent, id: string, options: GroupOptions, groupPanel: DockviewGroupPanel);
    private _scheduleTabGroupUpdate;
    createTabGroup(options?: CreateTabGroupOptions): ITabGroup;
    dissolveTabGroup(tabGroupId: string): void;
    addPanelToTabGroup(tabGroupId: string, panelId: string, index?: number): void;
    /**
     * Move a panel to a new index within its tab group.
     * Updates both the group's panelIds order and the flat _panels array.
     */
    movePanelWithinGroup(tabGroupId: string, panelId: string, newIndex: number): void;
    /**
     * Move a panel from one tab group to another.
     */
    movePanelBetweenGroups(sourcePanelId: string, targetTabGroupId: string, targetIndex?: number): void;
    /**
     * Move an entire tab group to a new position in the tab bar.
     * The group's internal panel order is preserved.
     */
    moveTabGroup(tabGroupId: string, targetIndex: number): void;
    /**
     * Ensure a panel is at the correct global index in _panels
     * to maintain contiguity of its tab group members.
     */
    private _enforceContiguity;
    /**
     * Compute the global index in _panels for a group-local index.
     * Finds where the group's panels start in the flat array and offsets.
     */
    private _computeGlobalIndex;
    removePanelFromTabGroup(panelId: string): void;
    getTabGroups(): readonly ITabGroup[];
    updateTabGroups(): void;
    refreshTabGroupAccent(): void;
    refreshWatermark(): void;
    getTabGroupForPanel(panelId: string): ITabGroup | undefined;
    private _findTabGroupForPanel;
    private _removeTabGroupInternal;
    private _handleGroupCollapse;
    private _handleGroupExpand;
    /** Restore tab groups from serialized data (used by fromJSON) */
    restoreTabGroups(serializedGroups: SerializedTabGroup[]): void;
    focusContent(): void;
    set renderContainer(value: OverlayRenderContainer | null);
    get renderContainer(): OverlayRenderContainer;
    set dropTargetContainer(value: DropTargetAnchorContainer | null);
    get dropTargetContainer(): DropTargetAnchorContainer | null;
    initialize(): void;
    updateHeaderActions(): void;
    rerender(panel: IDockviewPanel): void;
    indexOf(panel: IDockviewPanel): number;
    toJSON(): GroupPanelViewState;
    moveToNext(options?: {
        panel?: IDockviewPanel;
        suppressRoll?: boolean;
    }): void;
    moveToPrevious(options?: {
        panel?: IDockviewPanel;
        suppressRoll?: boolean;
    }): void;
    containsPanel(panel: IDockviewPanel): boolean;
    init(_params: PanelInitParameters): void;
    update(_params: PanelUpdateEvent): void;
    focus(): void;
    openPanel(panel: IDockviewPanel, options?: {
        index?: number;
        skipSetActive?: boolean;
        skipSetGroupActive?: boolean;
    }): void;
    removePanel(groupItemOrId: IDockviewPanel | string, options?: {
        skipSetActive?: boolean;
        skipSetActiveGroup?: boolean;
    }): IDockviewPanel;
    closeAllPanels(): void;
    closePanel(panel: IDockviewPanel): void;
    private doClose;
    isPanelActive(panel: IDockviewPanel): boolean;
    updateActions(element: HTMLElement | undefined): void;
    setActive(isGroupActive: boolean, force?: boolean): void;
    layout(width: number, height: number): void;
    private _removePanel;
    private doRemovePanel;
    private doAddPanel;
    private doSetActivePanel;
    private updateMru;
    private updateContainer;
    canDisplayOverlay(event: DragEvent | PointerEvent, position: Position, target: DockviewGroupDropLocation): boolean;
    private handleDropEvent;
    updateDragAndDropState(): void;
    dispose(): void;
}
export {};