dockview-core 7.0.3 → 8.0.0

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

@@ -0,0 +1,295 @@
+import { CompositeDisposable, IValueDisposable } from '../../../lifecycle';
+import { DockviewComponent } from '../../dockviewComponent';
+import { DockviewGroupPanel } from '../../dockviewGroupPanel';
+import { DockviewHeaderDirection } from '../../options';
+import { Tab } from '../tab/tab';
+import { TabDropIndexEvent } from './tabsContainer';
+import { TabGroupManager } from './tabGroups';
+export interface TabAnimationState {
+    sourceTabId: string;
+    sourceIndex: number;
+    tabPositions: Map<string, DOMRect>;
+    /** Group-chip widths keyed by group ID, captured before collapse */
+    chipPositions: Map<string, number>;
+    currentInsertionIndex: number | null;
+    targetTabGroupId: string | null;
+    /** When set, the drag source is a group chip (entire group drag) */
+    sourceTabGroupId: string | null;
+    /** Cached panel IDs of the source group (avoids repeated lookups during drag) */
+    sourceGroupPanelIds: Set<string> | null;
+    /** Width of the group chip, captured before collapse */
+    sourceChipWidth: number;
+    /** Distance from cursor to the left edge of the drag image */
+    cursorOffsetFromDragLeft: number;
+    /** Total width of the dragged content (chip + tabs for groups, tab width for singles) */
+    sourceGapWidth: number;
+    /** Left edge of the tabs container at drag start */
+    containerLeft: number;
+}
+export interface ITabReorderHost {
+    /** Live tab list (the `_tabs` array of the owning `Tabs`). */
+    readonly tabItems: IValueDisposable<Tab>[];
+    /** Panel-id → tab lookup (the `_tabMap` of the owning `Tabs`). */
+    readonly tabMap: Map<string, IValueDisposable<Tab>>;
+    /** The scrollable tab strip element (`.dv-tabs-container`). */
+    readonly tabsList: HTMLElement;
+    readonly direction: DockviewHeaderDirection;
+    readonly groupPanel: DockviewGroupPanel;
+    readonly component: DockviewComponent;
+    readonly tabGroupManager: TabGroupManager;
+    /** Fire the owning `Tabs`' drop event. */
+    fireDrop(event: TabDropIndexEvent): void;
+}
+/**
+ * Tab drag-reorder + FLIP animation subsystem extracted from `Tabs`. The DOM
+ * event wiring remains in `Tabs` and delegates the reorder/animation logic to
+ * this controller. All access back into `Tabs` goes through
+ * {@link ITabReorderHost}.
+ */
+export declare class TabReorderController extends CompositeDisposable {
+    private readonly host;
+    private _animState;
+    private readonly _pendingMarginCleanups;
+    private _pendingCollapse;
+    private _flipTransitionCleanup;
+    private _voidContainer;
+    private _extendedDropZone;
+    private _pointerInsideTabsList;
+    /** The tab element currently carrying a wrap-mode drop indicator, if any. */
+    private _wrapIndicatorEl;
+    private get _tabs();
+    private get _tabMap();
+    private get _tabsList();
+    private get _direction();
+    private get group();
+    private get accessor();
+    private get _tabGroupManager();
+    /** Whether the tab strip is in multi-row wrap layout
+     *  (`MultiRowTabsModule`, `overflow.mode: 'wrap'`). In wrap, the 1-D
+     *  gap/FLIP animation is suppressed and reorder uses a 2-D hit-test. */
+    private get _wrapMode();
+    get animState(): TabAnimationState | null;
+    set animState(value: TabAnimationState | null);
+    get pendingCollapse(): boolean;
+    set pendingCollapse(value: boolean);
+    set voidContainerElement(el: HTMLElement | null);
+    constructor(host: ITabReorderHost);
+    setExtendedDropZone(el: HTMLElement): void;
+    /**
+     * Allows external elements (e.g. void container, left actions) to push an
+     * insertion index into the animation while the cursor is outside the tabs
+     * list itself.  Pass `null` to clear the indicator.
+     */
+    setExternalInsertionIndex(index: number | null): void;
+    /**
+     * Called when the drag cursor leaves the entire header area (not just the
+     * tabs list).  Clears animation state for cross-group drags, which never
+     * receive a `dragend` event on this tab list.
+     */
+    clearExternalAnimState(): void;
+    snapshotTabPositions(): Map<string, DOMRect>;
+    private getAverageTabWidth;
+    /**
+     * Pointer-event entry point. The HTML5 path enters via the per-element
+     * `dragover` listener; this one hit-tests the global pointer-drag
+     * position against the tabs list and routes through the same shared
+     * `processDragOver` / `processDragLeave` helpers.
+     */
+    handlePointerDragMove(clientX: number, clientY: number): void;
+    /**
+     * Pointer-side cleanup hook: when any pointer drag ends, reset the
+     * inside-strip flag and tear down any smooth-reorder anim state the
+     * dragover bridge may have installed.
+     */
+    handlePointerDragEnd(e?: {
+        clientX: number;
+        clientY: number;
+        pointerEvent: PointerEvent;
+    }): void;
+    private isPointInsideTabsList;
+    /** Commit a smooth-mode intra-group reorder from the current insertion
+     *  index (adjusted for the source's own position), then clear drag state.
+     *  Used by the pointer backend for both single-row and wrap layouts. */
+    private commitPointerReorder;
+    /**
+     * Shared body of the dragover entry point. Refreshes stale anim state
+     * for a changed drag identity, initializes anim state for incoming
+     * cross-group drags, and dispatches to the gap-following math in
+     * `handleDragOver`. Returns true when this tabs list has taken
+     * ownership of the drag; HTML5 callers use this to gate
+     * `event.preventDefault()`.
+     */
+    processDragOver(clientX: number, clientY?: number): boolean;
+    /**
+     * If a previous drag's anim state lingers but the current drag is a
+     * different cross-group chip identity, drop the stale state so the new drag
+     * starts clean.
+     */
+    private _dropStaleAnimState;
+    /**
+     * Create the anim state for an external (cross-group) tab or chip drag.
+     * Returns `true` when state was created, `false` when this drag should not
+     * be handled at the tabs-list level.
+     */
+    private _initAnimStateForExternalDrag;
+    /** Anim state for an external group-chip drag (gap sized to the group). */
+    private _makeGroupDragAnimState;
+    /** Anim state for an external single-tab drag. */
+    private _makeTabDragAnimState;
+    /**
+     * Shared body of the dragleave entry point. Preserves anim state when
+     * the drag moves between tabs-list children, into the extended drop
+     * zone, or into the void container; tears it down otherwise.
+     */
+    processDragLeave(related: Element | null): void;
+    handleDragOver(event: {
+        clientX: number;
+        clientY?: number;
+    }): void;
+    /**
+     * Build a lookup from the first panel ID of each non-source group → group
+     * ID, so the accumulation walk can add chip widths when it reaches a
+     * group's first tab.
+     */
+    private _buildFirstPanelToGroupMap;
+    /**
+     * Walk the tabs left-to-right by their original widths and return the
+     * insertion slot for the drag image's left edge (null if no slot fits).
+     */
+    private _computeDragOverInsertionIndex;
+    /**
+     * Rebuild the accumulated original width up to `insertionIndex`, walking the
+     * tabs exactly the way the accumulation loop does, so callers know the
+     * original right edge of the chip (if any) that precedes the insertion slot.
+     */
+    private _accumulatedWidthUpTo;
+    /**
+     * Given a raw insertion index, snap it out of / into any tab group it falls
+     * within and resolve the target group (if the drop should merge into one).
+     */
+    private _resolveInsertionAgainstTabGroups;
+    /**
+     * Evaluate a single tab group against the proposed insertion index.
+     * Returns the resolved `{ insertionIndex, targetTabGroupId }` when this
+     * group governs the slot (the caller stops iterating), or `null` when the
+     * group is irrelevant and the caller should keep looking.
+     */
+    private _evaluateTabGroupForInsertion;
+    /**
+     * The index range this group occupies in the live tab list, excluding the
+     * source tab / source group tabs (so dragging a tab out of its own group
+     * doesn't inflate the range). Null when the group has no effective tabs or
+     * its bounds can't be located.
+     */
+    private _resolveGroupRange;
+    /** Insertion target for a group-chip drag: a group can't be dropped inside
+     *  another group, so snap out of the range; a just-before slot is kept. */
+    private _resolveGroupDragTarget;
+    /** Insertion target for a single-tab drag against a group: decide whether
+     *  the drop merges into the group based on the cursor vs the chip edge. */
+    private _resolveTabDragTarget;
+    /**
+     * Whether every tab in the half-open range `[from, to)` is the source tab
+     * or one of the source group's tabs.
+     */
+    private _onlySourceBetween;
+    /**
+     * Multi-row wrap drag-over: resolve the 2-D insertion slot and show a
+     * discrete drop indicator. No gap/FLIP animation (that's 1-D and fights the
+     * flow layout, so `applyDragOverTransforms`/`runFlipAnimation` no-op in wrap).
+     */
+    private handleWrappedDragOver;
+    /**
+     * The insertion slot (index into the full tab list) for a pointer at
+     * `(clientX, clientY)` over a wrapped strip. Two axes:
+     *  - horizontal header (rows): pick the row whose vertical span contains
+     *    `clientY`, then the slot within it by x-midpoint;
+     *  - vertical header (columns): pick the column whose horizontal span
+     *    contains `clientX`, then the slot within it by y-midpoint.
+     * The pointer's cross-axis coordinate selects the line (nearest line if it
+     * falls in an inter-line gap); its main-axis coordinate selects the slot.
+     * Excludes the drag source so its own position doesn't bias the result; the
+     * drop path adjusts for the source offset.
+     */
+    private computeWrappedInsertionIndex;
+    /**
+     * The wrapped drop candidates: each non-source tab's list index + live
+     * rect. The drag source (and any grouped tabs moving with it) are excluded
+     * so their own positions don't bias the hit-test.
+     */
+    private _wrappedDragEntries;
+    /**
+     * Bucket entries into lines by cross-axis start (2px tolerance for sub-pixel
+     * rounding), sorted along the cross axis.
+     */
+    private _bucketWrappedLines;
+    /** The line nearest `crossPointer` by cross-axis distance (gap fallback). */
+    private _nearestWrappedLine;
+    private updateWrapDropIndicator;
+    private clearWrapDropIndicator;
+    /**
+     * Batch-remove a CSS class from multiple elements instantly,
+     * forcing only a single reflow for the entire batch.
+     */
+    private _removeClassInstantlyBatch;
+    /**
+     * Remove `dv-tab--dragging` from the source tab instantly so it
+     * regains its real width before FLIP snapshots.
+     */
+    uncollapseSourceTab(sourceTabId: string): void;
+    applyDragOverTransforms(skipTransition?: boolean): void;
+    /** Gap width for the current drag: the whole group's span for a group
+     *  drag, otherwise the source tab's own width. */
+    private _computeGapWidth;
+    /**
+     * When the insertion lands at or before a group's first tab, the chip is
+     * shifted so the gap appears before the entire group. Returns that chip
+     * element, or null when no chip should shift.
+     *
+     * A chip shifts when dropping outside the group (targetTabGroupId null), or
+     * when dropping inside a collapsed group (whose tabs are invisible, so
+     * putting the gap on them has no visual effect).
+     */
+    private _computeChipToShift;
+    /**
+     * The chip to shift for a single group, or `undefined` to keep scanning the
+     * remaining groups. A defined result (the chip element, or null when the
+     * governing group has no shiftable chip) stops the scan.
+     */
+    private _chipToShiftForGroup;
+    /** Reset non-source chip margins, then apply the gap margin to the chip or
+     *  the first tab at/after the insertion index. */
+    private _applyGapMargins;
+    /** Pick the correct shifting class for tabs vs chips. */
+    private _shiftingClass;
+    /** Apply a margin-left value to an element, optionally bypassing CSS
+     *  transitions for instant positioning. */
+    private _setMargin;
+    /** Clear an element's gap margin, animating it back to zero unless
+     *  transitions are skipped. */
+    private _clearMargin;
+    resetTabTransforms(): void;
+    /**
+     * Commit a group-drag drop: clear drag classes, move the group
+     * in the model, and run a FLIP animation.
+     */
+    commitGroupMove(sourceTabGroupId: string, insertionIndex: number): void;
+    private _clearGroupDragClasses;
+    resetDragAnimation(): void;
+    runFlipAnimation(firstPositions: Map<string, DOMRect>, sourceTabId: string, isCrossGroup?: boolean, animRange?: {
+        from: number;
+        to: number;
+    }): void;
+    /**
+     * Set a single tab's FLIP transform: the source tab slides in from the end
+     * on a cross-group insert; other in-range tabs slide from their first
+     * position to their last. Returns true if the tab will animate.
+     */
+    private _applyFlipTransform;
+    /**
+     * Next frame, clear the transforms (triggering the CSS transition), track
+     * underlines through the slide, and drop the shifting classes once the
+     * transform transition ends.
+     */
+    private _scheduleFlipReset;
+}

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

@@ -1,5 +1,5 @@
 import { Event } from '../../../events';
-import { CompositeDisposable } from '../../../lifecycle';
+import { CompositeDisposable, IValueDisposable } from '../../../lifecycle';
 import { DockviewComponent } from '../../dockviewComponent';
 import { DockviewGroupPanel } from '../../dockviewGroupPanel';
 import { DockviewWillShowOverlayLocationEvent } from '../../events';
@@ -7,27 +7,66 @@ import { IDockviewPanel } from '../../dockviewPanel';
 import { DockviewHeaderDirection } from '../../options';
 import { Tab } from '../tab/tab';
 import { TabDragEvent, TabDropIndexEvent } from './tabsContainer';
-export declare class Tabs extends CompositeDisposable {
+import { TabGroupManager } from './tabGroups';
+import { ITabReorderHost } from './tabReorderController';
+export declare class Tabs extends CompositeDisposable implements ITabReorderHost {
     private readonly group;
     private readonly accessor;
     private readonly _element;
     private readonly _tabsList;
     private readonly _observerDisposable;
+    private readonly _pointerActivation;
     private readonly _scrollbar;
     private _tabs;
     private readonly _tabMap;
     private selectedIndex;
     private _showTabsOverflowControl;
+    /**
+     * Predicate that keeps a panel's tab out of the overflow dropdown
+     * regardless of visibility. Wired by the PinnedTabs module so pinned tabs
+     * never overflow. Defaults to a no-op so behaviour is unchanged when the
+     * module is absent. Must stay a pure lookup (no DOM reads) because it runs
+     * inside the overflow filter, which the `OverflowObserver` re-fires on every
+     * resize.
+     */
+    private _overflowExclude;
+    /**
+     * Predicate that forces a panel's tab into the overflow dropdown regardless
+     * of horizontal fit, the complement of {@link _overflowExclude}. Wired by
+     * the MultiRowTabs module: in wrap mode tabs never clip horizontally (they
+     * wrap), so the `OverflowObserver` detects nothing; this routes the surplus
+     * rows beyond `overflow.maxRows` into the dropdown. Defaults to a no-op so
+     * behaviour is unchanged when the module is absent. Must stay a pure lookup
+     * (no DOM reads) because it runs inside the overflow filter.
+     */
+    private _forcedOverflow;
+    /**
+     * When true, pinned (overflow-excluded) tabs stick to the left edge as the
+     * strip scrolls horizontally (Chrome-style frozen columns), wired by the
+     * PinnedTabs module in inline mode. Each pinned tab is given a cumulative
+     * `--dv-pinned-sticky-left` offset. Defaults to off so behaviour is
+     * unchanged when the module is absent.
+     */
+    private _pinnedSticky;
+    /** Whether any tab currently carries the sticky styling; lets
+     *  {@link _applyPinnedSticky} bail early when there is nothing to do (the
+     *  common case for components that never enable the feature). */
+    private _hasPinnedStickyStyling;
     private _direction;
-    private _animState;
-    private readonly _pendingMarginCleanups;
-    private _pendingCollapse;
-    private _flipTransitionCleanup;
-    private _voidContainer;
     private _voidContainerListeners;
-    private _extendedDropZone;
-    private _pointerInsideTabsList;
     private readonly _tabGroupManager;
+    private readonly _reorder;
+    private get _animState();
+    private set _animState(value);
+    private get _pendingCollapse();
+    private set _pendingCollapse(value);
+    get tabItems(): IValueDisposable<Tab>[];
+    get tabMap(): Map<string, IValueDisposable<Tab>>;
+    get tabsList(): HTMLElement;
+    get groupPanel(): DockviewGroupPanel;
+    get component(): DockviewComponent;
+    get tabGroupManager(): TabGroupManager;
+    fireDrop(event: TabDropIndexEvent): void;
     private readonly _onTabDragStart;
     readonly onTabDragStart: Event<TabDragEvent>;
     private readonly _onDrop;
@@ -38,11 +77,58 @@ export declare class Tabs extends CompositeDisposable {
     readonly onOverflowTabsChange: Event<{
         tabs: string[];
         tabGroups: string[];
+        /**
+         * Overflow-excluded (pinned) tabs that have themselves clipped out of
+         * the strip. Rendered in a dedicated "Pinned" section at the top of the
+         * dropdown so an overflowing pinned block stays reachable. Empty unless
+         * the {@link _overflowExclude} predicate is wired (PinnedTabs module).
+         */
+        pinnedTabs: string[];
         reset: boolean;
     }>;
+    /**
+     * Register a predicate excluding panels from the overflow dropdown (pinned
+     * tabs). Re-evaluates the dropdown immediately if overflow is being
+     * observed. Passing `() => false` restores default behaviour.
+     */
+    setOverflowExclude(fn: (panelId: string) => boolean): void;
+    /**
+     * Register a predicate that forces matching panels into the overflow
+     * dropdown regardless of horizontal fit (the MultiRowTabs surplus set, the
+     * rows beyond `overflow.maxRows`). Re-evaluates the dropdown immediately.
+     * Passing `() => false` restores default behaviour.
+     */
+    setForcedOverflow(fn: (panelId: string) => boolean): void;
+    /** Re-evaluate the overflow dropdown now (e.g. after the exclusion set
+     *  changed) instead of waiting for the next resize/scroll observer fire. */
+    refreshOverflow(): void;
+    /**
+     * Enable/disable sticky-on-scroll for pinned tabs (inline mode), wired by
+     * the PinnedTabs module. When on, pinned (overflow-excluded) tabs are frozen
+     * to the left edge as the strip scrolls, each at the cumulative width of the
+     * pinned tabs before it; when off, the sticky styling is cleared. The
+     * offsets are scroll-invariant, so they are recomputed only on resize,
+     * horizontal scroll (a cheap self-heal after a reorder), and pinned-set
+     * changes, not continuously.
+     */
+    setPinnedSticky(enabled: boolean): void;
+    /**
+     * Freeze the pinned (overflow-excluded) tabs to the left edge: give each the
+     * `dv-tab--pinned-sticky` class and a `--dv-pinned-sticky-left` offset so the
+     * CSS `position: sticky` rule holds it in place as the strip scrolls. Clears
+     * the styling from any tab that is no longer pinned, and from all tabs when
+     * the feature is off.
+     */
+    private _applyPinnedSticky;
     get showTabsOverflowControl(): boolean;
     set showTabsOverflowControl(value: boolean);
     get element(): HTMLElement;
+    /**
+     * The scrollable tab list (`.dv-tabs-container`) holding the tab elements,
+     * exposed (read-only) so the multi-row wrap controller can measure the
+     * wrapped row count and toggle the wrap class. Not the outer header element.
+     */
+    get tabsListElement(): HTMLElement;
     set voidContainer(el: HTMLElement | null);
     /**
      * Handle a drop that occurred on the void container (empty header
@@ -59,8 +145,11 @@ 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`. */
+    /** DOM id of the tab element for a panel, used for the tabpanel's `aria-labelledby`. */
     getTabId(panelId: string): string | undefined;
+    /** Inverse of {@link getTabId}: the panel whose tab owns `element` (the tab
+     *  itself or any descendant of it), or `undefined` for non-tab targets. */
+    getPanelForTab(element: Element): IDockviewPanel | undefined;
     isActive(tab: Tab): boolean;
     private _onKeyDown;
     /**
@@ -70,9 +159,29 @@ export declare class Tabs extends CompositeDisposable {
     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. */
+    /** Move DOM focus to the active tab, the entry point into the tablist. */
     focusActiveTab(): void;
     setActivePanel(panel: IDockviewPanel): void;
+    /**
+     * Scroll the active tab into view within its scroll container. Uses the
+     * element's own offset (relative to the container) rather than accumulating
+     * tab client sizes, which omits tab margins and any in-flow group chips
+     * between tabs and so undershoots the active tab's real position.
+     */
+    private _scrollTabIntoView;
+    /**
+     * Activate a tab in response to a plain (non-shift) left pointerdown.
+     *
+     * With the HTML5 drag backend the tab is natively `draggable`, and a native
+     * drag arms from the same pointerdown+move gesture. Firefox aborts that
+     * pending drag if the pointerdown also moves focus / relayouts the tab strip
+     * synchronously — which `openPanel` does — so a drag started on an inactive
+     * tab never begins (issue #932). Defer the activation past the frame so
+     * `dragstart` arms first; a plain click (no drag) still activates on the
+     * next frame, which is imperceptible. The pointer backend has no native drag
+     * to pre-empt, so it activates synchronously as before.
+     */
+    private _activateOnPointerDown;
     openPanel(panel: IDockviewPanel, index?: number): void;
     delete(id: string): void;
     private addTab;
@@ -120,48 +229,9 @@ export declare class Tabs extends CompositeDisposable {
      */
     clearExternalAnimState(): void;
     private snapshotTabPositions;
-    private getAverageTabWidth;
-    /**
-     * Pointer-event entry point. The HTML5 path enters via the per-element
-     * `dragover` listener; this one hit-tests the global pointer-drag
-     * position against the tabs list and routes through the same shared
-     * `_processDragOver` / `_processDragLeave` helpers.
-     */
-    private _handlePointerDragMove;
-    /**
-     * Shared body of the dragover entry point. Refreshes stale anim state
-     * for a changed drag identity, initializes anim state for incoming
-     * cross-group drags, and dispatches to the gap-following math in
-     * `handleDragOver`. Returns true when this tabs list has taken
-     * ownership of the drag — HTML5 callers use this to gate
-     * `event.preventDefault()`.
-     */
-    private _processDragOver;
-    /**
-     * Shared body of the dragleave entry point. Preserves anim state when
-     * the drag moves between tabs-list children, into the extended drop
-     * zone, or into the void container; tears it down otherwise.
-     */
-    private _processDragLeave;
     private handleDragOver;
-    /**
-     * Batch-remove a CSS class from multiple elements instantly,
-     * forcing only a single reflow for the entire batch.
-     */
-    private _removeClassInstantlyBatch;
-    /**
-     * Remove `dv-tab--dragging` from the source tab instantly so it
-     * regains its real width before FLIP snapshots.
-     */
-    private _uncollapsSourceTab;
     private applyDragOverTransforms;
     private resetTabTransforms;
-    /**
-     * Commit a group-drag drop: clear drag classes, move the group
-     * in the model, and run a FLIP animation.
-     */
     private _commitGroupMove;
-    private _clearGroupDragClasses;
-    private resetDragAnimation;
     private runFlipAnimation;
 }

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

@@ -23,6 +23,8 @@ export interface GroupDragEvent {
 }
 export interface ITabsContainer extends IDisposable {
     readonly element: HTMLElement;
+    /** The scrollable tab list element (`.dv-tabs-container`); see `Tabs.tabsListElement`. */
+    readonly tabsListElement: HTMLElement;
     readonly panels: string[];
     readonly size: number;
     readonly onDrop: Event<TabDropIndexEvent>;
@@ -34,6 +36,7 @@ export interface ITabsContainer extends IDisposable {
     delete(id: string): void;
     indexOf(id: string): number;
     getTabId(panelId: string): string | undefined;
+    getPanelForTab(element: Element): IDockviewPanel | undefined;
     setActive(isGroupActive: boolean): void;
     setActivePanel(panel: IDockviewPanel): void;
     focusActiveTab(): void;
@@ -48,6 +51,13 @@ export interface ITabsContainer extends IDisposable {
     updateDragAndDropState(): void;
     updateTabGroups(): void;
     refreshTabGroupAccent(): void;
+    setOverflowExclude(fn: (panelId: string) => boolean): void;
+    setForcedOverflow(fn: (panelId: string) => boolean): void;
+    setPinnedSticky(enabled: boolean): void;
+    refreshOverflow(): void;
+    setDropIndexResolver(fn: (panelId: string, index: number) => number): void;
+    resolveDropIndex(panelId: string, index: number): number;
+    setPinnedRow(el: HTMLElement | undefined): void;
 }
 export declare class TabsContainer extends CompositeDisposable implements ITabsContainer {
     private readonly accessor;
@@ -63,9 +73,22 @@ export declare class TabsContainer extends CompositeDisposable implements ITabsC
     private preActions;
     private _hidden;
     private _direction;
+    /**
+     * Clamps/redirects a header drop index, wired by the PinnedTabs module to
+     * keep drops on the correct side of the pin boundary. Identity by default
+     * so behaviour is unchanged when the module is absent.
+     */
+    private _dropIndexResolver;
+    /** The pinned second-row element (PinnedTabs `separate-row` mode), owned by
+     *  the module and mounted here. Undefined when there is no row. */
+    private _pinnedRow;
     private dropdownPart;
     private _overflowTabs;
     private _overflowTabGroups;
+    /** Pinned tabs that have clipped out of the strip, rendered in a "Pinned"
+     *  section at the top of the dropdown. Empty unless the PinnedTabs module is
+     *  active and the pinned block itself overflows. */
+    private _overflowPinnedTabs;
     private readonly _dropdownDisposable;
     private readonly _onDrop;
     readonly onDrop: Event<TabDropIndexEvent>;
@@ -81,6 +104,7 @@ export declare class TabsContainer extends CompositeDisposable implements ITabsC
     get direction(): DockviewHeaderDirection;
     set direction(value: DockviewHeaderDirection);
     get element(): HTMLElement;
+    get tabsListElement(): HTMLElement;
     constructor(accessor: DockviewComponent, group: DockviewGroupPanel);
     show(): void;
     hide(): void;
@@ -90,14 +114,38 @@ export declare class TabsContainer extends CompositeDisposable implements ITabsC
     isActive(tab: Tab): boolean;
     indexOf(id: string): number;
     getTabId(panelId: string): string | undefined;
+    getPanelForTab(element: Element): IDockviewPanel | 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;
+    setOverflowExclude(fn: (panelId: string) => boolean): void;
+    setForcedOverflow(fn: (panelId: string) => boolean): void;
+    setPinnedSticky(enabled: boolean): void;
+    refreshOverflow(): void;
+    setPinnedRow(el: HTMLElement | undefined): void;
+    setDropIndexResolver(fn: (panelId: string, index: number) => number): void;
+    resolveDropIndex(panelId: string, index: number): number;
     private updateClassnames;
     private toggleDropdown;
+    /**
+     * Build the core row/header builders + popover control shared by the free
+     * overflow list and the advanced overflow module. Everything the module
+     * needs to rebuild the dropdown body in a custom order lives here, so the
+     * row DOM, group-header DOM, click-to-activate, and (critically) the
+     * window-bound popover open/close stay in core, so the module never captures
+     * the wrong `window` for a popped-out group.
+     */
+    private createOverflowRenderContext;
+    /**
+     * The free (module-absent) overflow list: the flat `.dv-tabs-overflow-container`
+     * body with a group header before the first member tab of each overflow
+     * group, in tab (DOM) order. Reuses the shared row/header builders so it
+     * stays identical to the advanced path's per-row DOM.
+     */
+    private renderFreeOverflowList;
     updateDragAndDropState(): void;
     updateTabGroups(): void;
     refreshTabGroupAccent(): void;

package/dist/cjs/dockview/dndCapabilities.d.ts

@@ -2,7 +2,7 @@ import { DockviewOptions } from './options';
 /**
  * Internal mapping of the user-facing `dndStrategy` option into the
  * per-backend capability flags consumed by drag-source / drop-target
- * construction sites. Not part of the public API — consumers only see
+ * construction sites. Not part of the public API; consumers only see
  * the `dndStrategy` option itself.
  */
 export interface DndCapabilities {