dockview-core 7.0.3 → 8.0.0

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

@@ -1,10 +1,10 @@
 import { SerializedGridObject, Gridview, SerializedGridview } from '../gridview/gridview';
-import { DroptargetOverlayModel, Position } from '../dnd/droptarget';
+import { DroptargetOverlayModel, Position, PositionResolver } from '../dnd/droptarget';
 import { DockviewPanel, IDockviewPanel } from './dockviewPanel';
 import { IDisposable } from '../lifecycle';
 import { Event, Emitter } from '../events';
 import { IWatermarkRenderer, GroupviewPanelState } from './types';
-import { AddGroupOptions, AddPanelOptions, DockviewComponentOptions, DockviewDndOverlayEvent, DockviewOptions, MovementOptions, DockviewHeaderPosition } from './options';
+import { AddGroupOptions, AddPanelOptions, DockviewComponentOptions, DockviewDndOverlayEvent, DockviewOptions, MovementOptions, DockviewHeaderPosition, SmartGuidesOptions } from './options';
 import { BaseGrid, IBaseGrid } from '../gridview/baseComponentGridview';
 import { DockviewApi } from '../api/component.api';
 import { Orientation } from '../splitview/splitview';
@@ -18,7 +18,7 @@ import { IFloatingGroupHost } from './floatingGroupService';
 import { IPopoutWindowHost } from './popoutWindowService';
 import { IWatermarkHost } from './watermarkService';
 import { IEdgeGroupServiceHost } from './edgeGroupService';
-import { IAccessibilityHost, IAdvancedDnDHost, IContextMenuHost, IContextMenuService, ITabGroupChipsHost } from './moduleContracts';
+import { IKeyboardNavigationHost, IAdvancedDnDHost, IAutoHideEdgeGroupHost, IContextMenuHost, IContextMenuService, IDndCompassHost, ILayoutHistoryHost, LayoutHistoryChangeEvent, IMultiRowTabsHost, ISmartGuidesHost, SmartGuidesSnapEvent, SmartGuidesSnapTogetherEvent, ITabGroupChipsHost, IPinnedTabsService, IAdvancedOverflowService } from './moduleContracts';
 import { IHeaderActionsHost } from './headerActionsService';
 import { AnchoredBox, AnchorPosition, Box } from '../types';
 import { DockviewPanelRenderer, OverlayRenderContainer } from '../overlay/overlayRenderContainer';
@@ -27,7 +27,7 @@ import { IRootDropTargetHost } from './rootDropTargetService';
 import { ILiveRegionHost } from './liveRegionService';
 import { IDragGhostSpec } from '../dnd/backend';
 import { DropTargetAnchorContainer } from '../dnd/dropTargetAnchorContainer';
-import { EdgeGroupPosition, EdgeGroupOptions, SerializedEdgeGroups } from './dockviewShell';
+import { EdgeGroupPosition, AddEdgeGroupOptions, SerializedEdgeGroups } from './dockviewShell';
 import { DockviewGroupPanelApi } from '../api/dockviewGroupPanelApi';
 import { TabGroupColorPalette } from './tabGroupAccent';
 export interface DockviewPopoutGroupOptions {
@@ -147,6 +147,12 @@ export interface FloatingGroupOptions {
      * group only. See {@link DockviewOptions.floatingGroupDragHandle}.
      */
     dragHandle?: 'titlebar' | 'tabbar';
+    /**
+     * Exclude this floating group from Smart Guides so it never snaps and shows
+     * no guides when dragged (e.g. a pinned HUD). See
+     * {@link DockviewOptions.smartGuides}.
+     */
+    disableSmartGuides?: boolean;
 }
 interface FloatingGroupOptionsInternal extends FloatingGroupOptions {
     skipRemoveGroup?: boolean;
@@ -181,6 +187,14 @@ export interface DockviewActivePanelChangeEvent {
     readonly panel: IDockviewPanel | undefined;
     readonly origin: DockviewOrigin;
 }
+/**
+ * Fired by `onDidPanelPinnedChange` when a panel is pinned or unpinned via the
+ * PinnedTabs module. `isPinned` is the new state.
+ */
+export interface DockviewPanelPinnedChangeEvent {
+    readonly panel: IDockviewPanel;
+    readonly isPinned: boolean;
+}
 export interface PopoutGroupChangeSizeEvent {
     width: number;
     height: number;
@@ -219,6 +233,7 @@ export interface IDockviewComponent extends IBaseGrid<DockviewGroupPanel> {
     readonly onDidAddPanel: Event<IDockviewPanel>;
     readonly onDidLayoutFromJSON: Event<void>;
     readonly onDidActivePanelChange: Event<DockviewActivePanelChangeEvent>;
+    readonly onDidPanelPinnedChange: Event<DockviewPanelPinnedChangeEvent>;
     readonly onWillDragPanel: Event<TabDragEvent>;
     readonly onWillDragGroup: Event<GroupDragEvent>;
     readonly onDidRemoveGroup: Event<DockviewGroupPanel>;
@@ -244,6 +259,7 @@ export interface IDockviewComponent extends IBaseGrid<DockviewGroupPanel> {
     updateOptions(options: DockviewOptions): void;
     moveGroupOrPanel(options: MoveGroupOrPanelOptions): void;
     moveGroup(options: MoveGroupOptions): void;
+    setPanelPinned(panel: DockviewPanel, pinned: boolean): void;
     doSetGroupActive: (group: DockviewGroupPanel, skipFocus?: boolean) => void;
     removeGroup: (group: DockviewGroupPanel) => void;
     addPanel<T extends object = Parameters>(options: AddPanelOptions<T>): IDockviewPanel;
@@ -253,8 +269,8 @@ export interface IDockviewComponent extends IBaseGrid<DockviewGroupPanel> {
     addGroup(options?: AddGroupOptions): DockviewGroupPanel;
     closeAllGroups(): void;
     adjacentGroupInDirection(group: DockviewGroupPanel, direction: GroupNavigationDirection): DockviewGroupPanel | undefined;
-    moveToNext(options?: MovementOptions): void;
-    moveToPrevious(options?: MovementOptions): void;
+    activateNext(options?: MovementOptions): void;
+    activatePrevious(options?: MovementOptions): void;
     setActivePanel(panel: IDockviewPanel): void;
     focus(): void;
     toJSON(): SerializedDockview;
@@ -264,13 +280,40 @@ export interface IDockviewComponent extends IBaseGrid<DockviewGroupPanel> {
     fromJSON(data: any, options?: {
         reuseExistingPanels: boolean;
     }): void;
-    addEdgeGroup(position: EdgeGroupPosition, options: EdgeGroupOptions): DockviewGroupPanelApi;
+    addEdgeGroup(position: EdgeGroupPosition, options: AddEdgeGroupOptions): DockviewGroupPanelApi;
+    revealEdgeGroupWithData(position: EdgeGroupPosition, data: {
+        groupId: string;
+        panelId?: string | null;
+    }, options?: {
+        autoHide?: boolean;
+    }): void;
     getEdgeGroup(position: EdgeGroupPosition): DockviewGroupPanelApi | undefined;
     setEdgeGroupVisible(position: EdgeGroupPosition, visible: boolean): void;
     isEdgeGroupVisible(position: EdgeGroupPosition): boolean;
     removeEdgeGroup(position: EdgeGroupPosition): void;
+    getEdgeGroupPanel(position: EdgeGroupPosition): DockviewGroupPanel | undefined;
+    pinEdgeGroup(position: EdgeGroupPosition): void;
+    autoHideEdgeGroup(position: EdgeGroupPosition): void;
+    peekEdgeGroup(position: EdgeGroupPosition, peek: boolean): void;
+    isEdgeGroupAutoHide(group: DockviewGroupPanel): boolean;
+    setEdgeGroupAutoHide(group: DockviewGroupPanel, value: boolean | undefined): void;
+    readonly onDidEdgeGroupAutoHideChange: Event<DockviewGroupPanel>;
+    readonly overlayRoot: HTMLElement;
+    getEdgeGroupExpandedSize(position: EdgeGroupPosition): number;
+    undo(): void;
+    redo(): void;
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+    clearHistory(): void;
+    readonly onDidChangeHistory: Event<LayoutHistoryChangeEvent>;
+    readonly popoutRestorationPromise: Promise<void>;
+    readonly smartGuidesEnabled: boolean;
+    setSmartGuidesEnabled(enabled: boolean): void;
+    updateSmartGuidesOptions(options: Partial<SmartGuidesOptions>): void;
+    readonly onDidSnapFloat: Event<SmartGuidesSnapEvent>;
+    readonly onDidSnapTogether: Event<SmartGuidesSnapTogetherEvent>;
 }
-export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> implements IDockviewComponent, IFloatingGroupHost, IPopoutWindowHost, IWatermarkHost, IEdgeGroupServiceHost, ITabGroupChipsHost, IContextMenuHost, IRootDropTargetHost, IHeaderActionsHost, IAdvancedDnDHost, ILiveRegionHost, IAccessibilityHost {
+export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> implements IDockviewComponent, IFloatingGroupHost, IPopoutWindowHost, IWatermarkHost, IEdgeGroupServiceHost, ITabGroupChipsHost, IContextMenuHost, IRootDropTargetHost, IHeaderActionsHost, IAdvancedDnDHost, ILiveRegionHost, IKeyboardNavigationHost, ILayoutHistoryHost, IDndCompassHost, ISmartGuidesHost, IAutoHideEdgeGroupHost, IMultiRowTabsHost {
     private readonly nextGroupId;
     private readonly _deserializer;
     private readonly _api;
@@ -281,6 +324,18 @@ export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> impl
     readonly overlayRenderContainer: OverlayRenderContainer;
     readonly popupService: PopupService;
     readonly rootDropTargetContainer: DropTargetAnchorContainer;
+    /**
+     * Shell-level anchor container dedicated to floating groups. Unlike
+     * {@link rootDropTargetContainer} it is never disabled by the
+     * `dndOverlayMounting: 'relative'` theme setting: a floating group cannot
+     * use an in-place ('relative') overlay because the overlay would be
+     * appended inside the floating window's stacking context
+     * (`.dv-resize-container`, a lower z-index than the shell-level render
+     * overlay that hosts the floating panel's content) and be painted over.
+     * Routing floating groups through this always-anchored container keeps
+     * their drop overlays visible in both mounting modes.
+     */
+    readonly floatingDropTargetContainer: DropTargetAnchorContainer;
     private readonly _onWillDragPanel;
     readonly onWillDragPanel: Event<TabDragEvent>;
     private readonly _onWillDragGroup;
@@ -312,12 +367,29 @@ export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> impl
     readonly onDidAddPopoutGroup: Event<PopoutGroup>;
     private readonly _onDidRemovePopoutGroup;
     readonly onDidRemovePopoutGroup: Event<PopoutGroup>;
+    private readonly _onDidChangePopouts;
+    /** Fires whenever a popout window opens or closes, i.e. the set of popout
+     *  documents changed. Used by accessibility services that mirror per-window
+     *  state (e.g. a live region in each popout). */
+    readonly onDidChangePopouts: Event<void>;
     private readonly _onDidOpenPopoutWindowFail;
     readonly onDidOpenPopoutWindowFail: Event<void>;
+    private readonly _onDidStartFloatingGroupDrag;
+    /** Fires with the dragged group when a floating group move-drag first moves.
+     *  Consumed by the Smart Guides service (`ISmartGuidesHost`) to start each
+     *  drag from a clean slate (a redock long-press aborts with no end event). */
+    readonly onDidStartFloatingGroupDrag: Event<DockviewGroupPanel>;
+    private readonly _onDidEndFloatingGroupDrag;
+    /** Fires with the dragged group when a floating group's move/resize drag
+     *  ends. Consumed by the Smart Guides service (`ISmartGuidesHost`) to tear
+     *  down its per-drag guides. */
+    readonly onDidEndFloatingGroupDrag: Event<DockviewGroupPanel>;
     private readonly _onDidLayoutFromJSON;
     readonly onDidLayoutFromJSON: Event<void>;
     private readonly _onDidActivePanelChange;
     readonly onDidActivePanelChange: Event<DockviewActivePanelChangeEvent>;
+    private readonly _onDidPanelPinnedChange;
+    readonly onDidPanelPinnedChange: Event<DockviewPanelPinnedChangeEvent>;
     private readonly _onDidMovePanel;
     readonly onDidMovePanel: Event<MovePanelEvent>;
     private readonly _onDidCreateTabGroup;
@@ -345,6 +417,8 @@ export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> impl
     private _inShellLayout;
     private readonly _onDidRemoveGroup;
     readonly onDidRemoveGroup: Event<DockviewGroupPanel>;
+    private readonly _onDidEdgeGroupAutoHideChange;
+    readonly onDidEdgeGroupAutoHideChange: Event<DockviewGroupPanel>;
     protected readonly _onDidAddGroup: Emitter<DockviewGroupPanel>;
     readonly onDidAddGroup: Event<DockviewGroupPanel>;
     private readonly _onDidOptionsChange;
@@ -361,6 +435,16 @@ export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> impl
     get defaultHeaderPosition(): DockviewHeaderPosition;
     get api(): DockviewApi;
     get floatingGroups(): readonly DockviewFloatingGroupPanel[];
+    /**
+     * Resolve the floating window hosting `group`, matched by membership so it
+     * finds nested (non-anchor) members too — a floating window can host a
+     * whole nested gridview, not just its anchor group. Returns `undefined`
+     * when the group isn't in any floating window. `floatingGroups` alone only
+     * exposes each window's anchor, so consumers that must act on any member
+     * (e.g. lifting an `always`-rendered panel's overlay above the window)
+     * should use this instead of a `.find(f => f.group === group)`.
+     */
+    getFloatingWindowForGroup(group: DockviewGroupPanel): DockviewFloatingGroupPanel | undefined;
     /**
      * Boxes of the floating groups other than `exclude`, in coordinates
      * relative to the floating overlay container. Supplied to a
@@ -368,13 +452,108 @@ export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> impl
      * align the dragged float against its siblings.
      */
     private _gatherFloatingGroupBoxes;
+    /**
+     * ISmartGuidesHost: the positioning parent floats are placed in, also the
+     * coordinate space the Smart Guides overlay draws its alignment lines in.
+     */
+    getFloatingContainer(): HTMLElement;
+    /** ISmartGuidesHost: the other floats' group identity + container-relative
+     *  box, for the snap-together detector. */
+    getFloatingGroupSnapshots(exclude: DockviewGroupPanel): readonly {
+        group: DockviewGroupPanel;
+        box: Box;
+    }[];
+    /** ISmartGuidesHost: dock/merge a dragged float into a target group via the
+     *  existing move primitive (so events + undo cover it). */
+    mergeFloatInto(dragged: DockviewGroupPanel, target: DockviewGroupPanel, position: Position): void;
+    /** ISmartGuidesHost: the main grid's splitter (sash) rectangles, in the
+     *  floating container's coordinate space, for the optional splitter target. */
+    getGridSplitterRects(): Box[];
+    private get _smartGuidesService();
+    /** Whether Smart Guides snapping is currently active. */
+    get smartGuidesEnabled(): boolean;
+    /** Toggle Smart Guides snapping at runtime (no-op if the module is absent). */
+    setSmartGuidesEnabled(enabled: boolean): void;
+    /** Merge a partial Smart Guides option override in at runtime. */
+    updateSmartGuidesOptions(options: Partial<SmartGuidesOptions>): void;
+    /** Fires when a dragged float commits an alignment snap on drop. */
+    get onDidSnapFloat(): Event<SmartGuidesSnapEvent>;
+    /** Fires when a dragged float commits a dock/merge on drop. */
+    get onDidSnapTogether(): Event<SmartGuidesSnapTogetherEvent>;
+    /**
+     * Compose the float drag-position transform from the public
+     * `transformFloatingGroupDrag` option and the optional Smart Guides module,
+     * so an app and the module can both nudge a single drag rather than one
+     * clobbering the other. Returns `undefined` only when the app option is
+     * unset and the module is absent (the removability case); then no transform
+     * is installed and the sibling-box snapshot is skipped, so the drag loop is
+     * truly byte-for-byte unchanged. When the module is present but `smartGuides`
+     * is unset it installs a cheap pass-through (the service snaps nothing and
+     * early-returns), so observable drag behaviour is still unchanged.
+     */
+    private _buildFloatingDragTransform;
     private get _floatingGroupService();
     private get _popoutWindowService();
     private get _watermarkService();
     private get _edgeGroupService();
     private get _rootDropTargetService();
     private get _advancedDnDService();
+    private get _dndCompassService();
+    /** IDndCompassHost: whether a content drop at `position` on `group` is
+     *  allowed, for compass cell gating (only legal cells are shown). The same
+     *  predicate the content drop target uses, so the compass and the real drop
+     *  agree. */
+    canDropOnGroup(group: DockviewGroupPanel, position: Position, event: DragEvent | PointerEvent): boolean;
+    /** IDndCompassHost: the frame the content drop target measures (mirrors the
+     *  `getOverlayOutline` rule in `content.ts`): the whole group when
+     *  `dndPanelOverlay === 'group'`, else just the content. The compass paints
+     *  in this frame so its cells align with where a drop resolves. */
+    getDropOverlayElement(group: DockviewGroupPanel): HTMLElement | undefined;
+    /** IMultiRowTabsHost: the group's scrollable tab list (`.dv-tabs-container`),
+     *  the element the wrap controller toggles + measures. */
+    getTabsListElement(group: DockviewGroupPanel): HTMLElement | undefined;
+    /** IMultiRowTabsHost: re-run a group's layout so a wrapped-header height
+     *  change propagates to the content + active panel. */
+    relayoutGroup(group: DockviewGroupPanel): void;
+    /** IMultiRowTabsHost: force the wrap controller's surplus set (rows beyond
+     *  `overflow.maxRows`) into the group's overflow dropdown. */
+    setForcedOverflow(group: DockviewGroupPanel, fn: (panelId: string) => boolean): void;
+    /** IDndCompassHost: the layout root (`.dv-dockview`, a positioned element),
+     *  the surface the outer-cell landing preview is drawn over. */
+    getLayoutElement(): HTMLElement;
+    /**
+     * The drop-position resolver installed on the group content drop targets:
+     * the app's `dropPositionResolver` option if set, else the DnD compass
+     * module's compass resolver (undefined when the compass is disabled). Read
+     * live by the content drop targets; undefined ⇒ default cursor-quadrant.
+     */
+    getDropPositionResolver(): PositionResolver | undefined;
+    /**
+     * Dock the dragged item against the whole-layout edge at `position` (the
+     * orthogonalized root group), as the layout-edge drop zones do. Shared by
+     * the root drop target and by an `edge`-flagged drop on a group content
+     * target (a position resolver that marks an outer "dock to the layout edge"
+     * cell). No-op when there is no active drag data.
+     */
+    dockToLayoutEdge(nativeEvent: DragEvent | PointerEvent, position: Position): void;
     get headerActionsService(): import("./headerActionsService").IHeaderActionsService | undefined;
+    private get _layoutHistoryService();
+    /** Undo the previous recorded layout mutation (no-op if nothing to undo or
+     *  the LayoutHistory module is absent). Requires `layoutHistory.enabled`. */
+    undo(): void;
+    /** Re-apply the next layout mutation (no-op if nothing to redo). */
+    redo(): void;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    /** Drop both undo and redo stacks. */
+    clearHistory(): void;
+    get onDidChangeHistory(): Event<LayoutHistoryChangeEvent>;
+    /**
+     * Whether the two-band edge drag-reveal affordance is registered. See
+     * {@link IRootDropTargetHost.hasEdgeDragReveal}; must not be read during
+     * module initialisation, only from `init`/postConstruct onwards.
+     */
+    get hasEdgeDragReveal(): boolean;
     isGridEmpty(): boolean;
     rootDropTargetOverrideTarget(): import("../dnd/droptarget").DropTargetTargetModel | undefined;
     dispatchUnhandledDragOver(nativeEvent: DragEvent | PointerEvent, position: Position): boolean;
@@ -385,7 +564,7 @@ export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> impl
     /**
      * Resolve the custom group drag ghost (via the AdvancedDnD module), or
      * `undefined` to fall back to the default chip. Returns `undefined` when
-     * the module is absent — the default ghost then renders.
+     * the module is absent, and the default ghost then renders.
      */
     buildGroupDragGhost(group: DockviewGroupPanel): IDragGhostSpec | undefined;
     /**
@@ -393,13 +572,22 @@ export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> impl
      * for a group drop target, or `undefined` to keep the target's default.
      */
     resolveDropOverlayModel(location: DockviewGroupDropLocation, group?: DockviewGroupPanel): DroptargetOverlayModel | undefined;
-    /** Outermost element — the shell (incl. edge groups) once built, else the gridview. */
+    /** Outermost element: the shell (incl. edge groups) once built, else the gridview. */
     get rootElement(): HTMLElement;
+    /**
+     * Does this dock own `node`, in any of its windows? True when the node is
+     * inside the main shell, or inside one of this component's popout documents.
+     * A popout window hosts only this component's content, so whole-document
+     * membership is sufficient there; the main document may hold sibling docks,
+     * so it must be a containment check. A same-document popout (the jsdom mock)
+     * is already covered by the main check and contributes nothing.
+     */
+    ownsElement(node: Node): boolean;
     /**
      * The next / previous group in gridview (spatial) order, wrapping round.
      * The keyboard accessibility module's focus navigation is built on this
-     * primitive — the only piece that needs the grid internals; the rest of
-     * the navigation logic lives in the AccessibilityService.
+     * primitive, the only piece that needs the grid internals; the rest of
+     * the navigation logic lives in the KeyboardNavigationService.
      */
     adjacentGroup(group: DockviewGroupPanel, reverse: boolean): DockviewGroupPanel | undefined;
     /**
@@ -412,7 +600,22 @@ export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> impl
     showDropPreview(group: DockviewGroupPanel, position: Position): IDisposable;
     announce(message: string): void;
     dockPanel(panel: IDockviewPanel, group: DockviewGroupPanel, position: Position): void;
+    floatPanel(panel: IDockviewPanel): void;
     get contextMenuService(): IContextMenuService | undefined;
+    get pinnedTabsService(): IPinnedTabsService | undefined;
+    get advancedOverflowService(): IAdvancedOverflowService | undefined;
+    /**
+     * Pin/unpin a panel's tab. The single gated entry point behind
+     * `panel.api.setPinned`. Dormant unless `pinnedTabs.enabled` is set (a
+     * silent no-op), and a silent no-op when the PinnedTabs module is not
+     * registered: reaching past the `enabled` check means the option was set,
+     * so the option rule has already named the missing module. When active it
+     * mutates the panel's pinned flag (which fires
+     * `panel.api.onDidChangePinned`) and the component-level
+     * `onDidPanelPinnedChange`; the module reacts to enforce pinned-first
+     * ordering.
+     */
+    setPanelPinned(panel: DockviewPanel, pinned: boolean): void;
     get mountElement(): HTMLElement;
     hasVisibleGridGroup(): boolean;
     fireLayoutChange(): void;
@@ -433,9 +636,12 @@ export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> impl
     addPopoutGroup(itemToPopout: DockviewPanel | DockviewGroupPanel, options?: DockviewPopoutGroupOptionsInternal): Promise<boolean>;
     /** Enumerate the popout groups currently open in their own windows. */
     getPopouts(): PopoutGroup[];
+    /** The live popout `Window` handles, one per open popout group. The
+     *  narrow surface accessibility services need to mirror per-window state. */
+    getPopoutWindows(): Window[];
     private _doAddPopoutGroup;
     /**
-     * The popout window was blocked (e.g. by the browser's popup blocker —
+     * The popout window was blocked (e.g. by the browser's popup blocker,
      * common when restoring popouts on load). Fall back gracefully so the
      * group(s) end up valid and visible in the main grid rather than as
      * orphans that later crash clear()/remove().
@@ -445,7 +651,7 @@ export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> impl
      * Wire a group that has been displaced from a floating / popout window back
      * to the main grid's render & drop-target containers and dock it at the
      * root. The caller is responsible for first detaching it from its old
-     * gridview — the detach strategy differs between the window-teardown path
+     * gridview; the detach strategy differs between the window-teardown path
      * (`doRemoveGroup`) and the blocked-window path (`gridview.remove`).
      */
     private redockGroupToMainGrid;
@@ -472,29 +678,107 @@ export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> impl
     private mountFloatingWindow;
     private orthogonalize;
     updateOptions(options: Partial<DockviewComponentOptions>): void;
+    /**
+     * Report any option the caller set whose module isn't registered. Logs
+     * once per module+reason; never throws, matching the module system's
+     * degrade-to-no-op contract.
+     */
+    private reportMissingOptionModules;
     layout(width: number, height: number, forceResize?: boolean | undefined): void;
     private _syncFloatingOverlayHost;
     private _layoutFromShell;
     protected forceRelayout(): void;
-    addEdgeGroup(position: EdgeGroupPosition, options: EdgeGroupOptions): DockviewGroupPanelApi;
+    addEdgeGroup(position: EdgeGroupPosition, options: AddEdgeGroupOptions): DockviewGroupPanelApi;
+    /**
+     * Reveal (create-or-fill) the edge group at `position` and move the dragged
+     * item described by `data` into it. A newly created edge group is created
+     * collapsed and flagged `autoReveal` so it tears down to zero footprint when
+     * later emptied. If an edge group already exists there it is reused: the
+     * panel is added to its tabs and its collapsed/toggled state is left as-is
+     * (never re-created; `addEdgeGroup` throws on a duplicate position). No-op if
+     * the EdgeGroup module is absent.
+     *
+     * This is the primitive behind the dock-to-edge groups: the two-band
+     * drag-reveal affordance routes its outer-band drops here.
+     */
+    revealEdgeGroupWithData(position: EdgeGroupPosition, data: {
+        groupId: string;
+        panelId?: string | null;
+    }, options?: {
+        autoHide?: boolean;
+    }): void;
     getEdgeGroup(position: EdgeGroupPosition): DockviewGroupPanelApi | undefined;
+    /** The edge group panel at a position (the model, not the api). */
+    getEdgeGroupPanel(position: EdgeGroupPosition): DockviewGroupPanel | undefined;
+    /** Pin (expand) the edge group at a position. Reports the missing module if
+     *  AutoHideEdgeGroup is absent, since this command is reachable without the
+     *  `autoHideEdgeGroups` option that would otherwise have named it. */
+    pinEdgeGroup(position: EdgeGroupPosition): void;
+    /** Auto-hide (collapse to strip) the edge group at a position. */
+    autoHideEdgeGroup(position: EdgeGroupPosition): void;
+    /** Peek (slide out) / close the collapsed edge group at a position. */
+    peekEdgeGroup(position: EdgeGroupPosition, peek: boolean): void;
+    /** The auto-hide peek mounts on the shell, the same element the
+     *  `OverlayRenderContainer` roots on, so `always` content re-anchors in the
+     *  peek's coordinate space. */
+    get overlayRoot(): HTMLElement;
+    /** Viewport rect of the docked content area (the element the root/group drop
+     *  targets hit-test against), used by the two-band drag-reveal affordance to
+     *  classify a pointer's distance from each edge. This is the gridview/center
+     *  container, which is inset when edge groups are present, so the outer band
+     *  sits at the boundary of the content area (adjacent to any existing edge
+     *  group) rather than at the shell's outer edge. */
+    getDropZoneRect(): DOMRect;
+    /** The size an edge group expands to (pre-collapse); sizes the peek. */
+    getEdgeGroupExpandedSize(position: EdgeGroupPosition): number;
+    /** Reposition a single `renderer:'always'` panel's overlay over its
+     *  reference container, optionally forcing it visible (the auto-hide peek
+     *  slides an `always` panel out without reparenting it or touching its
+     *  visibility state). No-op for non-overlay-rendered panels. */
+    repositionPanelOverlay(panel: IDockviewPanel, forceVisible: boolean, clip?: DOMRect): void;
     setEdgeGroupVisible(position: EdgeGroupPosition, visible: boolean): void;
     isEdgeGroupVisible(position: EdgeGroupPosition): boolean;
     removeEdgeGroup(position: EdgeGroupPosition): void;
     setEdgeGroupCollapsed(group: DockviewGroupPanel, collapsed: boolean): void;
     isEdgeGroupCollapsed(group: DockviewGroupPanel): boolean;
+    /** Edge groups currently peeking (auto-hide). The peek state is owned by the
+     *  auto-hide module; the component just records it so `group.api.isPeeking()`
+     *  / `onDidPeekChange` work. */
+    private readonly _peekingGroups;
+    isEdgeGroupPeeking(group: DockviewGroupPanel): boolean;
+    /** Set the peek state and fire the group's `onDidPeekChange` (called by the
+     *  auto-hide service). */
+    setEdgeGroupPeeking(group: DockviewGroupPanel, peeking: boolean): void;
+    /**
+     * Resolve whether an edge group should behave as an auto-hide (pinnable)
+     * tool window: the per-group flag when set, otherwise the per-edge
+     * `autoHideEdgeGroups` option for the group's edge. This is what lets a
+     * static edge group and an auto-hiding one co-exist in the same layout.
+     */
+    isEdgeGroupAutoHide(group: DockviewGroupPanel): boolean;
+    /**
+     * Set (or clear, via `undefined`) the per-group auto-hide flag and notify
+     * the auto-hide module so it can dock/undock the group at runtime.
+     */
+    setEdgeGroupAutoHide(group: DockviewGroupPanel, value: boolean | undefined): void;
     private updateDragAndDropState;
     focus(): void;
     getGroupPanel(id: string): IDockviewPanel | undefined;
     setActivePanel(panel: IDockviewPanel): void;
-    moveToNext(options?: MovementOptions): void;
-    moveToPrevious(options?: MovementOptions): void;
+    activateNext(options?: MovementOptions): void;
+    activatePrevious(options?: MovementOptions): void;
     /**
      * Serialize the current state of the layout
      *
      * @returns A JSON respresentation of the layout
      */
     toJSON(): SerializedDockview;
+    /**
+     * Serialize the edge groups, augmenting each shell entry with the serialized
+     * group state + the component-owned per-group presentation flags (the shell
+     * only knows geometry/collapse). Returns `undefined` when there are none.
+     */
+    private _serializeEdgeGroups;
     fromJSON(data: SerializedDockview, options?: {
         reuseExistingPanels: boolean;
     }): void;
@@ -536,7 +820,7 @@ export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> impl
      *
      * @returns `true` if the group was detached from a multi-member window;
      * `false` if `group` is not in a nested window, or is the window's only
-     * member — in which case the caller is responsible for disposing the whole
+     * member, in which case the caller is responsible for disposing the whole
      * window.
      */
     private detachFromNestedWindow;
@@ -579,7 +863,7 @@ export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> impl
      * Run `func` with the operation origin set to `origin`, restoring the
      * previous value afterwards. Used by the DockviewApi boundary to tag
      * programmatic operations as `'api'`, and by user-gesture handlers to tag
-     * `'user'`. Only the outermost caller sets the origin — a nested call (or a
+     * `'user'`. Only the outermost caller sets the origin; a nested call (or a
      * call made while a mutation is already in flight) keeps whatever the
      * enclosing operation established, so the trigger always wins.
      */

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

@@ -30,6 +30,11 @@ export declare class DockviewGroupPanel extends GridviewPanel<DockviewGroupPanel
     initialize(): void;
     setActive(isActive: boolean): void;
     layout(width: number, height: number): void;
+    /**
+     * Re-run the group's layout with its current dimensions, propagating a
+     * header-size change down to the content + active panel.
+     */
+    relayout(): void;
     getComponent(): IFrameworkPart;
     toJSON(): any;
 }

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

@@ -50,7 +50,7 @@ export interface DockviewGroupChangeEvent {
 /**
  * Payload for the group-level `onDidActivePanelChange`. Extends
  * {@link DockviewGroupChangeEvent} with the {@link DockviewOrigin} so it mirrors
- * the component-level `DockviewActivePanelChangeEvent` — both report whether the
+ * the component-level `DockviewActivePanelChangeEvent`. Both report whether the
  * change came from a user gesture or an API call.
  */
 export interface DockviewGroupActivePanelChangeEvent extends DockviewGroupChangeEvent {
@@ -96,6 +96,25 @@ export declare class DockviewWillDropEvent extends DockviewDidDropEvent {
 export interface IHeader {
     hidden: boolean;
     direction: DockviewHeaderDirection;
+    /** Register a predicate that keeps matching panels out of the overflow
+     *  dropdown (used by the PinnedTabs module). No-op default. */
+    setOverflowExclude(fn: (panelId: string) => boolean): void;
+    /** Register a predicate that forces matching panels into the overflow
+     *  dropdown regardless of horizontal fit (used by the MultiRowTabs module
+     *  for the surplus rows beyond `overflow.maxRows`). No-op default. */
+    setForcedOverflow(fn: (panelId: string) => boolean): void;
+    /** Re-evaluate the overflow dropdown now (e.g. after the exclusion set
+     *  changed). */
+    refreshOverflow(): void;
+    /** Enable/disable sticky-on-scroll for pinned tabs (PinnedTabs inline mode):
+     *  pinned tabs freeze to the left edge as the strip scrolls. No-op default. */
+    setPinnedSticky(enabled: boolean): void;
+    /** Register a resolver that clamps/redirects a header drop index (used by
+     *  the PinnedTabs module to enforce the pin boundary). Identity default. */
+    setDropIndexResolver(fn: (panelId: string, index: number) => number): void;
+    /** Mount (or clear, with `undefined`) a second tab row above the main strip
+     *  (PinnedTabs `separate-row` mode). The module owns the element. */
+    setPinnedRow(el: HTMLElement | undefined): void;
 }
 export type DockviewGroupPanelLocked = boolean | 'no-drop-target';
 export interface IDockviewGroupPanelModel extends IPanel {
@@ -115,6 +134,8 @@ export interface IDockviewGroupPanelModel extends IPanel {
     headerPosition: DockviewHeaderPosition;
     setActive(isActive: boolean): void;
     initialize(): void;
+    relayout(): void;
+    readonly tabsListElement: HTMLElement;
     isPanelActive: (panel: IDockviewPanel) => boolean;
     indexOf(panel: IDockviewPanel): number;
     openPanel(panel: IDockviewPanel, options?: {
@@ -164,6 +185,7 @@ export declare class DockviewGroupPanelModel extends CompositeDisposable impleme
     private _isGroupActive;
     private _locked;
     private _headerPosition;
+    private _headerDirection;
     private _location;
     private mostRecentlyUsed;
     private _overwriteRenderContainer;
@@ -237,7 +259,7 @@ export declare class DockviewGroupPanelModel extends CompositeDisposable impleme
     get activePanel(): IDockviewPanel | undefined;
     /** DOM id of the content container (the group's tabpanel), referenced by each tab's `aria-controls`. */
     get contentContainerId(): string;
-    /** The group's content drop target — lets keyboard docking preview a drop here. */
+    /** The group's content drop target; lets keyboard docking preview a drop here. */
     get contentDropTarget(): Droptarget;
     get locked(): DockviewGroupPanelLocked;
     set locked(value: DockviewGroupPanelLocked);
@@ -247,6 +269,13 @@ export declare class DockviewGroupPanelModel extends CompositeDisposable impleme
     get isEmpty(): boolean;
     get hasWatermark(): boolean;
     get header(): IHeader;
+    /** The scrollable tab list element (`.dv-tabs-container`), exposed for the
+     *  multi-row wrap controller to measure rows / toggle the wrap class. */
+    get tabsListElement(): HTMLElement;
+    /** The panel whose tab owns `element` (the tab itself or a descendant of
+     *  it), or `undefined` when the target isn't a tab. The robust inverse of a
+     *  tab→panel lookup, with no positional/DOM-order assumptions. */
+    getPanelForTab(element: Element): IDockviewPanel | undefined;
     get isContentFocused(): boolean;
     get headerPosition(): DockviewHeaderPosition;
     set headerPosition(value: DockviewHeaderPosition);
@@ -342,6 +371,20 @@ export declare class DockviewGroupPanelModel extends CompositeDisposable impleme
     updateActions(element: HTMLElement | undefined): void;
     setActive(isGroupActive: boolean, force?: boolean): void;
     layout(width: number, height: number): void;
+    /**
+     * Re-run the group's layout with its current dimensions. Used to propagate a
+     * header-size change (e.g. a header that grew/shrank without the group box
+     * changing) down to the content + active panel.
+     */
+    relayout(): void;
+    /**
+     * The dimensions available to the content/panel: the group box minus the
+     * header along its axis. The header (`dv-tabs-and-actions-container`) is
+     * laid out top/bottom (subtract its height) or left/right (subtract its
+     * width); a hidden header has `display:none` so its `offset*` is 0 and
+     * nothing is subtracted.
+     */
+    private contentDimensions;
     private _removePanel;
     private doRemovePanel;
     private doAddPanel;
@@ -351,6 +394,13 @@ export declare class DockviewGroupPanelModel extends CompositeDisposable impleme
     private updateMru;
     private updateContainer;
     canDisplayOverlay(event: DragEvent | PointerEvent, position: Position, target: DockviewGroupDropLocation): boolean;
+    /**
+     * Whether a content drop at `position` is allowed: the locked rules, the
+     * shift-to-not-drop gesture, the same-component shortcut, then the
+     * `canDisplayOverlay` veto. The single source of truth for the content drop
+     * target (`content.ts`) and the compass cell gating (`canDropOnGroup`).
+     */
+    canDisplayContentOverlay(event: DragEvent | PointerEvent, position: Position): boolean;
     private handleDropEvent;
     updateDragAndDropState(): void;
     dispose(): void;