dockview-core 7.0.3 → 8.0.0

package/LICENCE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 mathuo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,96 +1,27 @@
 <div align="center">
+
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://github.com/dockview/dockview/blob/HEAD/static/img/dockview-lockup-dark.svg?raw=true">
+  <img src="https://github.com/dockview/dockview/blob/HEAD/static/img/dockview-lockup-light.svg?raw=true" alt="Dockview" width="480">
+</picture>
+
 <h1>dockview-core</h1>
 
-<p>Framework-agnostic core layout engine — zero dependencies, JavaScript. Supports tabs, groups, grids and splitviews</p>
+<p>Internal core layout engine. Not a supported install target.</p>
 
 </div>
 
 ---
 
-[![npm version](https://badge.fury.io/js/dockview-core.svg)](https://www.npmjs.com/package/dockview-core)
-[![npm](https://img.shields.io/npm/dm/dockview-core)](https://www.npmjs.com/package/dockview-core)
-[![CI Build](https://github.com/mathuo/dockview/workflows/CI/badge.svg)](https://github.com/mathuo/dockview/actions?query=workflow%3ACI)
-[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=mathuo_dockview&metric=coverage)](https://sonarcloud.io/summary/overall?id=mathuo_dockview)
-[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=mathuo_dockview&metric=alert_status)](https://sonarcloud.io/summary/overall?id=mathuo_dockview)
-[![Bundle Phobia](https://badgen.net/bundlephobia/minzip/dockview-core)](https://bundlephobia.com/result?p=dockview-core)
-
-##
-
-![](https://github.com/mathuo/dockview/blob/HEAD/packages/docs/static/img/splashscreenv2.png?raw=true)
-
-Please see the website: https://dockview.dev
-
-> **`dockview-core` is an internal package.** Install
-> **[`dockview`](https://www.npmjs.com/package/dockview)** instead — the JavaScript
-> JavaScript / TypeScript package that ships the full feature set out of the box. Using a
-> framework? Install the bindings: [`dockview-react`](https://www.npmjs.com/package/dockview-react),
-> [`dockview-vue`](https://www.npmjs.com/package/dockview-vue) or
-> [`dockview-angular`](https://www.npmjs.com/package/dockview-angular).
-
-## Features
-
--   Serialization / deserialization with full layout management
--   Support for split-views, grid-views and 'dockable' views
--   Themeable and customizable
--   Tab and Group docking / Drag n' Drop
--   Touch & mobile support
--   Popout Windows
--   Floating Groups
--   Edge Groups
--   Tab Groups
--   Extensive API
--   Supports Shadow DOMs
--   High test coverage
--   Documentation website with live examples
--   Transparent builds and Code Analysis
--   Security at mind - verified publishing and builds through GitHub Actions
-
-## Quick Start
-
-Install from [npm](https://www.npmjs.com/package/dockview-core):
-
-```
-npm install dockview-core
-```
-
-Import the stylesheet:
-
-```css
-@import 'dockview-core/dist/styles/dockview.css';
-```
-
-Create a dockview instance:
-
-```ts
-import { DockviewComponent } from 'dockview-core';
-
-const element = document.getElementById('app');
-
-const dockview = new DockviewComponent(element, {
-    createComponent: (options) => {
-        switch (options.name) {
-            case 'my-component':
-                return {
-                    init: (params) => {
-                        params.containerElement.textContent = 'Hello World';
-                    },
-                };
-        }
-    },
-});
-
-dockview.addPanel({
-    id: 'panel_1',
-    component: 'my-component',
-});
-```
-
-Apply a theme to a parent element:
-
-```html
-<div id="app" class="dockview-theme-dark" style="height: 400px;"></div>
-```
+> **`dockview-core` is an internal package.** It is published only because the
+> public packages depend on it at install time. Install one of these instead:
+>
+> -   **[`dockview`](https://www.npmjs.com/package/dockview)** - JavaScript / TypeScript
+> -   **[`dockview-react`](https://www.npmjs.com/package/dockview-react)** - React
+> -   **[`dockview-vue`](https://www.npmjs.com/package/dockview-vue)** - Vue 3
+> -   **[`dockview-angular`](https://www.npmjs.com/package/dockview-angular)** - Angular
 
-See the [documentation](https://dockview.dev) for full examples.
+`dockview` re-exports this package in full, so everything documented on the website
+is available from `dockview` or a framework binding.
 
-Want to verify our builds? Go [here](https://www.npmjs.com/package/dockview-core#Provenance).
+Documentation: https://dockview.dev

package/dist/cjs/api/component.api.d.ts

@@ -1,5 +1,6 @@
-import { DockviewActivePanelChangeEvent, DockviewLayoutMutationEvent, DockviewMaximizedGroupChangeEvent, DockviewPopoutGroupOptions, FloatingGroupOptions, GroupNavigationDirection, IDockviewComponent, MovePanelEvent, PopoutGroup, PopoutGroupChangePositionEvent, PopoutGroupChangeSizeEvent, SerializedDockview } from '../dockview/dockviewComponent';
-import { AddGroupOptions, AddPanelOptions, DockviewComponentOptions, DockviewDndOverlayEvent, MovementOptions } from '../dockview/options';
+import { DockviewActivePanelChangeEvent, DockviewPanelPinnedChangeEvent, DockviewLayoutMutationEvent, DockviewMaximizedGroupChangeEvent, DockviewPopoutGroupOptions, FloatingGroupOptions, GroupNavigationDirection, IDockviewComponent, MovePanelEvent, PopoutGroup, PopoutGroupChangePositionEvent, PopoutGroupChangeSizeEvent, SerializedDockview } from '../dockview/dockviewComponent';
+import { AddGroupOptions, AddPanelOptions, DockviewComponentOptions, DockviewDndOverlayEvent, MovementOptions, SmartGuidesOptions } from '../dockview/options';
+import { DockviewMessages } from '../dockview/accessibilityMessages';
 import { Parameters } from '../panel/types';
 import { Direction } from '../gridview/baseComponentGridview';
 import { AddGridviewComponentOptions, IGridviewComponent, SerializedGridviewComponent } from '../gridview/gridviewComponent';
@@ -11,6 +12,7 @@ import { IView, Orientation, Sizing } from '../splitview/splitview';
 import { ISplitviewPanel } from '../splitview/splitviewPanel';
 import { DockviewGroupPanel, IDockviewGroupPanel } from '../dockview/dockviewGroupPanel';
 import { Event } from '../events';
+import { LayoutHistoryChangeEvent, SmartGuidesSnapEvent, SmartGuidesSnapTogetherEvent } from '../dockview/moduleContracts';
 import { IDockviewPanel } from '../dockview/dockviewPanel';
 import { PaneviewDidDropEvent } from '../paneview/draggablePaneviewPanel';
 import { GroupDragEvent, TabDragEvent } from '../dockview/components/titlebar/tabsContainer';
@@ -21,7 +23,7 @@ import { DockviewTabGroupColorEntry } from '../dockview/tabGroupAccent';
 import { PaneviewComponentOptions, PaneviewDndOverlayEvent } from '../paneview/options';
 import { SplitviewComponentOptions } from '../splitview/options';
 import { GridviewComponentOptions } from '../gridview/options';
-import { EdgeGroupPosition, EdgeGroupOptions } from '../dockview/dockviewShell';
+import { EdgeGroupPosition, AddEdgeGroupOptions } from '../dockview/dockviewShell';
 import { DockviewGroupPanelApi } from './dockviewGroupPanelApi';
 export interface CommonApi<T = any> {
     readonly height: number;
@@ -384,6 +386,11 @@ export declare class DockviewApi implements CommonApi<SerializedDockview> {
      * {@link DockviewOrigin} (`'user'` vs `'api'`) of the change.
      */
     get onDidActivePanelChange(): Event<DockviewActivePanelChangeEvent>;
+    /**
+     * Fired when a panel is pinned or unpinned (PinnedTabs module). Carries the
+     * panel and its new `isPinned` state.
+     */
+    get onDidPanelPinnedChange(): Event<DockviewPanelPinnedChangeEvent>;
     /**
      * Invoked when a panel is added. May be called multiple times when moving panels.
      */
@@ -416,7 +423,7 @@ export declare class DockviewApi implements CommonApi<SerializedDockview> {
      * Fires before each top-level structural layout mutation (add / remove /
      * move / float / popout / maximize / load / clear). Compound operations
      * (e.g. a drag) fire once. Pair with `onDidMutateLayout` to bracket a
-     * change — useful for undo/redo, autosave and dirty-tracking.
+     * change, which is useful for undo/redo, autosave and dirty-tracking.
      */
     get onWillMutateLayout(): Event<DockviewLayoutMutationEvent>;
     /** Fires after each top-level structural layout mutation. See `onWillMutateLayout`. */
@@ -451,7 +458,7 @@ export declare class DockviewApi implements CommonApi<SerializedDockview> {
      */
     get onDidAddPopoutGroup(): Event<PopoutGroup>;
     /**
-     * Fires when a popout group is removed — whether the user closed its window
+     * Fires when a popout group is removed, whether the user closed its window
      * or it was docked back programmatically. Symmetric with
      * {@link onDidAddPopoutGroup}; not fired during component disposal.
      */
@@ -493,7 +500,7 @@ export declare class DockviewApi implements CommonApi<SerializedDockview> {
     get groups(): DockviewGroupPanel[];
     /**
      * The nearest grid group in a spatial direction from `group`, comparing
-     * group centre points — e.g. the group visually to the left. Floating and
+     * group centre points, e.g. the group visually to the left. Floating and
      * popout groups are ignored. Returns `undefined` when there is no group in
      * that direction. Pair with `group.api.boundingBox` to build your own
      * spatial navigation.
@@ -507,6 +514,12 @@ export declare class DockviewApi implements CommonApi<SerializedDockview> {
      * Active group object.
      */
     get activeGroup(): DockviewGroupPanel | undefined;
+    /**
+     * The resolved accessibility message catalog (the app's `messages`
+     * overrides merged over the English defaults). Used by parts that surface
+     * localisable AT strings, e.g. the default tab's close-button label.
+     */
+    get messages(): DockviewMessages;
     constructor(component: IDockviewComponent);
     /**
      *  Focus the component. Will try to focus an active panel if one exists.
@@ -563,11 +576,64 @@ export declare class DockviewApi implements CommonApi<SerializedDockview> {
      */
     clear(): void;
     /**
-     * Move the focus progmatically to the next panel or group.
+     * Undo the previous recorded layout mutation. No-op when there is nothing
+     * to undo, when `layoutHistory.enabled` is not set, or when the
+     * LayoutHistory module is absent.
+     */
+    undo(): void;
+    /** Re-apply the next layout mutation undone via {@link undo}. */
+    redo(): void;
+    /** Whether {@link undo} would do something. Reactive via {@link onDidChangeHistory}. */
+    get canUndo(): boolean;
+    /** Whether {@link redo} would do something. */
+    get canRedo(): boolean;
+    /** Drop both undo and redo stacks (e.g. on document switch). */
+    clearHistory(): void;
+    /** Fires whenever the undo/redo stacks change. */
+    get onDidChangeHistory(): Event<LayoutHistoryChangeEvent>;
+    /**
+     * Whether Smart Guides snapping is active (the `smartGuides` option is
+     * present + enabled and the module is registered). Reactive via
+     * {@link setSmartGuidesEnabled}.
+     */
+    get smartGuidesEnabled(): boolean;
+    /** Toggle Smart Guides snapping at runtime (no-op when 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 floating group commits an alignment snap on drop. */
+    get onDidSnapFloat(): Event<SmartGuidesSnapEvent>;
+    /** Fires when a dragged floating group docks/merges into another on drop. */
+    get onDidSnapTogether(): Event<SmartGuidesSnapTogetherEvent>;
+    /**
+     * Resolves once any in-flight popout-window restoration completes. Popout
+     * windows re-open asynchronously, so after an {@link undo} / {@link redo} (or
+     * {@link fromJSON}) that re-opens a popout, await this to know the window is
+     * ready. Already-resolved when nothing is restoring.
+     */
+    get popoutRestorationPromise(): Promise<void>;
+    /**
+     * Activate the next panel or group, moving focus programmatically. Pass
+     * `{ includePanel: true }` to step through the panels of the active group
+     * before advancing to the next group.
+     */
+    activateNext(options?: MovementOptions): void;
+    /**
+     * Activate the previous panel or group, moving focus programmatically. Pass
+     * `{ includePanel: true }` to step through the panels of the active group
+     * before advancing to the previous group.
+     */
+    activatePrevious(options?: MovementOptions): void;
+    /**
+     * @deprecated Use {@link DockviewApi.activateNext} instead. Renamed because
+     * this advances the active panel/group (focus), it does not relocate a
+     * panel. Removal planned for a future major release.
      */
     moveToNext(options?: MovementOptions): void;
     /**
-     * Move the focus progmatically to the previous panel or group.
+     * @deprecated Use {@link DockviewApi.activatePrevious} instead. Renamed
+     * because this advances the active panel/group (focus), it does not
+     * relocate a panel. Removal planned for a future major release.
      */
     moveToPrevious(options?: MovementOptions): void;
     maximizeGroup(panel: IDockviewPanel): void;
@@ -582,7 +648,19 @@ export declare class DockviewApi implements CommonApi<SerializedDockview> {
      * Add an edge group at the given position. Returns the group panel API
      * for the newly created group. Throws if a group already exists there.
      */
-    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 tears down to
+     * zero footprint when later emptied. Drives the dock-to-edge groups behind
+     * the `dockToEdgeGroups` option; a no-op if edge groups are unavailable.
+     */
+    revealEdgeGroupWithData(position: EdgeGroupPosition, data: {
+        groupId: string;
+        panelId?: string | null;
+    }, options?: {
+        autoHide?: boolean;
+    }): void;
     /**
      * Get the group panel API for an edge group at the given position.
      * Returns `undefined` if no edge group is configured at that position.
@@ -601,6 +679,19 @@ export declare class DockviewApi implements CommonApi<SerializedDockview> {
      * All panels inside the group are disposed. Throws if no group exists at position.
      */
     removeEdgeGroup(position: EdgeGroupPosition): void;
+    /**
+     * Pin (expand) the collapsed edge group at `position`. Requires the
+     * auto-hide edge groups module; no-op when it is absent.
+     */
+    pinEdgeGroup(position: EdgeGroupPosition): void;
+    /** Auto-hide (collapse to a strip) the edge group at `position`. */
+    autoHideEdgeGroup(position: EdgeGroupPosition): void;
+    /**
+     * Peek (slide out as an overlay, without reflowing the grid) or close the
+     * collapsed edge group at `position`. No-op when the auto-hide module is
+     * absent or the group is not collapsed.
+     */
+    peekEdgeGroup(position: EdgeGroupPosition, peek: boolean): void;
     updateOptions(options: Partial<DockviewComponentOptions>): void;
     private _getGroupModel;
     createTabGroup(options: {

package/dist/cjs/api/dockviewGroupPanelApi.d.ts

@@ -3,7 +3,7 @@ import { DockviewComponent } from '../dockview/dockviewComponent';
 import { Box } from '../types';
 import { DockviewGroupPanel } from '../dockview/dockviewGroupPanel';
 import { DockviewGroupActivePanelChangeEvent, DockviewGroupLocation, DockviewGroupPanelLocked } from '../dockview/dockviewGroupPanelModel';
-import { DockviewHeaderPosition } from '../dockview/options';
+import { DockviewHeaderDirection, DockviewHeaderPosition } from '../dockview/options';
 import { Emitter, Event } from '../events';
 import { GridviewPanelApi, GridviewPanelApiImpl, SizeEvent } from './gridviewPanelApi';
 export interface DockviewGroupMoveParams {
@@ -21,6 +21,15 @@ export interface DockviewGroupMoveParams {
 export interface DockviewGroupPanelCollapsedChangeEvent {
     readonly isCollapsed: boolean;
 }
+export interface DockviewGroupPanelPeekChangeEvent {
+    readonly isPeeking: boolean;
+}
+export interface DockviewGroupPanelHeaderDirectionChangeEvent {
+    /** The header's new axis: `'horizontal'` (top/bottom) or `'vertical'` (left/right). */
+    readonly direction: DockviewHeaderDirection;
+    /** The header position that produced the new direction. */
+    readonly position: DockviewHeaderPosition;
+}
 export interface DockviewGroupPanelApi extends GridviewPanelApi {
     readonly onDidLocationChange: Event<DockviewGroupPanelLocationChangeEvent>;
     /**
@@ -36,6 +45,19 @@ export interface DockviewGroupPanelApi extends GridviewPanelApi {
      * Never fires for non-edge groups.
      */
     readonly onDidCollapsedChange: Event<DockviewGroupPanelCollapsedChangeEvent>;
+    /**
+     * Fired when an edge group's auto-hide *peek* state changes (the slid-out
+     * overlay shown/hidden while the group stays logically collapsed). Never
+     * fires for non-edge groups or without the auto-hide module.
+     */
+    readonly onDidPeekChange: Event<DockviewGroupPanelPeekChangeEvent>;
+    /**
+     * Fires when this group's header flips orientation between horizontal
+     * (top/bottom) and vertical (left/right), e.g. when `headerPosition`
+     * moves from `top` to `left`. Does not fire for position changes that
+     * keep the same axis (top↔bottom, left↔right) or for the initial set.
+     */
+    readonly onDidHeaderDirectionChange: Event<DockviewGroupPanelHeaderDirectionChangeEvent>;
     readonly location: DockviewGroupLocation;
     /**
      * Whether this group is locked against drop interactions.
@@ -68,6 +90,21 @@ export interface DockviewGroupPanelApi extends GridviewPanelApi {
      * Always returns false for non-edge groups.
      */
     isCollapsed(): boolean;
+    /** True while this edge group is peeking (auto-hide slid-out overlay). */
+    isPeeking(): boolean;
+    /**
+     * Opt this edge group in/out of auto-hide (pinnable tool-window) behaviour
+     * at runtime, overriding the global `autoHideEdgeGroups` option. Pass
+     * `undefined` to clear the override and inherit the global. No-op for
+     * non-edge groups or without the auto-hide module.
+     */
+    setAutoHide(value: boolean | undefined): void;
+    /**
+     * The resolved auto-hide state of this edge group: the per-group override
+     * if one is set, otherwise the global `autoHideEdgeGroups` option for this
+     * edge. Always returns false for non-edge groups.
+     */
+    isAutoHide(): boolean;
 }
 export interface DockviewGroupPanelLocationChangeEvent {
     readonly location: DockviewGroupLocation;
@@ -82,6 +119,10 @@ export declare class DockviewGroupPanelApiImpl extends GridviewPanelApiImpl {
     readonly onDidActivePanelChange: Event<DockviewGroupActivePanelChangeEvent>;
     readonly _onDidCollapsedChange: Emitter<DockviewGroupPanelCollapsedChangeEvent>;
     readonly onDidCollapsedChange: Event<DockviewGroupPanelCollapsedChangeEvent>;
+    readonly _onDidPeekChange: Emitter<DockviewGroupPanelPeekChangeEvent>;
+    readonly onDidPeekChange: Event<DockviewGroupPanelPeekChangeEvent>;
+    readonly _onDidHeaderDirectionChange: Emitter<DockviewGroupPanelHeaderDirectionChangeEvent>;
+    readonly onDidHeaderDirectionChange: Event<DockviewGroupPanelHeaderDirectionChangeEvent>;
     get location(): DockviewGroupLocation;
     /**
      * The group's bounding box relative to the top-left of the dockview root,
@@ -105,5 +146,8 @@ export declare class DockviewGroupPanelApiImpl extends GridviewPanelApiImpl {
     collapse(): void;
     expand(): void;
     isCollapsed(): boolean;
+    isPeeking(): boolean;
+    setAutoHide(value: boolean | undefined): void;
+    isAutoHide(): boolean;
     initialize(group: DockviewGroupPanel): void;
 }

package/dist/cjs/api/dockviewPanelApi.d.ts

@@ -9,6 +9,9 @@ import { DockviewGroupLocation } from '../dockview/dockviewGroupPanelModel';
 export interface TitleEvent {
     readonly title: string;
 }
+export interface PinnedChangeEvent {
+    readonly isPinned: boolean;
+}
 export interface RendererChangedEvent {
     readonly renderer: DockviewPanelRenderer;
 }
@@ -29,14 +32,28 @@ export interface DockviewPanelApi extends Omit<GridviewPanelApi, 'setVisible' |
     readonly isGroupActive: boolean;
     readonly renderer: DockviewPanelRenderer;
     readonly title: string | undefined;
+    /**
+     * Whether this panel's tab is pinned. Pinned tabs render before unpinned
+     * tabs, never overflow, and resist cross-boundary reorder. Owned by the
+     * PinnedTabs module. Reads `false` until a panel is pinned, which requires
+     * `pinnedTabs.enabled` (both `setPinned` and restore are gated on it), so a
+     * component with pinning disabled always reports `false`.
+     */
+    readonly isPinned: boolean;
     readonly onDidActiveGroupChange: Event<ActiveGroupEvent>;
     readonly onDidGroupChange: Event<GroupChangedEvent>;
     readonly onDidTitleChange: Event<TitleEvent>;
+    readonly onDidChangePinned: Event<PinnedChangeEvent>;
     readonly onDidRendererChange: Event<RendererChangedEvent>;
     readonly location: DockviewGroupLocation;
     readonly onDidLocationChange: Event<DockviewGroupPanelLocationChangeEvent>;
     close(): void;
     setTitle(title: string): void;
+    /**
+     * Pin or unpin this panel's tab. No-op (warns once) when the PinnedTabs
+     * module is not registered, and dormant unless `pinnedTabs.enabled` is set.
+     */
+    setPinned(pinned: boolean): void;
     setRenderer(renderer: DockviewPanelRenderer): void;
     moveTo(options: DockviewPanelMoveParams): void;
     maximize(): void;
@@ -54,6 +71,8 @@ export declare class DockviewPanelApiImpl extends GridviewPanelApiImpl implement
     private readonly _tabComponent;
     readonly _onDidTitleChange: Emitter<TitleEvent>;
     readonly onDidTitleChange: Event<TitleEvent>;
+    readonly _onDidChangePinned: Emitter<PinnedChangeEvent>;
+    readonly onDidChangePinned: Event<PinnedChangeEvent>;
     private readonly _onDidActiveGroupChange;
     readonly onDidActiveGroupChange: Event<ActiveGroupEvent>;
     private readonly _onDidGroupChange;
@@ -65,6 +84,7 @@ export declare class DockviewPanelApiImpl extends GridviewPanelApiImpl implement
     private readonly groupEventsDisposable;
     get location(): DockviewGroupLocation;
     get title(): string | undefined;
+    get isPinned(): boolean;
     get isGroupActive(): boolean;
     get renderer(): DockviewPanelRenderer;
     set group(value: DockviewGroupPanel);
@@ -75,6 +95,7 @@ export declare class DockviewPanelApiImpl extends GridviewPanelApiImpl implement
     setActive(): void;
     moveTo(options: DockviewPanelMoveParams): void;
     setTitle(title: string): void;
+    setPinned(pinned: boolean): void;
     setRenderer(renderer: DockviewPanelRenderer): void;
     close(): void;
     maximize(): void;

package/dist/cjs/dismissableLayer.d.ts

@@ -0,0 +1,57 @@
+import { IDisposable } from './lifecycle';
+export interface DismissableLayerOptions {
+    /** Window to listen on. Pass the popout window for popout-hosted layers.
+     *  Defaults to the global `window`. */
+    readonly window?: Window;
+    /** Invoked when any enabled dismiss signal fires. */
+    readonly onDismiss: () => void;
+    /** A pointerdown landed *inside* the layer (not a dismissal). Use it to
+     *  mark interaction (e.g. make a transient layer sticky). */
+    readonly onInsidePointerDown?: (event: PointerEvent) => void;
+    /** Whether a pointer event is inside the layer. Defaults to a DOM
+     *  `contains` check against {@link DismissableLayerOptions.elements}.
+     *  Provide this for geometry-based hit testing (e.g. when the visible
+     *  content is a sibling overlay stacked on top of the layer). */
+    readonly isInside?: (event: PointerEvent) => boolean;
+    /** Elements treated as "inside" by the default contains check. */
+    readonly elements?: () => HTMLElement[];
+    /** Dismiss on `Escape` (default `true`). */
+    readonly escape?: boolean;
+    /** Extra keys that also dismiss (e.g. `'Enter'`). */
+    readonly keys?: readonly string[];
+    /** Dismiss on a pointerdown outside the layer (default `true`). */
+    readonly outsidePointerDown?: boolean;
+    /** Ignore outside-pointerdowns for this many ms after opening. Covers the
+     *  gesture that opened the layer (e.g. a touch long-press) dispatching a
+     *  follow-up pointerdown just outside it. */
+    readonly pointerDownGraceMs?: number;
+    /** Dismiss on window resize, skipping touch-driven resizes (default
+     *  `false`). */
+    readonly resize?: boolean;
+    /** Dismiss when focus moves to an element *outside* the layer (default
+     *  `false`): the "slide back on focus loss" behaviour. */
+    readonly focusOut?: boolean;
+    /** Whether a newly-focused element is inside the layer (for
+     *  {@link focusOut}). Defaults to a `contains` check against
+     *  {@link elements}. Provide this for geometry-based testing when the
+     *  content is a sibling overlay stacked on top of the layer. */
+    readonly isFocusInside?: (focused: Element) => boolean;
+    /** Listen in the capture phase (default `false`). Use capture when the
+     *  layer must see the event before content handlers stop its propagation. */
+    readonly capture?: boolean;
+    /** Clock source for the grace window. Defaults to `Date.now`. */
+    readonly now?: () => number;
+}
+/**
+ * The shared dismissal lifecycle behind transient surfaces (popovers, menus,
+ * peeks): while it lives it watches a configurable set of dismiss signals
+ * (Escape / extra keys, outside-pointerdown with an optional grace window,
+ * window resize, focus moving outside) and calls `onDismiss`. Inside/outside is
+ * decided by an `isInside` predicate (geometry) or a `contains` check against
+ * `elements`. Dispose to detach every listener.
+ *
+ * It owns only the *signals*, not the surface element, its position, or any
+ * hover/keep-open policy, so callers keep their own element lifecycle and
+ * layer this underneath.
+ */
+export declare function createDismissableLayer(options: DismissableLayerOptions): IDisposable;

package/dist/cjs/dnd/backend.d.ts

@@ -5,8 +5,8 @@ import { DroptargetOptions, IDropTarget } from './droptarget';
  * mechanism (HTML5 native events, pointer events) behind a uniform set of
  * `createX` methods.
  *
- * The backends are stateless — `html5Backend` and `pointerBackend` below
- * are exported as module-level singletons so they need no construction
+ * The backends are stateless. `html5Backend` and `pointerBackend` below
+ * are exported as module-level singletons, so they need no construction
  * or wiring through the component tree.
  */
 export interface IDragBackend {

package/dist/cjs/dnd/dropTargetAnchorContainer.d.ts

@@ -5,8 +5,20 @@ export declare class DropTargetAnchorContainer extends CompositeDisposable {
     private _model;
     private _outline;
     private _disabled;
+    /**
+     * Handle for a deferred {@link DropTargetTargetModel.scheduleClear}. The
+     * HTML5 backend does not clear this container on `dragleave` (that would
+     * churn the shared overlay and kill its slide transition on every crossing
+     * between adjacent targets). Instead it *schedules* a clear, which a
+     * subsequent `getElements` (the next target rendering into this container)
+     * cancels — so the overlay slides between targets, but is torn down when the
+     * drag genuinely leaves to somewhere that doesn't re-render here.
+     */
+    private _pendingClear;
     get disabled(): boolean;
     set disabled(value: boolean);
+    private _cancelPendingClear;
+    private _clearNow;
     get model(): DropTargetTargetModel | undefined;
     constructor(element: HTMLElement, options: {
         disabled: boolean;