dockview-core 6.6.0 → 7.0.2

package/dist/esm/dockview/popoutWindowService.d.ts

@@ -0,0 +1,95 @@
+import { IDisposable } from '../lifecycle';
+import { Event } from '../events';
+import { PopupService } from './components/popupService';
+import { PopoutWindow } from '../popoutWindow';
+import { DockviewGroupPanel } from './dockviewGroupPanel';
+import { SerializedPopoutGroup } from './dockviewComponent';
+import { Gridview } from '../gridview/gridview';
+import { OverlayRenderContainer } from '../overlay/overlayRenderContainer';
+import { DropTargetAnchorContainer } from '../dnd/dropTargetAnchorContainer';
+export interface PopoutGroupEntry {
+    window: PopoutWindow;
+    popoutGroup: DockviewGroupPanel;
+    referenceGroup?: string;
+    /**
+     * The popout window hosts its own gridview so it can hold a nested
+     * splitview layout of groups. `popoutGroup` is the window's anchor group.
+     */
+    gridview: Gridview;
+    /**
+     * Render / drop-target containers and window accessor for this popout, so
+     * groups relocated into the window can be wired to its own document.
+     */
+    overlayRenderContainer: OverlayRenderContainer;
+    dropTargetContainer: DropTargetAnchorContainer;
+    getWindow: () => Window;
+    popoutUrl?: string;
+    disposable: {
+        dispose: () => DockviewGroupPanel | undefined;
+    };
+}
+/**
+ * Narrow callback surface the PopoutWindowService needs from its host.
+ */
+export interface IPopoutWindowHost {
+    readonly isDisposed: boolean;
+}
+export interface IPopoutWindowService extends IDisposable {
+    readonly entries: readonly PopoutGroupEntry[];
+    readonly onDidRemove: Event<PopoutGroupEntry>;
+    add(entry: PopoutGroupEntry): void;
+    remove(entry: PopoutGroupEntry): void;
+    findByGroup(group: DockviewGroupPanel): PopoutGroupEntry | undefined;
+    findReferenceGroupId(group: DockviewGroupPanel): string | undefined;
+    observeGridviewSize(popoutWindow: PopoutWindow, gridview: Gridview, overlayRenderContainer: OverlayRenderContainer): IDisposable | undefined;
+    getPopupService(groupId: string): PopupService | undefined;
+    setPopupService(groupId: string, service: PopupService): void;
+    deletePopupService(groupId: string): void;
+    readonly restorationPromise: Promise<void>;
+    scheduleRestoration(delayMs: number, work: () => void, onCancel?: () => void): Promise<void>;
+    finishRestoration(promises: Promise<void>[]): void;
+    cancelPendingRestorations(): void;
+    serialize(): SerializedPopoutGroup[];
+    disposeAll(): void;
+}
+export declare class PopoutWindowService implements IPopoutWindowService {
+    private readonly _host;
+    private readonly _entries;
+    private readonly _popupServices;
+    private readonly _restorationCleanups;
+    private _restorationPromise;
+    private readonly _onDidRemove;
+    readonly onDidRemove: Event<PopoutGroupEntry>;
+    constructor(host: IPopoutWindowHost);
+    get entries(): readonly PopoutGroupEntry[];
+    get restorationPromise(): Promise<void>;
+    add(entry: PopoutGroupEntry): void;
+    remove(entry: PopoutGroupEntry): void;
+    findByGroup(group: DockviewGroupPanel): PopoutGroupEntry | undefined;
+    findReferenceGroupId(group: DockviewGroupPanel): string | undefined;
+    /**
+     * The popout window's innerWidth/innerHeight are often 0/stale until it has
+     * painted, and the nested gridview lays its children out to the size passed
+     * to layout() (a plain group fills via CSS instead). To stop content
+     * rendering into a zero box until a manual resize — and to avoid the race a
+     * fixed number of animation frames had — observe the gridview element with
+     * a ResizeObserver created in the POPOUT window's OWN realm. A parent-realm
+     * observer fires unreliably across the window boundary; a same-realm one
+     * fires reliably, including the initial observation once the window is
+     * sized.
+     *
+     * @returns a disposable that disconnects the observer, or `undefined` when
+     * the popout realm has no ResizeObserver (e.g. jsdom).
+     */
+    observeGridviewSize(popoutWindow: PopoutWindow, gridview: Gridview, overlayRenderContainer: OverlayRenderContainer): IDisposable | undefined;
+    getPopupService(groupId: string): PopupService | undefined;
+    setPopupService(groupId: string, service: PopupService): void;
+    deletePopupService(groupId: string): void;
+    scheduleRestoration(delayMs: number, work: () => void, onCancel?: () => void): Promise<void>;
+    finishRestoration(promises: Promise<void>[]): void;
+    cancelPendingRestorations(): void;
+    serialize(): SerializedPopoutGroup[];
+    disposeAll(): void;
+    dispose(): void;
+}
+export declare const PopoutWindowModule: import("./modules").DockviewModule<IPopoutWindowHost>;

package/dist/esm/dockview/popoutWindowService.js

@@ -0,0 +1,175 @@
+import { Emitter } from '../events';
+import { remove } from '../array';
+import { defineModule } from './modules';
+export class PopoutWindowService {
+    constructor(host) {
+        this._entries = [];
+        this._popupServices = new Map();
+        this._restorationCleanups = new Set();
+        this._restorationPromise = Promise.resolve();
+        this._onDidRemove = new Emitter();
+        this.onDidRemove = this._onDidRemove.event;
+        this._host = host;
+    }
+    get entries() {
+        return this._entries;
+    }
+    get restorationPromise() {
+        return this._restorationPromise;
+    }
+    add(entry) {
+        this._entries.push(entry);
+    }
+    remove(entry) {
+        // Fire only on a genuine removal, and not while the host component is
+        // tearing down (consumers don't want popout-removed events during
+        // dispose).
+        if (remove(this._entries, entry) && !this._host.isDisposed) {
+            this._onDidRemove.fire(entry);
+        }
+    }
+    findByGroup(group) {
+        // A popout window may host several groups in a nested gridview, so
+        // match by membership (DOM containment) rather than only the anchor.
+        return this._entries.find((entry) => entry.popoutGroup === group ||
+            entry.gridview.element.contains(group.element));
+    }
+    findReferenceGroupId(group) {
+        var _a;
+        return (_a = this._entries.find((entry) => entry.popoutGroup === group)) === null || _a === void 0 ? void 0 : _a.referenceGroup;
+    }
+    /**
+     * The popout window's innerWidth/innerHeight are often 0/stale until it has
+     * painted, and the nested gridview lays its children out to the size passed
+     * to layout() (a plain group fills via CSS instead). To stop content
+     * rendering into a zero box until a manual resize — and to avoid the race a
+     * fixed number of animation frames had — observe the gridview element with
+     * a ResizeObserver created in the POPOUT window's OWN realm. A parent-realm
+     * observer fires unreliably across the window boundary; a same-realm one
+     * fires reliably, including the initial observation once the window is
+     * sized.
+     *
+     * @returns a disposable that disconnects the observer, or `undefined` when
+     * the popout realm has no ResizeObserver (e.g. jsdom).
+     */
+    observeGridviewSize(popoutWindow, gridview, overlayRenderContainer) {
+        var _a;
+        const PopoutResizeObserver = (_a = popoutWindow.window) === null || _a === void 0 ? void 0 : _a.ResizeObserver;
+        if (!PopoutResizeObserver) {
+            return undefined;
+        }
+        let lastWidth = -1;
+        let lastHeight = -1;
+        const relayout = () => {
+            const win = popoutWindow.window;
+            if (this._host.isDisposed || !win || win.closed) {
+                return;
+            }
+            const width = Math.round(gridview.element.clientWidth);
+            const height = Math.round(gridview.element.clientHeight);
+            if (width === lastWidth && height === lastHeight) {
+                return;
+            }
+            lastWidth = width;
+            lastHeight = height;
+            if (width > 0 && height > 0) {
+                gridview.layout(width, height);
+            }
+            overlayRenderContainer.updateAllPositions();
+        };
+        const observer = new PopoutResizeObserver(() => {
+            var _a;
+            // Defer out of the observer callback into the popout's own frame to
+            // size against the settled layout and to avoid resize-loop warnings.
+            const raf = (_a = popoutWindow.window) === null || _a === void 0 ? void 0 : _a.requestAnimationFrame;
+            if (raf) {
+                raf.call(popoutWindow.window, relayout);
+            }
+            else {
+                relayout();
+            }
+        });
+        observer.observe(gridview.element);
+        return { dispose: () => observer.disconnect() };
+    }
+    getPopupService(groupId) {
+        return this._popupServices.get(groupId);
+    }
+    setPopupService(groupId, service) {
+        this._popupServices.set(groupId, service);
+    }
+    deletePopupService(groupId) {
+        this._popupServices.delete(groupId);
+    }
+    scheduleRestoration(delayMs, work, onCancel) {
+        return new Promise((resolve) => {
+            const cleanup = () => {
+                this._restorationCleanups.delete(cleanup);
+                clearTimeout(handle);
+                onCancel === null || onCancel === void 0 ? void 0 : onCancel();
+                resolve();
+            };
+            const handle = setTimeout(() => {
+                this._restorationCleanups.delete(cleanup);
+                // Guard against the component being disposed before this
+                // timer fires. Under React StrictMode the component is
+                // mounted -> disposed -> remounted, and without this guard
+                // the first instance's queued restoration would open a
+                // second popout window. See issue #851.
+                if (this._host.isDisposed) {
+                    resolve();
+                    return;
+                }
+                work();
+                resolve();
+            }, delayMs);
+            this._restorationCleanups.add(cleanup);
+        });
+    }
+    finishRestoration(promises) {
+        this._restorationPromise = Promise.all(promises).then(() => void 0);
+    }
+    cancelPendingRestorations() {
+        for (const cleanup of [...this._restorationCleanups]) {
+            cleanup();
+        }
+        this._restorationCleanups.clear();
+    }
+    serialize() {
+        return this._entries.map((entry) => {
+            const grid = entry.gridview.serialize();
+            const root = grid.root;
+            const url = entry.popoutGroup.api.location.type === 'popout'
+                ? entry.popoutGroup.api.location.popoutUrl
+                : undefined;
+            const base = {
+                gridReferenceGroup: entry.referenceGroup,
+                position: entry.window.dimensions(),
+                url,
+            };
+            // Single-group window keeps the legacy `data` shape so layouts
+            // round-trip byte-stably and older readers keep working.
+            if (root.type === 'branch' &&
+                root.data.length === 1 &&
+                root.data[0].type === 'leaf') {
+                return Object.assign(Object.assign({}, base), { data: root.data[0].data });
+            }
+            return Object.assign(Object.assign({}, base), { grid });
+        });
+    }
+    disposeAll() {
+        for (const entry of [...this._entries]) {
+            entry.disposable.dispose();
+        }
+    }
+    dispose() {
+        this.cancelPendingRestorations();
+        this.disposeAll();
+        this._onDidRemove.dispose();
+    }
+}
+export const PopoutWindowModule = defineModule({
+    name: 'PopoutWindow',
+    serviceKey: 'popoutWindowService',
+    create: (host) => new PopoutWindowService(host),
+});

package/dist/esm/dockview/rootDropTargetService.d.ts

@@ -0,0 +1,35 @@
+import { IDisposable } from '../lifecycle';
+import { Event } from '../events';
+import { DroptargetEvent, DropTargetTargetModel, Position, WillShowOverlayEvent } from '../dnd/droptarget';
+import { DockviewComponentOptions } from './options';
+export interface IRootDropTargetHost {
+    readonly id: string;
+    readonly element: HTMLElement;
+    readonly options: DockviewComponentOptions;
+    isGridEmpty(): boolean;
+    rootDropTargetOverrideTarget(): DropTargetTargetModel | undefined;
+    /**
+     * Build, fire, and return the verdict for an unhandled-drag-over event.
+     * Implemented on the component side so the service stays free of
+     * circular imports with the event class declared in dockviewComponent.
+     */
+    dispatchUnhandledDragOver(nativeEvent: DragEvent | PointerEvent, position: Position): boolean;
+}
+export interface IRootDropTargetService extends IDisposable {
+    /** Merged stream from both DnD backends. */
+    readonly onWillShowOverlay: Event<WillShowOverlayEvent>;
+    /** Merged stream from both DnD backends. */
+    readonly onDrop: Event<DroptargetEvent>;
+    /** Apply changed options (dndEdges). */
+    setOptions(options: Partial<DockviewComponentOptions>): void;
+}
+export declare class RootDropTargetService implements IRootDropTargetService {
+    private readonly _html5Target;
+    private readonly _pointerTarget;
+    readonly onWillShowOverlay: Event<WillShowOverlayEvent>;
+    readonly onDrop: Event<DroptargetEvent>;
+    constructor(host: IRootDropTargetHost);
+    setOptions(options: Partial<DockviewComponentOptions>): void;
+    dispose(): void;
+}
+export declare const RootDropTargetModule: import("./modules").DockviewModule<IRootDropTargetHost>;

package/dist/esm/dockview/rootDropTargetService.js

@@ -0,0 +1,82 @@
+import { Event } from '../events';
+import { html5Backend, pointerBackend } from '../dnd/backend';
+import { getPanelData } from '../dnd/dataTransfer';
+import { defineModule } from './modules';
+const DEFAULT_ROOT_OVERLAY_MODEL = {
+    activationSize: { type: 'pixels', value: 10 },
+    size: { type: 'pixels', value: 20 },
+};
+export class RootDropTargetService {
+    constructor(host) {
+        const canDisplayOverlay = (event, position) => {
+            const data = getPanelData();
+            if (data) {
+                if (data.viewId !== host.id) {
+                    return false;
+                }
+                if (position === 'center') {
+                    // center drop target only allowed if no panels in primary
+                    // grid; floating panels are allowed
+                    return host.isGridEmpty();
+                }
+                return true;
+            }
+            if (position === 'center' && !host.isGridEmpty()) {
+                // for external events only show the four-corner drag overlays,
+                // disable center so external drag events can fall through to
+                // the group and panel drop target handlers
+                return false;
+            }
+            return host.dispatchUnhandledDragOver(event, position);
+        };
+        const overlayModel = typeof host.options.dndEdges === 'object' &&
+            host.options.dndEdges !== null
+            ? host.options.dndEdges
+            : DEFAULT_ROOT_OVERLAY_MODEL;
+        this._html5Target = html5Backend.createDropTarget(host.element, {
+            className: 'dv-drop-target-edge',
+            canDisplayOverlay,
+            acceptedTargetZones: ['top', 'bottom', 'left', 'right', 'center'],
+            overlayModel,
+            getOverrideTarget: () => host.rootDropTargetOverrideTarget(),
+        });
+        this._pointerTarget = pointerBackend.createDropTarget(host.element, {
+            className: 'dv-drop-target-edge',
+            canDisplayOverlay,
+            acceptedTargetZones: ['top', 'bottom', 'left', 'right', 'center'],
+            overlayModel,
+            getOverrideTarget: () => host.rootDropTargetOverrideTarget(),
+        });
+        this.onWillShowOverlay = Event.any(this._html5Target.onWillShowOverlay, this._pointerTarget.onWillShowOverlay);
+        this.onDrop = Event.any(this._html5Target.onDrop, this._pointerTarget.onDrop);
+        // Apply initial-state options now that the targets exist; setOptions
+        // handles dndEdges (disable + overlay model) and late changes.
+        this.setOptions(host.options);
+    }
+    setOptions(options) {
+        if ('dndEdges' in options) {
+            const disabled = typeof options.dndEdges === 'boolean' &&
+                options.dndEdges === false;
+            this._html5Target.disabled = disabled;
+            this._pointerTarget.disabled = disabled;
+            if (typeof options.dndEdges === 'object' &&
+                options.dndEdges !== null) {
+                this._html5Target.setOverlayModel(options.dndEdges);
+                this._pointerTarget.setOverlayModel(options.dndEdges);
+            }
+            else {
+                this._html5Target.setOverlayModel(DEFAULT_ROOT_OVERLAY_MODEL);
+                this._pointerTarget.setOverlayModel(DEFAULT_ROOT_OVERLAY_MODEL);
+            }
+        }
+    }
+    dispose() {
+        this._html5Target.dispose();
+        this._pointerTarget.dispose();
+    }
+}
+export const RootDropTargetModule = defineModule({
+    name: 'RootDropTarget',
+    serviceKey: 'rootDropTargetService',
+    create: (host) => new RootDropTargetService(host),
+});

package/dist/esm/dockview/watermarkService.d.ts

@@ -0,0 +1,30 @@
+import { IDisposable } from '../lifecycle';
+import { Event } from '../events';
+import { IWatermarkRenderer } from './types';
+import { DockviewApi } from '../api/component.api';
+import { DockviewGroupPanel } from './dockviewGroupPanel';
+export interface IWatermarkHost {
+    readonly api: DockviewApi;
+    readonly mountElement: HTMLElement;
+    createWatermarkComponent(): IWatermarkRenderer;
+    hasVisibleGridGroup(): boolean;
+    readonly onDidAdd: Event<DockviewGroupPanel>;
+    readonly onDidRemove: Event<DockviewGroupPanel>;
+    readonly onDidViewVisibilityChangeMicroTaskQueue: Event<unknown>;
+}
+export interface IWatermarkService extends IDisposable {
+    /** Mount or unmount the watermark based on current grid state. */
+    update(): void;
+    /** Tear down the current watermark and re-evaluate. Used when the watermark factory option changes. */
+    refresh(): void;
+}
+export declare class WatermarkService implements IWatermarkService {
+    private readonly _host;
+    private _watermark;
+    constructor(host: IWatermarkHost);
+    update(): void;
+    refresh(): void;
+    private _unmount;
+    dispose(): void;
+}
+export declare const WatermarkModule: import("./modules").DockviewModule<IWatermarkHost>;

package/dist/esm/dockview/watermarkService.js

@@ -0,0 +1,56 @@
+import { CompositeDisposable } from '../lifecycle';
+import { addTestId } from '../dom';
+import { Event } from '../events';
+import { defineModule } from './modules';
+export class WatermarkService {
+    constructor(host) {
+        this._watermark = null;
+        this._host = host;
+    }
+    update() {
+        if (this._host.hasVisibleGridGroup()) {
+            this._unmount();
+            return;
+        }
+        if (this._watermark) {
+            return;
+        }
+        this._watermark = this._host.createWatermarkComponent();
+        this._watermark.init({ containerApi: this._host.api });
+        const container = document.createElement('div');
+        container.className = 'dv-watermark-container';
+        addTestId(container, 'watermark-component');
+        container.appendChild(this._watermark.element);
+        this._host.mountElement.appendChild(container);
+    }
+    refresh() {
+        this._unmount();
+        this.update();
+    }
+    _unmount() {
+        var _a, _b;
+        if (!this._watermark) {
+            return;
+        }
+        this._watermark.element.parentElement.remove();
+        (_b = (_a = this._watermark).dispose) === null || _b === void 0 ? void 0 : _b.call(_a);
+        this._watermark = null;
+    }
+    dispose() {
+        this._unmount();
+    }
+}
+export const WatermarkModule = defineModule({
+    name: 'Watermark',
+    serviceKey: 'watermarkService',
+    create: (host) => new WatermarkService(host),
+    init: (host, service) => {
+        // Initial evaluation reflects the watermark state at construction time.
+        service.update();
+        return new CompositeDisposable(Event.any(host.onDidAdd, host.onDidRemove)(() => {
+            service.update();
+        }), host.onDidViewVisibilityChangeMicroTaskQueue(() => {
+            service.update();
+        }));
+    },
+});

package/dist/esm/gridview/baseComponentGridview.d.ts

@@ -95,7 +95,7 @@ export declare abstract class BaseGrid<T extends IGridPanelView> extends Resizab
     isMaximizedGroup(panel: T): boolean;
     exitMaximizedGroup(): void;
     hasMaximizedGroup(): boolean;
-    protected doAddGroup(group: T, location?: number[], size?: number): void;
+    protected doAddGroup(group: T, location?: number[], size?: number, gridview?: Gridview): void;
     protected doRemoveGroup(group: T, options?: {
         skipActive?: boolean;
         skipDispose?: boolean;

package/dist/esm/gridview/baseComponentGridview.js

@@ -145,8 +145,8 @@ export class BaseGrid extends Resizable {
     hasMaximizedGroup() {
         return this.gridview.hasMaximizedView();
     }
-    doAddGroup(group, location = [0], size) {
-        this.gridview.addView(group, size !== null && size !== void 0 ? size : Sizing.Distribute, location);
+    doAddGroup(group, location = [0], size, gridview = this.gridview) {
+        gridview.addView(group, size !== null && size !== void 0 ? size : Sizing.Distribute, location);
         this._onDidAdd.fire(group);
     }
     doRemoveGroup(group, options) {

package/dist/esm/gridview/gridviewComponent.d.ts

@@ -11,7 +11,7 @@ export interface SerializedGridviewComponent {
     grid: SerializedGridview<GridPanelViewState>;
     activePanel?: string;
 }
-export interface AddComponentOptions<T extends object = Parameters> extends BaseComponentOptions<T> {
+export interface AddGridviewComponentOptions<T extends object = Parameters> extends BaseComponentOptions<T> {
     minimumWidth?: number;
     maximumWidth?: number;
     minimumHeight?: number;
@@ -29,7 +29,7 @@ export interface IGridviewComponent extends IBaseGrid<GridviewPanel> {
     readonly orientation: Orientation;
     readonly onDidLayoutFromJSON: Event<void>;
     updateOptions(options: Partial<GridviewComponentOptions>): void;
-    addPanel<T extends object = Parameters>(options: AddComponentOptions<T>): IGridviewPanel;
+    addPanel<T extends object = Parameters>(options: AddGridviewComponentOptions<T>): IGridviewPanel;
     removePanel(panel: IGridviewPanel, sizing?: Sizing): void;
     focus(): void;
     fromJSON(serializedGridview: SerializedGridviewComponent): void;
@@ -80,7 +80,7 @@ export declare class GridviewComponent extends BaseGrid<GridviewPanel> implement
         reference: string;
         size?: number;
     }): void;
-    addPanel<T extends object = Parameters>(options: AddComponentOptions<T>): IGridviewPanel;
+    addPanel<T extends object = Parameters>(options: AddGridviewComponentOptions<T>): IGridviewPanel;
     private registerPanel;
     moveGroup(referenceGroup: IGridPanelComponentView, groupId: string, target: Position): void;
     removeGroup(group: GridviewPanel): void;

package/dist/esm/gridview/gridviewPanel.d.ts

@@ -6,7 +6,7 @@ import { LayoutPriority } from '../splitview/splitview';
 import { Event } from '../events';
 import { IViewSize } from './gridview';
 import { BaseGrid, IGridPanelView } from './baseComponentGridview';
-export interface Contraints {
+export interface Constraints {
     minimumWidth?: number;
     maximumWidth?: number;
     minimumHeight?: number;

package/dist/esm/index.d.ts

@@ -13,11 +13,11 @@ export * from './paneview/paneview';
 export * from './gridview/gridview';
 export { GridviewComponentOptions, GridviewOptions, GridviewFrameworkOptions, PROPERTY_KEYS_GRIDVIEW, } from './gridview/options';
 export * from './gridview/baseComponentGridview';
-export { DraggablePaneviewPanel, PaneviewDidDropEvent as PaneviewDropEvent, } from './paneview/draggablePaneviewPanel';
+export { DraggablePaneviewPanel, PaneviewDidDropEvent, } from './paneview/draggablePaneviewPanel';
 export * from './dockview/components/panel/content';
 export * from './dockview/components/tab/tab';
-export { DockviewGroupPanelModel, DockviewDidDropEvent, DockviewWillDropEvent, DockviewGroupChangeEvent, DockviewGroupLocation, } from './dockview/dockviewGroupPanelModel';
-export { DockviewWillShowOverlayLocationEvent, DockviewTabGroupChangeEvent, DockviewTabGroupCollapsedChangeEvent, DockviewTabGroupPanelChangeEvent, } from './dockview/events';
+export { DockviewGroupPanelModel, DockviewDidDropEvent, DockviewWillDropEvent, DockviewGroupChangeEvent, DockviewGroupActivePanelChangeEvent, DockviewGroupLocation, } from './dockview/dockviewGroupPanelModel';
+export { DockviewWillShowOverlayLocationEvent, DockviewTabGroupChangeEvent, DockviewTabGroupCollapsedChangeEvent, DockviewTabGroupPanelChangeEvent, DockviewGroupDropLocation, } from './dockview/events';
 export { TabDragEvent, GroupDragEvent, } from './dockview/components/titlebar/tabsContainer';
 export * from './dockview/types';
 export * from './dockview/dockviewGroupPanel';
@@ -39,6 +39,7 @@ export * from './gridview/gridviewPanel';
 export { SplitviewPanel, ISplitviewPanel } from './splitview/splitviewPanel';
 export * from './paneview/paneviewPanel';
 export * from './dockview/types';
+export { Box, AnchorPosition, AnchoredBox } from './types';
 export { DockviewPanelRenderer } from './overlay/overlayRenderContainer';
 export { Position, positionToDirection, directionToPosition, MeasuredValue, DroptargetOverlayModel, } from './dnd/droptarget';
 export { FocusEvent, PanelDimensionChangeEvent, VisibilityEvent, ActiveEvent, PanelApi, } from './api/panelApi';
@@ -46,6 +47,12 @@ export { SizeEvent, GridviewPanelApi, GridConstraintChangeEvent, } from './api/g
 export { TitleEvent, RendererChangedEvent, DockviewPanelApi, DockviewPanelMoveParams, } from './api/dockviewPanelApi';
 export { PanelSizeEvent, PanelConstraintChangeEvent, SplitviewPanelApi, } from './api/splitviewPanelApi';
 export { ExpansionEvent, PaneviewPanelApi } from './api/paneviewPanelApi';
-export { DockviewGroupPanelApi, DockviewGroupPanelFloatingChangeEvent, DockviewGroupPanelCollapsedChangeEvent, DockviewGroupMoveParams, } from './api/dockviewGroupPanelApi';
+export { DockviewGroupPanelApi, DockviewGroupPanelLocationChangeEvent, DockviewGroupPanelCollapsedChangeEvent, DockviewGroupMoveParams, } from './api/dockviewGroupPanelApi';
 export { CommonApi, SplitviewApi, PaneviewApi, GridviewApi, DockviewApi, DockviewGetTabGroupsOptions, } from './api/component.api';
 export { createDockview, createGridview, createPaneview, createSplitview, } from './api/entryPoints';
+export { registerModules, getRegisteredModules, clearRegisteredModules, markDockviewPackageLoaded, isDockviewPackageLoaded, defineModule, DockviewModule, ServiceCollection, } from './dockview/modules';
+export { IAccessibilityHost, IAccessibilityService, IAdvancedDnDHost, IAdvancedDnDService, IContextMenuHost, IContextMenuService, IKeyboardDockingService, ITabGroupChipsHost, ITabGroupChipsService, } from './dockview/moduleContracts';
+export { resolveMessages } from './dockview/accessibilityMessages';
+export { findRelativeZIndexParent } from './dom';
+export { IDragGhostSpec } from './dnd/backend';
+export { LiveRegionModule } from './dockview/liveRegionService';

package/dist/esm/index.js

@@ -38,3 +38,7 @@ export * from './dockview/types';
 export { positionToDirection, directionToPosition, } from './dnd/droptarget';
 export { SplitviewApi, PaneviewApi, GridviewApi, DockviewApi, } from './api/component.api';
 export { createDockview, createGridview, createPaneview, createSplitview, } from './api/entryPoints';
+export { registerModules, getRegisteredModules, clearRegisteredModules, markDockviewPackageLoaded, isDockviewPackageLoaded, defineModule, } from './dockview/modules';
+export { resolveMessages } from './dockview/accessibilityMessages';
+export { findRelativeZIndexParent } from './dom';
+export { LiveRegionModule } from './dockview/liveRegionService';

package/dist/esm/overlay/overlay.d.ts

@@ -1,6 +1,21 @@
 import { Event } from '../events';
 import { CompositeDisposable } from '../lifecycle';
-import { AnchoredBox } from '../types';
+import { AnchoredBox, Box } from '../types';
+/**
+ * Context handed to {@link OverlayOptions.transformDragPosition} each
+ * pointer-move frame while a floating overlay is being dragged.
+ */
+export interface OverlayDragContext {
+    /** Proposed top-left + size this frame, in container pixels (pre-clamp). */
+    readonly proposed: Box;
+    /** Size of the container the overlay is dragged within. */
+    readonly container: {
+        width: number;
+        height: number;
+    };
+    /** Bounds of the sibling overlays, snapshotted at drag start. */
+    readonly others: readonly Box[];
+}
 export declare class Overlay extends CompositeDisposable {
     private readonly options;
     private readonly _element;
@@ -22,11 +37,38 @@ export declare class Overlay extends CompositeDisposable {
     set minimumInViewportHeight(value: number | undefined);
     get element(): HTMLElement;
     get isVisible(): boolean;
+    /**
+     * Height of the optional drag-handle header, or 0 when none is present.
+     * Used to translate between the overlay's outer box and the content area
+     * available to the group beneath the header.
+     */
+    get headerHeight(): number;
     constructor(options: AnchoredBox & {
         container: HTMLElement;
         content: HTMLElement;
+        /**
+         * Optional dedicated drag handle rendered above the content (a
+         * floating window title bar). When provided the resize container
+         * lays its children out as a flex column so the content shrinks
+         * to fit beneath the handle.
+         */
+        header?: HTMLElement;
         minimumInViewportWidth?: number;
         minimumInViewportHeight?: number;
+        /**
+         * Adjust the proposed top-left each drag frame (before the
+         * container clamp). Return an adjusted position or nothing to leave
+         * it unchanged. Used to implement snapping / custom bounds.
+         */
+        transformDragPosition?: (context: OverlayDragContext) => {
+            top: number;
+            left: number;
+        } | void;
+        /**
+         * Snapshot the sibling overlays' boxes at drag start, supplied to
+         * `transformDragPosition` as `context.others`.
+         */
+        getSiblingBoxes?: () => readonly Box[];
     });
     setVisible(isVisible: boolean): void;
     bringToFront(): void;