dockview 1.2.0 → 1.4.0

package/dist/esm/gridview/gridviewComponent.js

@@ -67,7 +67,7 @@ export class GridviewComponent extends BaseGrid {
         this.gridview.setViewVisible(getGridLocation(panel.element), visible);
     }
     setActive(panel) {
-        this._groups.forEach((value, key) => {
+        this._groups.forEach((value, _key) => {
             value.value.setActive(panel === value.value);
         });
     }
@@ -78,10 +78,14 @@ export class GridviewComponent extends BaseGrid {
         var _a;
         (_a = this.activeGroup) === null || _a === void 0 ? void 0 : _a.focus();
     }
-    fromJSON(serializedGridview, deferComponentLayout) {
+    fromJSON(serializedGridview) {
         const { grid, activePanel } = serializedGridview;
+        const groups = Array.from(this._groups.values()); // reassign since group panels will mutate
+        for (const group of groups) {
+            group.disposable.dispose();
+            this.doRemoveGroup(group.value, { skipActive: true });
+        }
         this.gridview.clear();
-        this._groups.clear();
         const queue = [];
         this.gridview.deserialize(grid, {
             fromJSON: (node) => {
@@ -108,14 +112,7 @@ export class GridviewComponent extends BaseGrid {
             },
         });
         this.layout(this.width, this.height, true);
-        if (deferComponentLayout) {
-            setTimeout(() => {
-                queue.forEach((f) => f());
-            }, 0);
-        }
-        else {
-            queue.forEach((f) => f());
-        }
+        queue.forEach((f) => f());
         if (typeof activePanel === 'string') {
             const panel = this.getPanel(activePanel);
             if (panel) {
@@ -145,10 +142,10 @@ export class GridviewComponent extends BaseGrid {
     addPanel(options) {
         var _a, _b;
         let relativeLocation = options.location || [0];
-        if ((_a = options.position) === null || _a === void 0 ? void 0 : _a.reference) {
-            const referenceGroup = (_b = this._groups.get(options.position.reference)) === null || _b === void 0 ? void 0 : _b.value;
+        if ((_a = options.position) === null || _a === void 0 ? void 0 : _a.referencePanel) {
+            const referenceGroup = (_b = this._groups.get(options.position.referencePanel)) === null || _b === void 0 ? void 0 : _b.value;
             if (!referenceGroup) {
-                throw new Error(`reference group ${options.position.reference} does not exist`);
+                throw new Error(`reference group ${options.position.referencePanel} does not exist`);
             }
             const target = toTarget(options.position.direction);
             if (target === Position.Center) {
@@ -178,7 +175,7 @@ export class GridviewComponent extends BaseGrid {
         });
         this.registerPanel(view);
         this.doAddGroup(view, relativeLocation, options.size);
-        return { api: view.api };
+        return view;
     }
     registerPanel(panel) {
         const disposable = new CompositeDisposable(panel.api.onDidFocusChange((event) => {
@@ -229,11 +226,6 @@ export class GridviewComponent extends BaseGrid {
     }
     removeGroup(group) {
         super.removeGroup(group);
-        const panel = this._groups.get(group.id);
-        if (panel) {
-            panel.disposable.dispose();
-            this._groups.delete(group.id);
-        }
     }
     dispose() {
         super.dispose();

package/dist/esm/groupview/groupPanel.d.ts

@@ -2,7 +2,7 @@ import { DockviewPanelApi } from '../api/groupPanelApi';
 import { IDisposable } from '../lifecycle';
 import { HeaderPartInitParameters } from './types';
 import { IPanel, PanelInitParameters, PanelUpdateEvent, Parameters } from '../panel/types';
-import { GroupviewPanel } from './groupviewPanel';
+import { GroupPanel } from './groupviewPanel';
 import { IGroupPanelView } from '../dockview/defaultGroupPanelView';
 export interface IGroupPanelInitParameters extends PanelInitParameters, HeaderPartInitParameters {
     view: IGroupPanelView;
@@ -12,14 +12,14 @@ export declare type GroupPanelUpdateEvent = PanelUpdateEvent<{
     title?: string;
     suppressClosable?: boolean;
 }>;
-export interface IGroupPanel extends IDisposable, IPanel {
+export interface IDockviewPanel extends IDisposable, IPanel {
     readonly view?: IGroupPanelView;
-    readonly group?: GroupviewPanel;
+    readonly group: GroupPanel;
     readonly api: DockviewPanelApi;
     readonly title: string;
     readonly suppressClosable: boolean;
     readonly params: Record<string, any> | undefined;
-    updateParentGroup(group: GroupviewPanel, isGroupActive: boolean): void;
+    updateParentGroup(group: GroupPanel, isGroupActive: boolean): void;
     init(params: IGroupPanelInitParameters): void;
     toJSON(): GroupviewPanelState;
     update(event: GroupPanelUpdateEvent): void;

package/dist/esm/groupview/groupview.d.ts

@@ -1,3 +1,4 @@
+import { PanelTransfer } from '../dnd/dataTransfer';
 import { Position } from '../dnd/droptarget';
 import { IDockviewComponent } from '../dockview/dockviewComponent';
 import { Event } from '../events';
@@ -5,8 +6,8 @@ import { IGridPanelView } from '../gridview/baseComponentGridview';
 import { IViewSize } from '../gridview/gridview';
 import { CompositeDisposable, IDisposable } from '../lifecycle';
 import { PanelInitParameters, PanelUpdateEvent } from '../panel/types';
-import { IGroupPanel } from './groupPanel';
-import { GroupviewPanel } from './groupviewPanel';
+import { IDockviewPanel } from './groupPanel';
+import { GroupPanel } from './groupviewPanel';
 import { DockviewDropTargets } from './dnd';
 export declare enum GroupChangeKind2 {
     ADD_PANEL = "ADD_PANEL",
@@ -32,55 +33,64 @@ interface GroupMoveEvent {
     target: Position;
     index?: number;
 }
-export interface GroupOptions {
-    readonly panels?: IGroupPanel[];
-    readonly activePanel?: IGroupPanel;
+interface CoreGroupOptions {
+    locked?: boolean;
+    hideHeader?: boolean;
+}
+export interface GroupOptions extends CoreGroupOptions {
+    readonly panels?: IDockviewPanel[];
+    readonly activePanel?: IDockviewPanel;
     readonly id?: string;
     tabHeight?: number;
 }
-export interface GroupviewChangeEvent {
-    readonly kind: GroupChangeKind2;
-    readonly panel?: IGroupPanel;
-}
-export interface GroupPanelViewState {
+export interface GroupPanelViewState extends CoreGroupOptions {
     views: string[];
     activeView?: string;
     id: string;
 }
+export interface GroupviewChangeEvent {
+    readonly kind: GroupChangeKind2;
+    readonly panel?: IDockviewPanel;
+}
 export interface GroupviewDropEvent {
     nativeEvent: DragEvent;
     position: Position;
+    getData(): PanelTransfer | undefined;
     index?: number;
 }
+export interface IHeader {
+    hidden: boolean;
+    height: number | undefined;
+}
 export interface IGroupview extends IDisposable, IGridPanelView {
     readonly isActive: boolean;
     readonly size: number;
-    readonly panels: IGroupPanel[];
-    readonly tabHeight: number | undefined;
-    readonly activePanel: IGroupPanel | undefined;
+    readonly panels: IDockviewPanel[];
+    readonly activePanel: IDockviewPanel | undefined;
+    readonly header: IHeader;
+    readonly isContentFocused: boolean;
     readonly onDidDrop: Event<GroupviewDropEvent>;
-    isPanelActive: (panel: IGroupPanel) => boolean;
-    indexOf(panel: IGroupPanel): number;
-    openPanel(panel: IGroupPanel, options?: {
+    readonly onDidGroupChange: Event<GroupviewChangeEvent>;
+    readonly onMove: Event<GroupMoveEvent>;
+    locked: boolean;
+    isPanelActive: (panel: IDockviewPanel) => boolean;
+    indexOf(panel: IDockviewPanel): number;
+    openPanel(panel: IDockviewPanel, options?: {
         index?: number;
         skipFocus?: boolean;
     }): void;
-    closePanel(panel: IGroupPanel): void;
+    closePanel(panel: IDockviewPanel): void;
     closeAllPanels(): void;
-    containsPanel(panel: IGroupPanel): boolean;
-    removePanel: (panelOrId: IGroupPanel | string) => IGroupPanel;
-    onDidGroupChange: Event<GroupviewChangeEvent>;
-    onMove: Event<GroupMoveEvent>;
+    containsPanel(panel: IDockviewPanel): boolean;
+    removePanel: (panelOrId: IDockviewPanel | string) => IDockviewPanel;
     moveToNext(options?: {
-        panel?: IGroupPanel;
+        panel?: IDockviewPanel;
         suppressRoll?: boolean;
     }): void;
     moveToPrevious(options?: {
-        panel?: IGroupPanel;
+        panel?: IDockviewPanel;
         suppressRoll?: boolean;
     }): void;
-    isContentFocused(): boolean;
-    updateActions(): void;
     canDisplayOverlay(event: DragEvent, target: DockviewDropTargets): boolean;
 }
 export declare class Groupview extends CompositeDisposable implements IGroupview {
@@ -95,6 +105,7 @@ export declare class Groupview extends CompositeDisposable implements IGroupview
     private _activePanel?;
     private watermark?;
     private _isGroupActive;
+    private _locked;
     private mostRecentlyUsed;
     private readonly _onDidChange;
     readonly onDidChange: Event<IViewSize | undefined>;
@@ -108,43 +119,46 @@ export declare class Groupview extends CompositeDisposable implements IGroupview
     private readonly _onDidDrop;
     readonly onDidDrop: Event<GroupviewDropEvent>;
     get element(): HTMLElement;
-    get activePanel(): IGroupPanel | undefined;
-    get tabHeight(): number | undefined;
-    set tabHeight(height: number | undefined);
+    get activePanel(): IDockviewPanel | undefined;
+    get locked(): boolean;
+    set locked(value: boolean);
     get isActive(): boolean;
-    get panels(): IGroupPanel[];
+    get panels(): IDockviewPanel[];
     get size(): number;
     get isEmpty(): boolean;
     get minimumHeight(): number;
     get maximumHeight(): number;
     get minimumWidth(): number;
     get maximumWidth(): number;
-    constructor(container: HTMLElement, accessor: IDockviewComponent, id: string, options: GroupOptions, parent: GroupviewPanel);
+    get hasWatermark(): boolean;
+    get header(): IHeader;
+    get isContentFocused(): boolean;
+    constructor(container: HTMLElement, accessor: IDockviewComponent, id: string, options: GroupOptions, parent: GroupPanel);
     initialize(): void;
-    isContentFocused(): boolean;
-    indexOf(panel: IGroupPanel): number;
+    indexOf(panel: IDockviewPanel): number;
     toJSON(): GroupPanelViewState;
     moveToNext(options?: {
-        panel?: IGroupPanel;
+        panel?: IDockviewPanel;
         suppressRoll?: boolean;
     }): void;
     moveToPrevious(options?: {
-        panel?: IGroupPanel;
+        panel?: IDockviewPanel;
         suppressRoll?: boolean;
     }): void;
-    containsPanel(panel: IGroupPanel): boolean;
-    init(params: PanelInitParameters): void;
-    update(params: PanelUpdateEvent): void;
+    containsPanel(panel: IDockviewPanel): boolean;
+    init(_params: PanelInitParameters): void;
+    update(_params: PanelUpdateEvent): void;
     focus(): void;
-    openPanel(panel: IGroupPanel, options?: {
+    openPanel(panel: IDockviewPanel, options?: {
         index?: number;
         skipFocus?: boolean;
+        skipSetActive?: boolean;
     }): void;
-    removePanel(groupItemOrId: IGroupPanel | string): IGroupPanel;
+    removePanel(groupItemOrId: IDockviewPanel | string): IDockviewPanel;
     closeAllPanels(): void;
-    closePanel(panel: IGroupPanel): void;
+    closePanel(panel: IDockviewPanel): void;
     private doClose;
-    isPanelActive(panel: IGroupPanel): boolean;
+    isPanelActive(panel: IDockviewPanel): boolean;
     updateActions(): void;
     setActive(isGroupActive: boolean, skipFocus?: boolean, force?: boolean): void;
     layout(width: number, height: number): void;

package/dist/esm/groupview/groupview.js

@@ -22,6 +22,7 @@ export class Groupview extends CompositeDisposable {
         this.options = options;
         this.parent = parent;
         this._isGroupActive = false;
+        this._locked = false;
         this.mostRecentlyUsed = [];
         this._onDidChange = new Emitter();
         this.onDidChange = this._onDidChange.event;
@@ -42,7 +43,10 @@ export class Groupview extends CompositeDisposable {
         this.contentContainer = new ContentContainer();
         this.dropTarget = new Droptarget(this.contentContainer.element, {
             validOverlays: 'all',
-            canDisplayOverlay: (event) => {
+            canDisplayOverlay: (event, quadrant) => {
+                if (this.locked && !quadrant) {
+                    return false;
+                }
                 const data = getPanelData();
                 if (data) {
                     const groupHasOnePanelAndIsActiveDragElement = this._panels.length === 1 && data.groupId === this.id;
@@ -52,6 +56,8 @@ export class Groupview extends CompositeDisposable {
             },
         });
         container.append(this.tabsContainer.element, this.contentContainer.element);
+        this.header.hidden = !!options.hideHeader;
+        this.locked = !!options.locked;
         this.addDisposables(this._onMove, this._onDidGroupChange, this.tabsContainer.onDrop((event) => {
             this.handleDropEvent(event.event, Position.Center, event.index);
         }), this.contentContainer.onDidFocus(() => {
@@ -68,12 +74,11 @@ export class Groupview extends CompositeDisposable {
     get activePanel() {
         return this._activePanel;
     }
-    get tabHeight() {
-        return this.tabsContainer.height;
+    get locked() {
+        return this._locked;
     }
-    set tabHeight(height) {
-        this.tabsContainer.height = height;
-        this.layout(this._width, this._height);
+    set locked(value) {
+        this._locked = value;
     }
     get isActive() {
         return this._isGroupActive;
@@ -99,6 +104,18 @@ export class Groupview extends CompositeDisposable {
     get maximumWidth() {
         return Number.MAX_SAFE_INTEGER;
     }
+    get hasWatermark() {
+        return !!(this.watermark && this.container.contains(this.watermark.element));
+    }
+    get header() {
+        return this.tabsContainer;
+    }
+    get isContentFocused() {
+        if (!document.activeElement) {
+            return false;
+        }
+        return isAncestor(document.activeElement, this.contentContainer.element);
+    }
     initialize() {
         var _a, _b;
         if ((_a = this.options) === null || _a === void 0 ? void 0 : _a.panels) {
@@ -114,22 +131,23 @@ export class Groupview extends CompositeDisposable {
         this.setActive(this.isActive, true, true);
         this.updateContainer();
     }
-    isContentFocused() {
-        if (!document.activeElement) {
-            return false;
-        }
-        return isAncestor(document.activeElement, this.contentContainer.element);
-    }
     indexOf(panel) {
         return this.tabsContainer.indexOf(panel.id);
     }
     toJSON() {
         var _a;
-        return {
+        const result = {
             views: this.tabsContainer.panels,
             activeView: (_a = this._activePanel) === null || _a === void 0 ? void 0 : _a.id,
             id: this.id,
         };
+        if (this.locked) {
+            result.locked = true;
+        }
+        if (this.header.hidden) {
+            result.hideHeader = true;
+        }
+        return result;
     }
     moveToNext(options) {
         if (!options) {
@@ -177,10 +195,10 @@ export class Groupview extends CompositeDisposable {
     containsPanel(panel) {
         return this.panels.includes(panel);
     }
-    init(params) {
+    init(_params) {
         //noop
     }
-    update(params) {
+    update(_params) {
         //noop
     }
     focus() {
@@ -192,15 +210,18 @@ export class Groupview extends CompositeDisposable {
             options.index > this.panels.length) {
             options.index = this.panels.length;
         }
+        const skipSetActive = !!options.skipSetActive;
         // ensure the group is updated before we fire any events
         panel.updateParentGroup(this.parent, true);
-        if (this._activePanel === panel) {
+        if (!skipSetActive && this._activePanel === panel) {
             this.accessor.doSetGroupActive(this.parent);
             return;
         }
         this.doAddPanel(panel, options.index);
-        this.doSetActivePanel(panel);
-        this.accessor.doSetGroupActive(this.parent, !!options.skipFocus);
+        if (!skipSetActive) {
+            this.doSetActivePanel(panel);
+            this.accessor.doSetGroupActive(this.parent, !!options.skipFocus);
+        }
         this.updateContainer();
     }
     removePanel(groupItemOrId) {
@@ -399,14 +420,21 @@ export class Groupview extends CompositeDisposable {
             });
         }
         else {
-            this._onDidDrop.fire({ nativeEvent: event, position, index });
+            this._onDidDrop.fire({
+                nativeEvent: event,
+                position,
+                index,
+                getData: () => getPanelData(),
+            });
         }
     }
     dispose() {
+        var _a;
+        super.dispose();
+        (_a = this.watermark) === null || _a === void 0 ? void 0 : _a.dispose();
         for (const panel of this.panels) {
             panel.dispose();
         }
-        super.dispose();
         this.dropTarget.dispose();
         this.tabsContainer.dispose();
         this.contentContainer.dispose();

package/dist/esm/groupview/groupviewPanel.d.ts

@@ -1,17 +1,31 @@
 import { IFrameworkPart } from '../panel/types';
 import { IDockviewComponent } from '../dockview/dockviewComponent';
-import { Groupview, GroupOptions } from './groupview';
+import { GridviewPanelApi } from '../api/gridviewPanelApi';
+import { Groupview, GroupOptions, IHeader } from './groupview';
 import { GridviewPanel, IGridviewPanel } from '../gridview/gridviewPanel';
+import { IDockviewPanel } from './groupPanel';
 export interface IGroupviewPanel extends IGridviewPanel {
     model: Groupview;
+    locked: boolean;
+    readonly size: number;
+    readonly panels: IDockviewPanel[];
+    readonly activePanel: IDockviewPanel | undefined;
 }
-export declare class GroupviewPanel extends GridviewPanel implements IGroupviewPanel {
+export declare type IGroupviewPanelPublic = IGroupviewPanel;
+export declare type GroupviewPanelApi = GridviewPanelApi;
+export declare class GroupPanel extends GridviewPanel implements IGroupviewPanel {
     private readonly _model;
+    get panels(): IDockviewPanel[];
+    get activePanel(): IDockviewPanel | undefined;
+    get size(): number;
     get model(): Groupview;
     get minimumHeight(): number;
     get maximumHeight(): number;
     get minimumWidth(): number;
     get maximumWidth(): number;
+    get locked(): boolean;
+    set locked(value: boolean);
+    get header(): IHeader;
     constructor(accessor: IDockviewComponent, id: string, options: GroupOptions);
     initialize(): void;
     setActive(isActive: boolean): void;

package/dist/esm/groupview/groupviewPanel.js

@@ -1,11 +1,22 @@
-import { GridviewPanelApiImpl } from '../api/gridviewPanelApi';
+import { GridviewPanelApiImpl, } from '../api/gridviewPanelApi';
 import { Groupview } from './groupview';
 import { GridviewPanel } from '../gridview/gridviewPanel';
-export class GroupviewPanel extends GridviewPanel {
+class GroupviewApi extends GridviewPanelApiImpl {
+}
+export class GroupPanel extends GridviewPanel {
     constructor(accessor, id, options) {
-        super(id, 'groupview_default', new GridviewPanelApiImpl(id));
+        super(id, 'groupview_default', new GroupviewApi(id));
         this._model = new Groupview(this.element, accessor, id, options, this);
     }
+    get panels() {
+        return this._model.panels;
+    }
+    get activePanel() {
+        return this._model.activePanel;
+    }
+    get size() {
+        return this._model.size;
+    }
     get model() {
         return this._model;
     }
@@ -21,8 +32,17 @@ export class GroupviewPanel extends GridviewPanel {
     get maximumWidth() {
         return this._model.maximumWidth;
     }
+    get locked() {
+        return this._model.locked;
+    }
+    set locked(value) {
+        this._model.locked = value;
+    }
+    get header() {
+        return this._model.header;
+    }
     initialize() {
-        this.model.initialize();
+        this._model.initialize();
     }
     setActive(isActive) {
         super.setActive(isActive);

package/dist/esm/groupview/panel/content.d.ts

@@ -1,12 +1,12 @@
 import { CompositeDisposable, IDisposable } from '../../lifecycle';
 import { Event } from '../../events';
-import { IGroupPanel } from '../groupPanel';
+import { IDockviewPanel } from '../groupPanel';
 export interface IContentContainer extends IDisposable {
     onDidFocus: Event<void>;
     onDidBlur: Event<void>;
     element: HTMLElement;
     layout(width: number, height: number): void;
-    openPanel: (panel: IGroupPanel) => void;
+    openPanel: (panel: IDockviewPanel) => void;
     closePanel: () => void;
     show(): void;
     hide(): void;
@@ -23,8 +23,8 @@ export declare class ContentContainer extends CompositeDisposable implements ICo
     constructor();
     show(): void;
     hide(): void;
-    openPanel(panel: IGroupPanel): void;
-    layout(width: number, height: number): void;
+    openPanel(panel: IDockviewPanel): void;
+    layout(_width: number, _height: number): void;
     closePanel(): void;
     dispose(): void;
 }

package/dist/esm/groupview/panel/content.js

@@ -56,7 +56,7 @@ export class ContentContainer extends CompositeDisposable {
         }
         this.disposable.value = disposable;
     }
-    layout(width, height) {
+    layout(_width, _height) {
         // noop
     }
     closePanel() {

package/dist/esm/groupview/tab.d.ts

@@ -2,8 +2,8 @@ import { Event } from '../events';
 import { CompositeDisposable } from '../lifecycle';
 import { IDockviewComponent } from '../dockview/dockviewComponent';
 import { ITabRenderer } from './types';
-import { IGroupPanel } from './groupPanel';
-import { GroupviewPanel } from './groupviewPanel';
+import { IDockviewPanel } from './groupPanel';
+import { GroupPanel } from './groupviewPanel';
 import { DroptargetEvent } from '../dnd/droptarget';
 export declare enum MouseEventKind {
     CLICK = "CLICK",
@@ -12,7 +12,7 @@ export declare enum MouseEventKind {
 export interface LayoutMouseEvent {
     readonly kind: MouseEventKind;
     readonly event: MouseEvent;
-    readonly panel?: IGroupPanel;
+    readonly panel?: IDockviewPanel;
     readonly tab?: boolean;
 }
 export interface ITab {
@@ -34,7 +34,7 @@ export declare class Tab extends CompositeDisposable implements ITab {
     private readonly _onDropped;
     readonly onDrop: Event<DroptargetEvent>;
     get element(): HTMLElement;
-    constructor(panelId: string, accessor: IDockviewComponent, group: GroupviewPanel);
+    constructor(panelId: string, accessor: IDockviewComponent, group: GroupPanel);
     setActive(isActive: boolean): void;
     setContent(part: ITabRenderer): void;
     dispose(): void;

package/dist/esm/groupview/titlebar/tabsContainer.d.ts

@@ -1,9 +1,9 @@
 import { IDisposable, CompositeDisposable } from '../../lifecycle';
 import { Event } from '../../events';
 import { ITab } from '../tab';
-import { IGroupPanel } from '../groupPanel';
+import { IDockviewPanel } from '../groupPanel';
 import { IDockviewComponent } from '../../dockview/dockviewComponent';
-import { GroupviewPanel } from '../groupviewPanel';
+import { GroupPanel } from '../groupviewPanel';
 export interface TabDropIndexEvent {
     event: DragEvent;
     readonly index: number;
@@ -18,11 +18,12 @@ export interface ITabsContainer extends IDisposable {
     at: (index: number) => ITab;
     onDrop: Event<TabDropIndexEvent>;
     setActive: (isGroupActive: boolean) => void;
-    setActivePanel: (panel: IGroupPanel) => void;
+    setActivePanel: (panel: IDockviewPanel) => void;
     isActive: (tab: ITab) => boolean;
-    closePanel: (panel: IGroupPanel) => void;
-    openPanel: (panel: IGroupPanel, index?: number) => void;
+    closePanel: (panel: IDockviewPanel) => void;
+    openPanel: (panel: IDockviewPanel, index?: number) => void;
     setActionElement(element: HTMLElement | undefined): void;
+    hidden: boolean;
     show(): void;
     hide(): void;
 }
@@ -40,12 +41,15 @@ export declare class TabsContainer extends CompositeDisposable implements ITabsC
     private activePanel;
     private actions;
     private _height;
+    private _hidden;
     private readonly _onDrop;
     readonly onDrop: Event<TabDropIndexEvent>;
     get panels(): string[];
     get size(): number;
     get height(): number | undefined;
     set height(value: number | undefined);
+    get hidden(): boolean;
+    set hidden(value: boolean);
     show(): void;
     hide(): void;
     setActionElement(element: HTMLElement | undefined): void;
@@ -53,14 +57,14 @@ export declare class TabsContainer extends CompositeDisposable implements ITabsC
     isActive(tab: ITab): boolean;
     at(index: number): ITab;
     indexOf(id: string): number;
-    constructor(accessor: IDockviewComponent, group: GroupviewPanel, options: {
+    constructor(accessor: IDockviewComponent, group: GroupPanel, options: {
         tabHeight?: number;
     });
     setActive(isGroupActive: boolean): void;
     private addTab;
     delete(id: string): void;
-    setActivePanel(panel: IGroupPanel): void;
-    openPanel(panel: IGroupPanel, index?: number): void;
-    closePanel(panel: IGroupPanel): void;
+    setActivePanel(panel: IDockviewPanel): void;
+    openPanel(panel: IDockviewPanel, index?: number): void;
+    closePanel(panel: IDockviewPanel): void;
     dispose(): void;
 }