dockview 1.3.1 → 1.4.2

package/dist/esm/gridview/gridviewPanel.js

@@ -17,11 +17,11 @@ export class GridviewPanel extends BasePanelView {
         this.onDidChange = this._onDidChange.event;
         this.addDisposables(this._onDidChange, this.api.onVisibilityChange((event) => {
             const { isVisible } = event;
-            const { containerApi } = this._params;
-            containerApi.setVisible(this, isVisible);
+            const { accessor } = this._params;
+            accessor.setVisible(this, isVisible);
         }), this.api.onActiveChange(() => {
-            const { containerApi } = this._params;
-            containerApi.setActive(this);
+            const { accessor } = this._params;
+            accessor.setActive(this);
         }), this.api.onDidConstraintsChangeInternal((event) => {
             if (typeof event.minimumWidth === 'number' ||
                 typeof event.minimumWidth === 'function') {

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,11 +119,11 @@ 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;
@@ -120,32 +131,34 @@ export declare class Groupview extends CompositeDisposable implements IGroupview
     get minimumWidth(): number;
     get maximumWidth(): number;
     get hasWatermark(): boolean;
-    constructor(container: HTMLElement, accessor: IDockviewComponent, id: string, options: GroupOptions, parent: GroupviewPanel);
+    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;
+    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;
@@ -102,6 +107,15 @@ export class Groupview extends CompositeDisposable {
     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) {
@@ -117,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) {
@@ -195,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);
+        this.doAddPanel(panel, options.index, skipSetActive);
+        if (!skipSetActive) {
+            this.doSetActivePanel(panel);
+            this.accessor.doSetGroupActive(this.parent, !!options.skipFocus);
+        }
         this.updateContainer();
     }
     removePanel(groupItemOrId) {
@@ -305,11 +323,13 @@ export class Groupview extends CompositeDisposable {
             panel,
         });
     }
-    doAddPanel(panel, index = this.panels.length) {
+    doAddPanel(panel, index = this.panels.length, skipSetActive = false) {
         const existingPanel = this._panels.indexOf(panel);
         const hasExistingPanel = existingPanel > -1;
         this.tabsContainer.openPanel(panel, index);
-        this.contentContainer.openPanel(panel);
+        if (!skipSetActive) {
+            this.contentContainer.openPanel(panel);
+        }
         this.tabsContainer.show();
         this.contentContainer.show();
         if (hasExistingPanel) {
@@ -402,7 +422,12 @@ export class Groupview extends CompositeDisposable {
             });
         }
         else {
-            this._onDidDrop.fire({ nativeEvent: event, position, index });
+            this._onDidDrop.fire({
+                nativeEvent: event,
+                position,
+                index,
+                getData: () => getPanelData(),
+            });
         }
     }
     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,7 +23,7 @@ export declare class ContentContainer extends CompositeDisposable implements ICo
     constructor();
     show(): void;
     hide(): void;
-    openPanel(panel: IGroupPanel): void;
+    openPanel(panel: IDockviewPanel): void;
     layout(_width: number, _height: number): void;
     closePanel(): void;
     dispose(): void;

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/tab.js

@@ -24,6 +24,7 @@ export class Tab extends CompositeDisposable {
         this._element.className = 'tab';
         this._element.tabIndex = 0;
         this._element.draggable = true;
+        toggleClass(this.element, 'inactive-tab', true);
         this.addDisposables(new (class Handler extends DragHandler {
             constructor() {
                 super(...arguments);

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;
 }
@@ -36,16 +37,17 @@ export declare class TabsContainer extends CompositeDisposable implements ITabsC
     private readonly voidDropTarget;
     private tabs;
     private selectedIndex;
-    private active;
-    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 +55,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;
+    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;
 }

package/dist/esm/groupview/titlebar/tabsContainer.js

@@ -12,7 +12,7 @@ export class TabsContainer extends CompositeDisposable {
         this.group = group;
         this.tabs = [];
         this.selectedIndex = -1;
-        this.active = false;
+        this._hidden = false;
         this._onDrop = new Emitter();
         this.onDrop = this._onDrop.event;
         this.addDisposables(this._onDrop);
@@ -73,11 +73,20 @@ export class TabsContainer extends CompositeDisposable {
             this.element.style.setProperty('--dv-tabs-and-actions-container-height', `${value}px`);
         }
     }
+    get hidden() {
+        return this._hidden;
+    }
+    set hidden(value) {
+        this._hidden = value;
+        this.element.style.display = value ? 'none' : '';
+    }
     show() {
-        this.element.style.display = '';
+        if (!this.hidden) {
+            this.element.style.display = '';
+        }
     }
     hide() {
-        this.element.style.display = 'none';
+        this._element.style.display = 'none';
     }
     setActionElement(element) {
         if (this.actions === element) {
@@ -106,8 +115,8 @@ export class TabsContainer extends CompositeDisposable {
     indexOf(id) {
         return this.tabs.findIndex((tab) => tab.value.panelId === id);
     }
-    setActive(isGroupActive) {
-        this.active = isGroupActive;
+    setActive(_isGroupActive) {
+        // noop
     }
     addTab(tab, index = this.tabs.length) {
         if (index < 0 || index > this.tabs.length) {
@@ -149,7 +158,7 @@ export class TabsContainer extends CompositeDisposable {
         const disposable = CompositeDisposable.from(tabToAdd.onChanged((event) => {
             var _a;
             const alreadyFocused = panel.id === ((_a = this.group.model.activePanel) === null || _a === void 0 ? void 0 : _a.id) &&
-                this.group.model.isContentFocused();
+                this.group.model.isContentFocused;
             this.accessor.fireMouseEvent(Object.assign(Object.assign({}, event), { panel, tab: true }));
             const isLeftClick = event.event.button === 0;
             if (!isLeftClick || event.event.defaultPrevented) {
@@ -168,7 +177,6 @@ export class TabsContainer extends CompositeDisposable {
         }));
         const value = { value: tabToAdd, disposable };
         this.addTab(value, index);
-        this.activePanel = panel;
     }
     closePanel(panel) {
         this.delete(panel.id);

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

@@ -3,9 +3,8 @@ import { IDockviewComponent } from '../dockview/dockviewComponent';
 import { DockviewPanelApi } from '../api/groupPanelApi';
 import { PanelInitParameters, IPanel } from '../panel/types';
 import { DockviewApi } from '../api/component.api';
-import { GroupviewPanel } from './groupviewPanel';
+import { GroupPanel } from './groupviewPanel';
 import { Event } from '../events';
-import { WrappedTab } from '../dockview/components/tab/defaultTab';
 export interface IRenderable {
     id: string;
     element: HTMLElement;
@@ -21,17 +20,17 @@ export interface GroupPanelPartInitParameters extends PanelInitParameters, Heade
     containerApi: DockviewApi;
 }
 export interface GroupPanelContentPartInitParameters extends GroupPanelPartInitParameters {
-    tab: WrappedTab;
+    tab: ITabRenderer;
 }
 export interface IWatermarkRenderer extends IPanel {
     readonly element: HTMLElement;
     init: (params: GroupPanelPartInitParameters) => void;
-    updateParentGroup(group: GroupviewPanel, visible: boolean): void;
+    updateParentGroup(group: GroupPanel, visible: boolean): void;
 }
 export interface ITabRenderer extends IPanel {
     readonly element: HTMLElement;
     init(parameters: GroupPanelPartInitParameters): void;
-    updateParentGroup(group: GroupviewPanel, isPanelVisible: boolean): void;
+    updateParentGroup(group: GroupPanel, isPanelVisible: boolean): void;
 }
 export interface IActionsRenderer extends IDisposable {
     readonly element: HTMLElement;
@@ -41,9 +40,8 @@ export interface IContentRenderer extends IPanel {
     readonly actions?: HTMLElement;
     readonly onDidFocus?: Event<void>;
     readonly onDidBlur?: Event<void>;
-    updateParentGroup(group: GroupviewPanel, isPanelVisible: boolean): void;
+    updateParentGroup(group: GroupPanel, isPanelVisible: boolean): void;
     init(parameters: GroupPanelContentPartInitParameters): void;
-    close?(): Promise<boolean>;
 }
 export interface WatermarkPartInitParameters {
     accessor: IDockviewComponent;