dockview-core 6.6.1 → 7.0.3

package/dist/cjs/dockview/components/titlebar/tabGroups.js

@@ -47,7 +47,6 @@ var dndCapabilities_1 = require("../../dndCapabilities");
 var tabGroupAccent_1 = require("../../tabGroupAccent");
 var tabGroupChip_1 = require("./tabGroupChip");
 var droptarget_1 = require("../../../dnd/droptarget");
-var dataTransfer_2 = require("../../../dnd/dataTransfer");
 var tabGroupIndicator_1 = require("./tabGroupIndicator");
 var EMPTY_MAP = new Map();
 var TabGroupManager = /** @class */ (function () {
@@ -90,6 +89,7 @@ var TabGroupManager = /** @class */ (function () {
      */
     TabGroupManager.prototype.update = function () {
         var e_1, _a, e_2, _b;
+        var _c;
         var model = this._ctx.group.model;
         var tabGroups = model.getTabGroups();
         // Track which group IDs are still active
@@ -111,11 +111,12 @@ var TabGroupManager = /** @class */ (function () {
         }
         try {
             // Remove chips for dissolved/destroyed groups
-            for (var _c = __values(this._chipRenderers), _d = _c.next(); !_d.done; _d = _c.next()) {
-                var _e = __read(_d.value, 2), groupId = _e[0], entry = _e[1];
+            for (var _d = __values(this._chipRenderers), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var _f = __read(_e.value, 2), groupId = _f[0], entry = _f[1];
                 if (!activeGroupIds.has(groupId)) {
                     entry.chip.element.remove();
                     entry.chip.dispose();
+                    (_c = entry.dragSourcesDisposable) === null || _c === void 0 ? void 0 : _c.dispose();
                     entry.disposable.dispose();
                     this._chipRenderers.delete(groupId);
                 }
@@ -124,7 +125,7 @@ var TabGroupManager = /** @class */ (function () {
         catch (e_2_1) { e_2 = { error: e_2_1 }; }
         finally {
             try {
-                if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
             }
             finally { if (e_2) throw e_2.error; }
         }
@@ -297,20 +298,21 @@ var TabGroupManager = /** @class */ (function () {
     };
     TabGroupManager.prototype.updateDragAndDropState = function () {
         var e_7, _a;
+        var _b, _c, _d;
         var caps = (0, dndCapabilities_1.resolveDndCapabilities)(this._ctx.accessor.options);
         try {
-            for (var _b = __values(this._chipRenderers.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var entry = _c.value;
+            for (var _e = __values(this._chipRenderers.values()), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var entry = _f.value;
                 entry.chip.element.draggable = caps.html5;
-                entry.html5DragSource.setDisabled(!caps.html5);
-                entry.pointerDragSource.setDisabled(!caps.pointer);
-                entry.pointerDragSource.setTouchOnly(!caps.pointerHandlesMouse);
+                (_b = entry.html5DragSource) === null || _b === void 0 ? void 0 : _b.setDisabled(!caps.html5);
+                (_c = entry.pointerDragSource) === null || _c === void 0 ? void 0 : _c.setDisabled(!caps.pointer);
+                (_d = entry.pointerDragSource) === null || _d === void 0 ? void 0 : _d.setTouchOnly(!caps.pointerHandlesMouse);
             }
         }
         catch (e_7_1) { e_7 = { error: e_7_1 }; }
         finally {
             try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
             }
             finally { if (e_7) throw e_7.error; }
         }
@@ -321,19 +323,28 @@ var TabGroupManager = /** @class */ (function () {
      * iframe shield are released BEFORE the cross-group move detaches
      * the chip (chip dispose is scheduled on a microtask via
      * `_scheduleTabGroupUpdate`, which is too late for callers that read
-     * `getPanelData()` synchronously after the move). Idempotent — the
-     * subsequent `update()` will also dispose the sources.
+     * `getPanelData()` synchronously after the move).
+     *
+     * A cross-group move dissolves the source chip entirely, but a
+     * within-group reorder keeps the same chip element — so the sources are
+     * cleared to `undefined` here and the subsequent `update()` re-arms them
+     * via `_ensureChipForGroup`. Without that re-arm the chip would fire a
+     * native `dragstart` (the element keeps `draggable=true`) but never set
+     * a transfer payload, leaving the group permanently undraggable after
+     * its first move. (#1410)
      */
     TabGroupManager.prototype.disposeChipDrag = function (tabGroupId) {
-        var _a, _b;
+        var _a;
         var entry = this._chipRenderers.get(tabGroupId);
         if (!entry) {
             return;
         }
         // Optional-chained because tests may inject minimal entries
         // that skip the manager's normal `_ensureChipForGroup` flow.
-        (_a = entry.html5DragSource) === null || _a === void 0 ? void 0 : _a.dispose();
-        (_b = entry.pointerDragSource) === null || _b === void 0 ? void 0 : _b.dispose();
+        (_a = entry.dragSourcesDisposable) === null || _a === void 0 ? void 0 : _a.dispose();
+        entry.html5DragSource = undefined;
+        entry.pointerDragSource = undefined;
+        entry.dragSourcesDisposable = undefined;
     };
     /** Cloned chip rect used as the pointer follow-finger ghost. */
     TabGroupManager.prototype._buildChipGhostElement = function (chipEl) {
@@ -347,35 +358,36 @@ var TabGroupManager = /** @class */ (function () {
     };
     TabGroupManager.prototype.disposeAll = function () {
         var e_8, _a, e_9, _b;
-        var _c;
+        var _c, _d;
         (_c = this._indicator) === null || _c === void 0 ? void 0 : _c.dispose();
         this._indicator = null;
         try {
-            for (var _d = __values(this._pendingTransitionCleanups), _e = _d.next(); !_e.done; _e = _d.next()) {
-                var _f = __read(_e.value, 2), cleanup = _f[1];
+            for (var _e = __values(this._pendingTransitionCleanups), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var _g = __read(_f.value, 2), cleanup = _g[1];
                 cleanup();
             }
         }
         catch (e_8_1) { e_8 = { error: e_8_1 }; }
         finally {
             try {
-                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+                if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
             }
             finally { if (e_8) throw e_8.error; }
         }
         this._pendingTransitionCleanups.clear();
         try {
-            for (var _g = __values(this._chipRenderers), _h = _g.next(); !_h.done; _h = _g.next()) {
-                var _j = __read(_h.value, 2), entry = _j[1];
+            for (var _h = __values(this._chipRenderers), _j = _h.next(); !_j.done; _j = _h.next()) {
+                var _k = __read(_j.value, 2), entry = _k[1];
                 entry.chip.element.remove();
                 entry.chip.dispose();
+                (_d = entry.dragSourcesDisposable) === null || _d === void 0 ? void 0 : _d.dispose();
                 entry.disposable.dispose();
             }
         }
         catch (e_9_1) { e_9 = { error: e_9_1 }; }
         finally {
             try {
-                if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+                if (_j && !_j.done && (_b = _h.return)) _b.call(_h);
             }
             finally { if (e_9) throw e_9.error; }
         }
@@ -383,7 +395,7 @@ var TabGroupManager = /** @class */ (function () {
     };
     TabGroupManager.prototype._ensureIndicator = function () {
         var _this = this;
-        var _a, _b;
+        var _a, _b, _c;
         var mode = (_b = (_a = this._ctx.accessor.options.theme) === null || _a === void 0 ? void 0 : _a.tabGroupIndicator) !== null && _b !== void 0 ? _b : 'wrap';
         var Ctor = mode === 'none' ? tabGroupIndicator_1.NoneTabGroupIndicator : tabGroupIndicator_1.WrapTabGroupIndicator;
         // Re-create if the indicator type changed (e.g. theme switch)
@@ -391,28 +403,25 @@ var TabGroupManager = /** @class */ (function () {
             this._indicator.dispose();
             this._indicator = null;
         }
-        if (!this._indicator) {
-            this._indicator = new Ctor({
-                tabsList: this._ctx.tabsList,
-                getTabGroups: function () { return _this._ctx.group.model.getTabGroups(); },
-                getActivePanelId: function () { var _a; return (_a = _this._ctx.group.activePanel) === null || _a === void 0 ? void 0 : _a.id; },
-                getTabMap: function () { return _this._ctx.getTabMap(); },
-                getChipElement: function (id) { var _a; return (_a = _this._chipRenderers.get(id)) === null || _a === void 0 ? void 0 : _a.chip.element; },
-                getDirection: function () { return _this._ctx.getDirection(); },
-                getColorPalette: function () { return _this._ctx.accessor.tabGroupColorPalette; },
-            });
-        }
+        (_c = this._indicator) !== null && _c !== void 0 ? _c : (this._indicator = new Ctor({
+            tabsList: this._ctx.tabsList,
+            getTabGroups: function () { return _this._ctx.group.model.getTabGroups(); },
+            getActivePanelId: function () { var _a; return (_a = _this._ctx.group.activePanel) === null || _a === void 0 ? void 0 : _a.id; },
+            getTabMap: function () { return _this._ctx.getTabMap(); },
+            getChipElement: function (id) { var _a; return (_a = _this._chipRenderers.get(id)) === null || _a === void 0 ? void 0 : _a.chip.element; },
+            getDirection: function () { return _this._ctx.getDirection(); },
+            getHeaderPosition: function () { return _this._ctx.group.model.headerPosition; },
+            getColorPalette: function () { return _this._ctx.accessor.tabGroupColorPalette; },
+        }));
     };
-    TabGroupManager.prototype._ensureChipForGroup = function (tabGroup) {
+    /**
+     * Create the HTML5 + pointer drag sources for a chip (and the direct
+     * dragend listener that clears the transfer synchronously). Extracted so
+     * both the initial chip build and the post-move re-arm in
+     * `_ensureChipForGroup` share one wiring path. (#1410)
+     */
+    TabGroupManager.prototype._createChipDragSources = function (chip, tabGroup) {
         var _this = this;
-        if (this._chipRenderers.has(tabGroup.id)) {
-            return;
-        }
-        var createChip = this._ctx.accessor.options.createTabGroupChipComponent;
-        var chip = createChip
-            ? createChip(tabGroup)
-            : new tabGroupChip_1.TabGroupChip(this._ctx.accessor.tabGroupColorPalette);
-        chip.init({ tabGroup: tabGroup, api: this._ctx.accessor.api });
         var caps = (0, dndCapabilities_1.resolveDndCapabilities)(this._ctx.accessor.options);
         chip.element.draggable = caps.html5;
         var panelTransfer = dataTransfer_1.LocalSelectionTransfer.getInstance();
@@ -466,9 +475,12 @@ var TabGroupManager = /** @class */ (function () {
         // the listener survives chip disposal in the detach-then-dragend
         // cross-group path; `once: true` auto-removes after the single
         // dragend that we care about. (#1254)
-        chip.element.addEventListener('dragend', function () {
+        var onDragEndClear = function () {
             panelTransfer.clearData(dataTransfer_1.PanelTransfer.prototype);
-        }, { once: true });
+        };
+        chip.element.addEventListener('dragend', onDragEndClear, {
+            once: true,
+        });
         var pointerDragSource = backend_1.pointerBackend.createDragSource(chip.element, {
             getData: getData,
             disabled: !caps.pointer,
@@ -485,6 +497,42 @@ var TabGroupManager = /** @class */ (function () {
                 _this._callbacks.onChipDragStart(tabGroup, chip, event);
             },
         });
+        return {
+            html5DragSource: html5DragSource,
+            pointerDragSource: pointerDragSource,
+            disposable: {
+                dispose: function () {
+                    html5DragSource.dispose();
+                    pointerDragSource.dispose();
+                    chip.element.removeEventListener('dragend', onDragEndClear);
+                },
+            },
+        };
+    };
+    TabGroupManager.prototype._ensureChipForGroup = function (tabGroup) {
+        var _this = this;
+        var existing = this._chipRenderers.get(tabGroup.id);
+        if (existing) {
+            // A committed group move tears down the chip's drag sources via
+            // `disposeChipDrag`, but a within-group reorder keeps the same
+            // chip element alive. Re-arm the sources so the group stays
+            // draggable; without this the chip is stuck after its first
+            // move — `dragstart` still fires (the element keeps
+            // `draggable=true`) but no transfer payload is set. (#1410)
+            if (!existing.html5DragSource) {
+                var sources = this._createChipDragSources(existing.chip, tabGroup);
+                existing.html5DragSource = sources.html5DragSource;
+                existing.pointerDragSource = sources.pointerDragSource;
+                existing.dragSourcesDisposable = sources.disposable;
+            }
+            return;
+        }
+        var createChip = this._ctx.accessor.options.createTabGroupChipComponent;
+        var chip = createChip
+            ? createChip(tabGroup)
+            : new tabGroupChip_1.TabGroupChip(this._ctx.accessor.tabGroupColorPalette);
+        chip.init({ tabGroup: tabGroup, api: this._ctx.accessor.api });
+        var dragSources = this._createChipDragSources(chip, tabGroup);
         var disposables = [
             tabGroup.onDidChange(function () {
                 var _a;
@@ -498,17 +546,19 @@ var TabGroupManager = /** @class */ (function () {
             tabGroup.onDidCollapseChange(function () {
                 _this._updateTabGroupClasses();
             }),
-            html5DragSource,
-            pointerDragSource,
         ];
         // Context menu: built-in TabGroupChip already aggregates right-click
         // + touch long-press into `onContextMenu`. Custom chip renderers
         // don't, so attach a long-press detector and contextmenu listener
         // directly on their element.
         var onContextMenu = function (event) {
+            var _a, _b;
             // A long-press on a chip should preempt the in-flight pointer
-            // drag and open the menu instead.
-            pointerDragSource.cancelPending();
+            // drag and open the menu instead. Resolve the source from the
+            // entry so a post-move re-armed source is cancelled, not the
+            // stale one captured at build time. (#1410)
+            (_b = (_a = _this._chipRenderers
+                .get(tabGroup.id)) === null || _a === void 0 ? void 0 : _a.pointerDragSource) === null || _b === void 0 ? void 0 : _b.cancelPending();
             _this._callbacks.onChipContextMenu(tabGroup, event);
         };
         if (chip instanceof tabGroupChip_1.TabGroupChip) {
@@ -540,8 +590,8 @@ var TabGroupManager = /** @class */ (function () {
                 if (_this._ctx.accessor.options.disableDnd) {
                     return false;
                 }
-                var data = (0, dataTransfer_2.getPanelData)();
-                if (data && _this._ctx.accessor.id === data.viewId) {
+                var data = (0, dataTransfer_1.getPanelData)();
+                if (_this._ctx.accessor.id === (data === null || data === void 0 ? void 0 : data.viewId)) {
                     if (((_a = _this._ctx.accessor.options.theme) === null || _a === void 0 ? void 0 : _a.tabAnimation) ===
                         'smooth') {
                         return false;
@@ -557,8 +607,9 @@ var TabGroupManager = /** @class */ (function () {
         var disposable = new (lifecycle_1.CompositeDisposable.bind.apply(lifecycle_1.CompositeDisposable, __spreadArray([void 0], __read(disposables), false)))();
         this._chipRenderers.set(tabGroup.id, {
             chip: chip,
-            html5DragSource: html5DragSource,
-            pointerDragSource: pointerDragSource,
+            html5DragSource: dragSources.html5DragSource,
+            pointerDragSource: dragSources.pointerDragSource,
+            dragSourcesDisposable: dragSources.disposable,
             disposable: disposable,
             dropTarget: dropTarget,
         });

package/dist/cjs/dockview/components/titlebar/tabs.d.ts

@@ -59,7 +59,19 @@ export declare class Tabs extends CompositeDisposable {
         showTabsOverflowControl: boolean;
     });
     indexOf(id: string): number;
+    /** DOM id of the tab element for a panel — for the tabpanel's `aria-labelledby`. */
+    getTabId(panelId: string): string | undefined;
     isActive(tab: Tab): boolean;
+    private _onKeyDown;
+    /**
+     * Close the tab at `index` and move roving focus to a neighbouring tab so
+     * keyboard focus stays in the tablist.
+     */
+    private _closeTab;
+    /** Move the roving focus to the tab at `index` (updates tabindex + DOM focus). */
+    private _focusTab;
+    /** Move DOM focus to the active tab — the entry point into the tablist. */
+    focusActiveTab(): void;
     setActivePanel(panel: IDockviewPanel): void;
     openPanel(panel: IDockviewPanel, index?: number): void;
     delete(id: string): void;

package/dist/cjs/dockview/components/titlebar/tabs.js

@@ -92,6 +92,9 @@ var Tabs = /** @class */ (function (_super) {
         _this.onOverflowTabsChange = _this._onOverflowTabsChange.event;
         _this._tabsList = document.createElement('div');
         _this._tabsList.className = 'dv-tabs-container';
+        // WAI-ARIA Tabs pattern: the strip of tabs is the tablist.
+        _this._tabsList.setAttribute('role', 'tablist');
+        _this._tabsList.setAttribute('aria-orientation', _this._direction === 'vertical' ? 'vertical' : 'horizontal');
         _this.showTabsOverflowControl = options.showTabsOverflowControl;
         if (accessor.options.scrollbars === 'native') {
             _this._element = _this._tabsList;
@@ -111,7 +114,8 @@ var Tabs = /** @class */ (function (_super) {
             getDirection: function () { return _this._direction; },
         }, {
             onChipContextMenu: function (tabGroup, event) {
-                _this.accessor.contextMenuController.showForChip(tabGroup, _this.group, event);
+                var _a;
+                (_a = _this.accessor.contextMenuService) === null || _a === void 0 ? void 0 : _a.showForChip(tabGroup, _this.group, event);
             },
             onChipDragStart: function (tabGroup, chip, event) {
                 _this._handleChipDragStart(tabGroup, chip, event);
@@ -204,7 +208,14 @@ var Tabs = /** @class */ (function (_super) {
             else {
                 _this._tabsList.scrollLeft = current + primary;
             }
-        }, { passive: false }), (0, events_1.addDisposableListener)(_this._tabsList, 'dragover', function (event) {
+        }, { passive: false }), 
+        // WAI-ARIA Tabs keyboard pattern: arrow keys move the roving
+        // focus along the strip, Home/End jump to the ends, and
+        // Enter/Space activate the focused tab (manual activation, so
+        // arrowing through tabs doesn't switch panels until committed).
+        (0, events_1.addDisposableListener)(_this._tabsList, 'keydown', function (event) {
+            _this._onKeyDown(event);
+        }), (0, events_1.addDisposableListener)(_this._tabsList, 'dragover', function (event) {
             if (_this._processDragOver(event.clientX)) {
                 // Allow `drop` to fire on the tabs list container.
                 event.preventDefault();
@@ -401,6 +412,7 @@ var Tabs = /** @class */ (function (_super) {
                 return;
             }
             this._direction = value;
+            this._tabsList.setAttribute('aria-orientation', value === 'vertical' ? 'vertical' : 'horizontal');
             if (this._scrollbar) {
                 this._scrollbar.orientation = value;
             }
@@ -433,10 +445,101 @@ var Tabs = /** @class */ (function (_super) {
     Tabs.prototype.indexOf = function (id) {
         return this._tabs.findIndex(function (tab) { return tab.value.panel.id === id; });
     };
+    /** DOM id of the tab element for a panel — for the tabpanel's `aria-labelledby`. */
+    Tabs.prototype.getTabId = function (panelId) {
+        var _a;
+        return (_a = this._tabMap.get(panelId)) === null || _a === void 0 ? void 0 : _a.value.element.id;
+    };
     Tabs.prototype.isActive = function (tab) {
         return (this.selectedIndex > -1 &&
             this._tabs[this.selectedIndex].value === tab);
     };
+    Tabs.prototype._onKeyDown = function (event) {
+        var _this = this;
+        // Only handle when a tab element itself is focused — never hijack keys
+        // typed inside a custom tab renderer's own controls (inputs etc.).
+        var index = this._tabs.findIndex(function (tab) { return tab.value.element === event.target; });
+        if (index === -1) {
+            return;
+        }
+        var isVertical = this._direction === 'vertical';
+        var nextKey = isVertical ? 'ArrowDown' : 'ArrowRight';
+        var prevKey = isVertical ? 'ArrowUp' : 'ArrowLeft';
+        var last = this._tabs.length - 1;
+        switch (event.key) {
+            case nextKey:
+                event.preventDefault();
+                this._focusTab(Math.min(index + 1, last));
+                break;
+            case prevKey:
+                event.preventDefault();
+                this._focusTab(Math.max(index - 1, 0));
+                break;
+            case 'Home':
+                event.preventDefault();
+                this._focusTab(0);
+                break;
+            case 'End':
+                event.preventDefault();
+                this._focusTab(last);
+                break;
+            case 'Enter':
+            case ' ':
+                // Manual activation of the focused tab.
+                event.preventDefault();
+                this.accessor.withOrigin('user', function () {
+                    return _this._tabs[index].value.panel.api.setActive();
+                });
+                break;
+            case 'Delete':
+            case 'Backspace':
+                // Close the focused tab (Backspace covers macOS, where the
+                // primary delete key reports as Backspace).
+                event.preventDefault();
+                this._closeTab(index);
+                break;
+        }
+    };
+    /**
+     * Close the tab at `index` and move roving focus to a neighbouring tab so
+     * keyboard focus stays in the tablist.
+     */
+    Tabs.prototype._closeTab = function (index) {
+        var _a, _b, _c, _d, _e;
+        var tab = (_a = this._tabs[index]) === null || _a === void 0 ? void 0 : _a.value;
+        if (!tab) {
+            return;
+        }
+        // Resolve the post-close focus target before closing mutates the list:
+        // prefer the next tab, otherwise the previous.
+        var neighbourId = (_e = ((_c = (_b = this._tabs[index + 1]) === null || _b === void 0 ? void 0 : _b.value) !== null && _c !== void 0 ? _c : (_d = this._tabs[index - 1]) === null || _d === void 0 ? void 0 : _d.value)) === null || _e === void 0 ? void 0 : _e.panel.id;
+        tab.panel.api.close();
+        if (neighbourId !== undefined) {
+            var nextIndex = this._tabs.findIndex(function (t) { return t.value.panel.id === neighbourId; });
+            if (nextIndex > -1) {
+                this._focusTab(nextIndex);
+            }
+        }
+    };
+    /** Move the roving focus to the tab at `index` (updates tabindex + DOM focus). */
+    Tabs.prototype._focusTab = function (index) {
+        for (var i = 0; i < this._tabs.length; i++) {
+            this._tabs[i].value.element.tabIndex = i === index ? 0 : -1;
+        }
+        this._tabs[index].value.element.focus();
+    };
+    /** Move DOM focus to the active tab — the entry point into the tablist. */
+    Tabs.prototype.focusActiveTab = function () {
+        var _a;
+        if (this._tabs.length === 0) {
+            return;
+        }
+        var activeId = (_a = this.group.activePanel) === null || _a === void 0 ? void 0 : _a.id;
+        var activeIndex = activeId
+            ? this._tabs.findIndex(function (t) { return t.value.panel.id === activeId; })
+            : -1;
+        this._focusTab(activeIndex > -1 ? activeIndex : 0);
+    };
     Tabs.prototype.setActivePanel = function (panel) {
         var e_3, _a;
         var isVertical = this._direction === 'vertical';
@@ -456,12 +559,10 @@ var Tabs = /** @class */ (function (_super) {
                             parentElement.scrollTop = running;
                         }
                     }
-                    else {
-                        if (running < parentElement.scrollLeft ||
-                            running + element.clientWidth >
-                                parentElement.scrollLeft + parentElement.clientWidth) {
-                            parentElement.scrollLeft = running;
-                        }
+                    else if (running < parentElement.scrollLeft ||
+                        running + element.clientWidth >
+                            parentElement.scrollLeft + parentElement.clientWidth) {
+                        parentElement.scrollLeft = running;
                     }
                 }
                 running += isVertical
@@ -583,18 +684,13 @@ var Tabs = /** @class */ (function (_super) {
                 });
                 return;
             }
-            switch (event.button) {
-                case 0:
-                    if (_this.group.api.location.type === 'edge') {
-                        // All tab interaction for edge groups is handled by
-                        // onTabClick to avoid race conditions with active panel state
-                    }
-                    else {
-                        if (_this.group.activePanel !== panel) {
-                            _this.group.model.openPanel(panel);
-                        }
-                    }
-                    break;
+            // Edge groups are skipped here: all their tab interaction
+            // is handled by onTabClick to avoid race conditions with
+            // active panel state.
+            if (event.button === 0 &&
+                _this.group.api.location.type !== 'edge' &&
+                _this.group.activePanel !== panel) {
+                _this.group.model.openPanel(panel);
             }
         }), tab.onDrop(function (event) {
             var _a, _b, _c, _d;
@@ -617,12 +713,12 @@ var Tabs = /** @class */ (function (_super) {
                     targetTabGroupId: animState.targetTabGroupId,
                 });
                 if (((_b = _this.accessor.options.theme) === null || _b === void 0 ? void 0 : _b.tabAnimation) === 'smooth') {
-                    _this.runFlipAnimation(firstPositions, animState.sourceTabId, animState.sourceIndex === -1, animState.sourceIndex !== -1
-                        ? {
+                    _this.runFlipAnimation(firstPositions, animState.sourceTabId, animState.sourceIndex === -1, animState.sourceIndex === -1
+                        ? undefined
+                        : {
                             from: Math.min(animState.sourceIndex, dropIndex),
                             to: Math.max(animState.sourceIndex, dropIndex),
-                        }
-                        : undefined);
+                        });
                 }
             }
             else {
@@ -939,7 +1035,7 @@ var Tabs = /** @class */ (function (_super) {
             return;
         }
         var data = (0, dataTransfer_1.getPanelData)();
-        var sourceIndex = data && data.groupId === this.group.id && data.panelId
+        var sourceIndex = (data === null || data === void 0 ? void 0 : data.groupId) === this.group.id && (data === null || data === void 0 ? void 0 : data.panelId)
             ? this._tabs.findIndex(function (x) { return x.value.panel.id === data.panelId; })
             : -1;
         var adjustedIndex = insertionIndex -

package/dist/cjs/dockview/components/titlebar/tabsContainer.d.ts

@@ -33,8 +33,10 @@ export interface ITabsContainer extends IDisposable {
     direction: DockviewHeaderDirection;
     delete(id: string): void;
     indexOf(id: string): number;
+    getTabId(panelId: string): string | undefined;
     setActive(isGroupActive: boolean): void;
     setActivePanel(panel: IDockviewPanel): void;
+    focusActiveTab(): void;
     isActive(tab: Tab): boolean;
     closePanel(panel: IDockviewPanel): void;
     openPanel(panel: IDockviewPanel, index?: number): void;
@@ -87,9 +89,11 @@ export declare class TabsContainer extends CompositeDisposable implements ITabsC
     setPrefixActionsElement(element: HTMLElement | undefined): void;
     isActive(tab: Tab): boolean;
     indexOf(id: string): number;
+    getTabId(panelId: string): string | undefined;
     setActive(_isGroupActive: boolean): void;
     delete(id: string): void;
     setActivePanel(panel: IDockviewPanel): void;
+    focusActiveTab(): void;
     openPanel(panel: IDockviewPanel, index?: number): void;
     closePanel(panel: IDockviewPanel): void;
     private updateClassnames;

package/dist/cjs/dockview/components/titlebar/tabsContainer.js

@@ -253,6 +253,9 @@ var TabsContainer = /** @class */ (function (_super) {
     TabsContainer.prototype.indexOf = function (id) {
         return this.tabs.indexOf(id);
     };
+    TabsContainer.prototype.getTabId = function (panelId) {
+        return this.tabs.getTabId(panelId);
+    };
     TabsContainer.prototype.setActive = function (_isGroupActive) {
         // noop
     };
@@ -263,6 +266,9 @@ var TabsContainer = /** @class */ (function (_super) {
     TabsContainer.prototype.setActivePanel = function (panel) {
         this.tabs.setActivePanel(panel);
     };
+    TabsContainer.prototype.focusActiveTab = function () {
+        this.tabs.focusActiveTab();
+    };
     TabsContainer.prototype.openPanel = function (panel, index) {
         if (index === void 0) { index = this.tabs.size; }
         this.tabs.openPanel(panel, index);
@@ -374,8 +380,10 @@ var TabsContainer = /** @class */ (function (_super) {
                         // Activate the first panel in the group
                         var firstPanelId = tg.panelIds[0];
                         if (firstPanelId) {
-                            var panel = _this.group.panels.find(function (p) { return p.id === firstPanelId; });
-                            panel === null || panel === void 0 ? void 0 : panel.api.setActive();
+                            var panel_1 = _this.group.panels.find(function (p) { return p.id === firstPanelId; });
+                            _this.accessor.withOrigin('user', function () {
+                                return panel_1 === null || panel_1 === void 0 ? void 0 : panel_1.api.setActive();
+                            });
                         }
                     });
                     el.appendChild(groupHeader);
@@ -401,7 +409,9 @@ var TabsContainer = /** @class */ (function (_super) {
                         tg.expand();
                     }
                     tab.element.scrollIntoView();
-                    tab.panel.api.setActive();
+                    _this.accessor.withOrigin('user', function () {
+                        return tab.panel.api.setActive();
+                    });
                 });
                 wrapper.appendChild(child);
                 el.appendChild(wrapper);

package/dist/cjs/dockview/components/titlebar/voidContainer.d.ts

@@ -9,9 +9,7 @@ export declare class VoidContainer extends CompositeDisposable {
     private readonly _element;
     private readonly dropTarget;
     private readonly pointerDropTarget;
-    private readonly html5DragSource;
-    private readonly pointerDragSource;
-    private readonly panelTransfer;
+    private readonly dragSource;
     private readonly _onDrop;
     readonly onDrop: Event<DroptargetEvent>;
     private readonly _onDragStart;
@@ -20,5 +18,4 @@ export declare class VoidContainer extends CompositeDisposable {
     get element(): HTMLElement;
     constructor(accessor: DockviewComponent, group: DockviewGroupPanel);
     updateDragAndDropState(): void;
-    private getFloatingOverlay;
 }