dockview-core 6.6.0 → 7.0.2

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

@@ -0,0 +1,119 @@
+/**
+ * Service + host interfaces for the pluggable feature modules. Core references
+ * only these interfaces — never a module's implementation — so each module is
+ * decoupled from core and independently testable / removable. Keep this file
+ * implementation-free.
+ */
+import { IDisposable } from '../lifecycle';
+import { Event } from '../events';
+import { DroptargetOverlayModel, Position } from '../dnd/droptarget';
+import { IDragGhostSpec } from '../dnd/backend';
+import { DockviewApi } from '../api/component.api';
+import { DockviewGroupPanel } from './dockviewGroupPanel';
+import { IDockviewPanel } from './dockviewPanel';
+import { ITabGroup } from './tabGroup';
+import { TabGroupColorPalette } from './tabGroupAccent';
+import { PopupService } from './components/popupService';
+import { DockviewComponentOptions } from './options';
+import { DockviewLayoutMutationEvent, GroupNavigationDirection } from './dockviewComponent';
+import { DockviewWillDropEvent } from './dockviewGroupPanelModel';
+import { GroupDragEvent, TabDragEvent } from './components/titlebar/tabsContainer';
+import { DockviewGroupDropLocation, DockviewTabGroupChangeEvent, DockviewTabGroupPanelChangeEvent, DockviewTabGroupCollapsedChangeEvent, DockviewWillShowOverlayLocationEvent } from './events';
+export interface IContextMenuHost {
+    readonly options: DockviewComponentOptions;
+    readonly api: DockviewApi;
+    readonly tabGroupColorPalette: TabGroupColorPalette;
+    getPopupServiceForGroup(group: DockviewGroupPanel): PopupService;
+}
+export interface IContextMenuService {
+    show(panel: IDockviewPanel, group: DockviewGroupPanel, event: MouseEvent): void;
+    showForChip(tabGroup: ITabGroup, group: DockviewGroupPanel, event: MouseEvent): void;
+}
+export interface ITabGroupChipsHost {
+    readonly onDidAddGroup: Event<DockviewGroupPanel>;
+    readonly onDidRemoveGroup: Event<DockviewGroupPanel>;
+    fireDidCreateTabGroup(event: DockviewTabGroupChangeEvent): void;
+    fireDidDestroyTabGroup(event: DockviewTabGroupChangeEvent): void;
+    fireDidAddPanelToTabGroup(event: DockviewTabGroupPanelChangeEvent): void;
+    fireDidRemovePanelFromTabGroup(event: DockviewTabGroupPanelChangeEvent): void;
+    fireDidTabGroupChange(event: DockviewTabGroupChangeEvent): void;
+    fireDidTabGroupCollapsedChange(event: DockviewTabGroupCollapsedChangeEvent): void;
+}
+export interface ITabGroupChipsService extends IDisposable {
+    /**
+     * Subscribe to the per-group tab-group events on the given group and
+     * re-fire them on the host's component-level emitters. Returns a
+     * disposable that detaches the subscriptions; intended to be bundled
+     * into the per-group CompositeDisposable so cleanup happens when the
+     * group is removed.
+     */
+    attachToGroup(group: DockviewGroupPanel): IDisposable;
+}
+export interface IAccessibilityHost {
+    /**
+     * The outermost dockview element (the shell, which also contains edge
+     * groups). A getter — it must resolve to the shell once that exists, not
+     * the inner gridview, or keydowns from edge groups are missed.
+     */
+    readonly rootElement: HTMLElement;
+    readonly options: DockviewComponentOptions;
+    readonly groups: DockviewGroupPanel[];
+    readonly activeGroup: DockviewGroupPanel | undefined;
+    readonly activePanel: IDockviewPanel | undefined;
+    /**
+     * The next / previous group in gridview (spatial) order, wrapping round —
+     * the one piece of navigation that needs the grid internals. All other
+     * focus logic lives in the service, using the public group API.
+     */
+    adjacentGroup(group: DockviewGroupPanel, reverse: boolean): DockviewGroupPanel | undefined;
+    /** The nearest grid group in a spatial direction — drives Alt+Arrow nav. */
+    adjacentGroupInDirection(group: DockviewGroupPanel, direction: GroupNavigationDirection): DockviewGroupPanel | undefined;
+    /** Fires before / after a structural layout change — used to restore focus on close. */
+    readonly onWillMutateLayout: Event<DockviewLayoutMutationEvent>;
+    readonly onDidMutateLayout: Event<DockviewLayoutMutationEvent>;
+    showDropPreview(group: DockviewGroupPanel, position: Position): IDisposable;
+    announce(message: string): void;
+    dockPanel(panel: IDockviewPanel, group: DockviewGroupPanel, position: Position): void;
+}
+export interface IAccessibilityService extends IDisposable {
+}
+/**
+ * Marker for the advanced keyboard docking service (spatial group focus +
+ * keyboard move mode). Self-driven; the component never calls into it.
+ */
+export interface IKeyboardDockingService extends IDisposable {
+}
+export interface IAdvancedDnDHost {
+    readonly options: DockviewComponentOptions;
+    readonly api: DockviewApi;
+    fireWillDragPanel(event: TabDragEvent): void;
+    fireWillDragGroup(event: GroupDragEvent): void;
+    fireWillDrop(event: DockviewWillDropEvent): void;
+    fireWillShowOverlay(event: DockviewWillShowOverlayLocationEvent): void;
+}
+export interface IAdvancedDnDService extends IDisposable {
+    dispatchWillDragPanel(event: TabDragEvent): void;
+    dispatchWillDragGroup(event: GroupDragEvent): void;
+    dispatchWillDrop(event: DockviewWillDropEvent): void;
+    dispatchWillShowOverlay(event: DockviewWillShowOverlayLocationEvent): void;
+    /**
+     * Resolve the custom group drag ghost from
+     * `createGroupDragGhostComponent`, or `undefined` when no factory is
+     * configured (the caller then renders the default chip). Returning
+     * `undefined` is also what happens when this module is absent.
+     */
+    buildGroupDragGhost(group: DockviewGroupPanel): IDragGhostSpec | undefined;
+    /**
+     * Resolve the app-supplied overlay model for a group drop target via the
+     * `dropOverlayModel` option, or `undefined` to keep the target's default.
+     */
+    resolveOverlayModel(location: DockviewGroupDropLocation, group?: DockviewGroupPanel): DroptargetOverlayModel | undefined;
+    /**
+     * Render the drop-preview overlay on a group at `position` — the same
+     * overlay a mouse drag shows — without a live drag. Returns a disposable
+     * that clears it. Used by keyboard docking so keyboard and mouse previews
+     * are identical (single source of truth). Commit the move via the public
+     * `api.moveGroupOrPanel({ to: { group, position } })`.
+     */
+    showPreviewOverlay(group: DockviewGroupPanel, position: Position): IDisposable;
+}

package/dist/esm/dockview/moduleContracts.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,110 @@
+/**
+ * Internal module system for dockview.
+ *
+ * Modules are feature bundles that register services into the dockview
+ * component. `registerModules(...)` is the one public entry point — it lets a
+ * sibling package contribute modules that `DockviewComponent` picks up at
+ * construction. The richer opt-in surface (a per-component `modules` option,
+ * framework wrappers) is still reserved for a future version; the module
+ * authoring API (`defineModule`, the service contracts) remains internal.
+ */
+import { IDisposable } from '../lifecycle';
+import { IFloatingGroupService } from './floatingGroupService';
+import { IPopoutWindowService } from './popoutWindowService';
+import { IWatermarkService } from './watermarkService';
+import { IEdgeGroupService } from './edgeGroupService';
+import { IRootDropTargetService } from './rootDropTargetService';
+import { IHeaderActionsService } from './headerActionsService';
+import { ILiveRegionService } from './liveRegionService';
+import { IAccessibilityService, IAdvancedDnDService, IContextMenuService, IKeyboardDockingService, ITabGroupChipsService } from './moduleContracts';
+export interface ServiceCollection {
+    floatingGroupService?: IFloatingGroupService;
+    popoutWindowService?: IPopoutWindowService;
+    watermarkService?: IWatermarkService;
+    edgeGroupService?: IEdgeGroupService;
+    tabGroupChipsService?: ITabGroupChipsService;
+    contextMenuService?: IContextMenuService;
+    rootDropTargetService?: IRootDropTargetService;
+    headerActionsService?: IHeaderActionsService;
+    advancedDnDService?: IAdvancedDnDService;
+    liveRegionService?: ILiveRegionService;
+    accessibilityService?: IAccessibilityService;
+    keyboardDockingService?: IKeyboardDockingService;
+}
+export interface DockviewModule<THost = unknown> {
+    moduleName: string;
+    services?: Record<string, (host: THost) => unknown>;
+    /**
+     * Optional post-construct hook called once after the host is fully
+     * constructed and all module services are instantiated. Use this to
+     * subscribe to host events — the returned disposable runs at host
+     * teardown. Components don't need to call into the service from event
+     * handlers; the module owns its own reactivity.
+     */
+    init?: (host: THost, services: ServiceCollection) => IDisposable;
+    dependsOn?: DockviewModule<any>[];
+}
+/**
+ * Typed helper for defining a module. Enforces that the factory's return
+ * type matches the slot in ServiceCollection at compile time, replacing
+ * the manual cast each module file would otherwise need.
+ */
+export declare function defineModule<K extends keyof ServiceCollection, THost>(config: {
+    name: string;
+    serviceKey: K;
+    create: (host: THost) => NonNullable<ServiceCollection[K]>;
+    init?: (host: THost, service: NonNullable<ServiceCollection[K]>) => IDisposable;
+    dependsOn?: DockviewModule<any>[];
+}): DockviewModule<THost>;
+/**
+ * For tests — clears the once-per-key dedup cache used by `assertModule`.
+ */
+export declare function _resetMissingModuleWarnings(): void;
+/**
+ * Returns the service if its module is registered, otherwise logs a
+ * deduplicated console error and returns `undefined`. Modelled on AG Grid's
+ * `assertModuleRegistered`: missing modules never throw — they degrade the
+ * affected feature to a no-op so consuming applications don't crash in
+ * production.
+ *
+ * Use at public-API entry points where the caller wants to surface which
+ * module is missing. For internal/lifecycle paths, plain `?.` chaining on
+ * the service slot is preferred — no log, just a silent no-op.
+ */
+export declare function assertModule<T>(service: T | undefined, moduleName: string, context?: string): T | undefined;
+export declare class ModuleRegistry<THost> implements IDisposable {
+    private readonly _modules;
+    private readonly _services;
+    private readonly _initDisposables;
+    get services(): ServiceCollection;
+    register<H>(module: DockviewModule<H>): void;
+    initialize(host: THost): void;
+    postConstruct(host: THost): void;
+    has(moduleName: string): boolean;
+    dispose(): void;
+}
+/**
+ * Register modules globally. Idempotent per `moduleName` — registering the
+ * same module twice is a no-op. Intended to be called once at import time by
+ * the package that bundles a given set of modules.
+ */
+export declare function registerModules(modules: DockviewModule<any>[]): void;
+/**
+ * Returns the globally-registered modules (a copy). `DockviewComponent` reads
+ * this to extend its built-in module set.
+ */
+export declare function getRegisteredModules(): DockviewModule<any>[];
+/**
+ * For tests — clears the global module registry.
+ */
+export declare function clearRegisteredModules(): void;
+/**
+ * Called once by the `dockview` package on import, solely so `dockview-core`
+ * can warn when it is used directly (see above). Not used for anything else.
+ */
+export declare function markDockviewPackageLoaded(): void;
+/**
+ * Whether the `dockview` package has been loaded in this process. Used only to
+ * gate the "don't use dockview-core directly" developer warning.
+ */
+export declare function isDockviewPackageLoaded(): boolean;

package/dist/esm/dockview/modules.js

@@ -0,0 +1,170 @@
+/**
+ * Internal module system for dockview.
+ *
+ * Modules are feature bundles that register services into the dockview
+ * component. `registerModules(...)` is the one public entry point — it lets a
+ * sibling package contribute modules that `DockviewComponent` picks up at
+ * construction. The richer opt-in surface (a per-component `modules` option,
+ * framework wrappers) is still reserved for a future version; the module
+ * authoring API (`defineModule`, the service contracts) remains internal.
+ */
+/**
+ * Typed helper for defining a module. Enforces that the factory's return
+ * type matches the slot in ServiceCollection at compile time, replacing
+ * the manual cast each module file would otherwise need.
+ */
+export function defineModule(config) {
+    return {
+        moduleName: config.name,
+        services: {
+            [config.serviceKey]: config.create,
+        },
+        init: config.init
+            ? (host, services) => config.init(host, services[config.serviceKey])
+            : undefined,
+        dependsOn: config.dependsOn,
+    };
+}
+const _warnedMissingModule = new Set();
+/**
+ * For tests — clears the once-per-key dedup cache used by `assertModule`.
+ */
+export function _resetMissingModuleWarnings() {
+    _warnedMissingModule.clear();
+}
+/**
+ * Returns the service if its module is registered, otherwise logs a
+ * deduplicated console error and returns `undefined`. Modelled on AG Grid's
+ * `assertModuleRegistered`: missing modules never throw — they degrade the
+ * affected feature to a no-op so consuming applications don't crash in
+ * production.
+ *
+ * Use at public-API entry points where the caller wants to surface which
+ * module is missing. For internal/lifecycle paths, plain `?.` chaining on
+ * the service slot is preferred — no log, just a silent no-op.
+ */
+export function assertModule(service, moduleName, context) {
+    if (service !== undefined) {
+        return service;
+    }
+    const key = `${moduleName}|${context !== null && context !== void 0 ? context : ''}`;
+    if (_warnedMissingModule.has(key)) {
+        return undefined;
+    }
+    _warnedMissingModule.add(key);
+    const where = context ? ` for ${context}` : '';
+    // eslint-disable-next-line no-console
+    console.error(`dockview: module "${moduleName}" is not registered${where}.`);
+    return undefined;
+}
+export class ModuleRegistry {
+    constructor() {
+        this._modules = new Map();
+        this._services = {};
+        this._initDisposables = [];
+    }
+    get services() {
+        return this._services;
+    }
+    register(module) {
+        if (this._modules.has(module.moduleName)) {
+            return;
+        }
+        if (module.dependsOn) {
+            for (const dep of module.dependsOn) {
+                this.register(dep);
+            }
+        }
+        this._modules.set(module.moduleName, module);
+    }
+    initialize(host) {
+        for (const module of this._modules.values()) {
+            if (!module.services) {
+                continue;
+            }
+            for (const [name, factory] of Object.entries(module.services)) {
+                this._services[name] = factory(host);
+            }
+        }
+    }
+    postConstruct(host) {
+        for (const module of this._modules.values()) {
+            if (module.init) {
+                this._initDisposables.push(module.init(host, this._services));
+            }
+        }
+    }
+    has(moduleName) {
+        return this._modules.has(moduleName);
+    }
+    dispose() {
+        // Tear down init() subscriptions first so they stop firing into
+        // services that are about to be disposed.
+        for (const disposable of this._initDisposables) {
+            disposable.dispose();
+        }
+        this._initDisposables.length = 0;
+        for (const service of Object.values(this._services)) {
+            if (service !== undefined &&
+                typeof service.dispose === 'function') {
+                service.dispose();
+            }
+        }
+    }
+}
+/**
+ * Process-global list of modules registered via {@link registerModules}.
+ * `DockviewComponent` appends these to its built-in set at construction, so
+ * importing a package that calls `registerModules(...)` (e.g. `dockview`)
+ * makes those modules available to every component in the process —
+ * modelled on AG Grid's `ModuleRegistry.registerModules`.
+ */
+const _globalModules = [];
+/**
+ * Register modules globally. Idempotent per `moduleName` — registering the
+ * same module twice is a no-op. Intended to be called once at import time by
+ * the package that bundles a given set of modules.
+ */
+export function registerModules(modules) {
+    for (const module of modules) {
+        if (_globalModules.some((m) => m.moduleName === module.moduleName)) {
+            continue;
+        }
+        _globalModules.push(module);
+    }
+}
+/**
+ * Returns the globally-registered modules (a copy). `DockviewComponent` reads
+ * this to extend its built-in module set.
+ */
+export function getRegisteredModules() {
+    return [..._globalModules];
+}
+/**
+ * For tests — clears the global module registry.
+ */
+export function clearRegisteredModules() {
+    _globalModules.length = 0;
+}
+/**
+ * This marker exists for ONE purpose: a developer warning about the v7 package
+ * renames. It has no functional effect on dockview's behaviour. Following the
+ * renames, `dockview-core` is internal and `dockview` is the public JavaScript
+ * package; `dockview` calls {@link markDockviewPackageLoaded} on import so that
+ * `dockview-core` can detect — and warn about — being used directly.
+ */
+let _dockviewPackageLoaded = false;
+/**
+ * Called once by the `dockview` package on import, solely so `dockview-core`
+ * can warn when it is used directly (see above). Not used for anything else.
+ */
+export function markDockviewPackageLoaded() {
+    _dockviewPackageLoaded = true;
+}
+/**
+ * Whether the `dockview` package has been loaded in this process. Used only to
+ * gate the "don't use dockview-core directly" developer warning.
+ */
+export function isDockviewPackageLoaded() {
+    return _dockviewPackageLoaded;
+}

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

@@ -4,8 +4,11 @@ import { IGridView } from '../gridview/gridview';
 import { IContentRenderer, ITabRenderer, IWatermarkRenderer } from './types';
 import { Parameters } from '../panel/types';
 import { DockviewGroupPanel } from './dockviewGroupPanel';
+import { DockviewMessages } from './accessibilityMessages';
+export type { DockviewMessages } from './accessibilityMessages';
 import { PanelTransfer } from '../dnd/dataTransfer';
 import { IDisposable } from '../lifecycle';
+import { Box } from '../types';
 import { DroptargetOverlayModel, Position } from '../dnd/droptarget';
 import { GroupOptions } from './dockviewGroupPanelModel';
 import { DockviewGroupDropLocation } from './events';
@@ -13,7 +16,7 @@ import { IDockviewPanel } from './dockviewPanel';
 import { DockviewPanelRenderer } from '../overlay/overlayRenderContainer';
 import { IGroupDragGhostRenderer, IGroupHeaderProps, ITabGroupChipRenderer } from './framework';
 import { FloatingGroupOptions } from './dockviewComponent';
-import { Contraints } from '../gridview/gridviewPanel';
+import { Constraints } from '../gridview/gridviewPanel';
 import { AcceptableEvent, IAcceptableEvent } from '../events';
 import { DockviewTheme } from './theme';
 import { ITabGroup } from './tabGroup';
@@ -43,6 +46,54 @@ export interface ContextMenuItemConfig {
     disabled?: boolean;
 }
 export type ContextMenuItem = BuiltInContextMenuItem | ContextMenuItemConfig;
+export interface DropOverlayModelParams {
+    /** Which of a group's drop targets the overlay is for. `'edge'` is shaped by `dndEdges`, not this option. */
+    location: DockviewGroupDropLocation;
+    /** The group the target belongs to, where known (tab / header_space / content). */
+    group?: DockviewGroupPanel;
+}
+/** A layout change to be announced — see the `getAnnouncement` option. */
+export interface LiveRegionEvent {
+    /**
+     * What changed: a panel was added (`'open'`) or removed (`'close'`); a
+     * group was maximized (`'maximize'`) / restored (`'restore'`); or a group
+     * moved to a floating window (`'float'`), back into the grid (`'dock'`), or
+     * out to a popout window (`'popout'`). `panel` is the affected panel — for
+     * group events, the group's active panel.
+     */
+    kind: 'open' | 'close' | 'maximize' | 'restore' | 'float' | 'dock' | 'popout';
+    panel: IDockviewPanel;
+}
+/** A resolved announcement handed to a custom `announcer`. */
+export interface AnnouncementEvent {
+    /** The (already localised) text to announce. */
+    message: string;
+    /** `'assertive'` interrupts the screen reader; `'polite'` waits for a pause. */
+    politeness: 'polite' | 'assertive';
+}
+/**
+ * Key bindings for {@link DockviewComponentOptions.keyboardNavigation}. Each
+ * value is a string of `+`-separated parts, modifiers first, e.g. `'ctrl+]'`,
+ * `'shift+f6'`. Recognised modifiers: `ctrl`, `shift`, `alt`, `meta` (alias
+ * `cmd`). The final part is the `KeyboardEvent.key` to match, case-insensitively
+ * (`']'`, `'f6'`, `'arrowleft'`).
+ */
+export interface DockviewKeybindings {
+    /** Switch to the next tab in the focused group. Default `ctrl+]`. */
+    nextTab: string;
+    /** Switch to the previous tab in the focused group. Default `ctrl+[`. */
+    prevTab: string;
+    /** Move focus to the next group. Default `f6`. */
+    focusNextGroup: string;
+    /** Move focus to the previous group. Default `shift+f6`. */
+    focusPrevGroup: string;
+    /** Move focus from panel content to the focused group's tab strip. Default `ctrl+shift+\`. */
+    focusTabs: string;
+}
+export interface KeyboardNavigationOptions {
+    /** Override individual {@link DockviewKeybindings}; unset keys keep their defaults. */
+    keymap?: Partial<DockviewKeybindings>;
+}
 export interface GetTabContextMenuItemsParams {
     panel: IDockviewPanel;
     group: DockviewGroupPanel;
@@ -78,6 +129,26 @@ export interface ViewFactoryData {
 export type DockviewHeaderPosition = 'top' | 'bottom' | 'left' | 'right';
 export type DockviewHeaderDirection = 'horizontal' | 'vertical';
 export type DockviewDndStrategy = 'auto' | 'pointer' | 'html5';
+/**
+ * Context handed to {@link DockviewOptions.transformFloatingGroupDrag} on each
+ * pointer-move frame while a floating group is being dragged.
+ */
+export interface FloatingGroupDragContext {
+    /** The floating group being dragged. */
+    readonly group: DockviewGroupPanel;
+    /** Proposed top-left + size this frame, in container pixels (pre-clamp). */
+    readonly proposed: Box;
+    /** Size of the container the floating group is dragged within. */
+    readonly container: {
+        width: number;
+        height: number;
+    };
+    /**
+     * Bounds of the other floating groups (relative to the same container),
+     * snapshotted at drag start.
+     */
+    readonly others: readonly Box[];
+}
 export interface DockviewOptions {
     /**
      * Disable the auto-resizing which is controlled through a `ResizeObserver`.
@@ -91,16 +162,39 @@ export interface DockviewOptions {
         minimumHeightWithinViewport?: number;
         minimumWidthWithinViewport?: number;
     };
+    /**
+     * Adjust a floating group's position while it is being dragged. Runs on
+     * each pointer-move frame with the proposed top-left (before the container
+     * clamp) and returns an adjusted top-left, or nothing to leave it
+     * unchanged. Use it for snapping, alignment, or custom bounds. Move only —
+     * resizing a floating group is unaffected.
+     *
+     * `context.others` holds the bounds of the other floating groups (relative
+     * to the same container), snapshotted at drag start, so the callback can
+     * align the dragged group against its siblings.
+     */
+    transformFloatingGroupDrag?: (context: FloatingGroupDragContext) => {
+        top: number;
+        left: number;
+    } | void;
+    /**
+     * Selects which element moves a floating group when dragged.
+     *
+     * - `'titlebar'` (default): a dedicated, blank drag-handle bar is rendered
+     *   above the group's tab bar. Dragging it moves the floating window;
+     *   shift+drag (mouse) / long-press (touch) redocks into the grid. Style
+     *   it with the `--dv-floating-titlebar-*` theme variables.
+     * - `'tabbar'`: the legacy behaviour — the empty space in the tab bar
+     *   (the "void container") doubles as the move handle. No dedicated bar
+     *   is rendered.
+     */
+    floatingGroupDragHandle?: 'titlebar' | 'tabbar';
     popoutUrl?: string;
     nonce?: CspNonceProvider;
     defaultRenderer?: DockviewPanelRenderer;
     defaultHeaderPosition?: DockviewHeaderPosition;
     debug?: boolean;
     dndEdges?: false | DroptargetOverlayModel;
-    /**
-     * @deprecated use `dndEdges` instead. To be removed in a future version.
-     * */
-    rootOverlayModel?: DroptargetOverlayModel;
     disableDnd?: boolean;
     /**
      * Selects which drag-and-drop implementation is active.
@@ -166,6 +260,65 @@ export interface DockviewOptions {
      * enabling i18n / custom visuals.
      */
     createGroupDragGhostComponent?: (group: DockviewGroupPanel) => IGroupDragGhostRenderer;
+    /**
+     * Shape the drop overlay shown over a group's drop targets — the tab
+     * strip (`'tab'`), the header void space (`'header_space'`) and the
+     * panel content area (`'content'`). Return a {@link DroptargetOverlayModel}
+     * to override that target's default overlay (size, activation threshold,
+     * small-element boundaries), or `undefined` to keep the default.
+     *
+     * `group` is provided where known (tab / header_space). The outer-layout
+     * edge overlay is shaped by `dndEdges`, not this option, so `'edge'` is
+     * not dispatched here.
+     */
+    dropOverlayModel?: (params: DropOverlayModelParams) => DroptargetOverlayModel | undefined;
+    /**
+     * Built-in screen-reader announcements of layout changes (a visually-hidden
+     * `aria-live` region narrating panel open/close etc.). On by default —
+     * set to `false` to disable, e.g. when the host app provides its own
+     * announcement system. Honoured live via `updateOptions`.
+     */
+    announcements?: boolean;
+    /**
+     * Localise or override the built-in announcement strings (the default
+     * messages are English). Return a string to use it, `null` / `''` to
+     * suppress that announcement, or `undefined` to keep the default. This is
+     * how non-English apps translate announcements — core ships no message
+     * catalog, only the default strings + this hook.
+     */
+    getAnnouncement?: (event: LiveRegionEvent) => string | null | undefined;
+    /**
+     * Route announcements to your own screen-reader infrastructure instead of
+     * the built-in `aria-live` regions (e.g. an app-wide live region). When
+     * set, dockview hands you each {@link AnnouncementEvent} and writes nothing
+     * to its own regions. `getAnnouncement` (localisation) still applies first.
+     */
+    announcer?: (event: AnnouncementEvent) => void;
+    /**
+     * Translate / override the strings dockview speaks to assistive technology
+     * — both the LiveRegion announcements and the keyboard-docking narration.
+     * Provide any subset of {@link DockviewMessages}; unset entries keep the
+     * English defaults. (`getAnnouncement` still applies first, per-event, for
+     * announcements.)
+     */
+    messages?: Partial<DockviewMessages>;
+    /**
+     * Operate the dock with the keyboard. `true` enables the default bindings;
+     * pass an object to override individual ones via `keymap`. Off by default
+     * (opt-in while the feature matures). Enables:
+     *
+     * - **Switch tab** within the focused group — `Ctrl`+`]` / `Ctrl`+`[`.
+     * - **Move focus between groups** — `F6` / `Shift`+`F6` (sequential) or
+     *   `Ctrl`+`Shift`+arrow keys (spatial: focus the group in that direction).
+     * - **Dock the active panel** without a mouse — `Ctrl`+`M` arms a two-phase
+     *   move (arrows cycle the target group with a live drop preview +
+     *   screen-reader narration, `Enter` docks, `Escape` cancels).
+     *
+     * Defaults avoid `Cmd`-based and browser-reserved combinations (e.g.
+     * `Cmd`+`M` is the macOS minimise-window shortcut); use {@link keymap} to
+     * rebind for your platform.
+     */
+    keyboardNavigation?: boolean | KeyboardNavigationOptions;
     /**
      * Replace the built-in tab group color palette with a user-defined list.
      *
@@ -300,7 +453,7 @@ export type AddPanelOptions<P extends object = Parameters> = {
     inactive?: boolean;
     initialWidth?: number;
     initialHeight?: number;
-} & Partial<AddPanelOptionsUnion> & Partial<Contraints>;
+} & Partial<AddPanelOptionsUnion> & Partial<Constraints>;
 type AddGroupOptionsWithPanel = {
     referencePanel: string | IDockviewPanel;
     direction?: Omit<Direction, 'within'>;

package/dist/esm/dockview/options.js

@@ -20,12 +20,13 @@ export const PROPERTY_KEYS_DOCKVIEW = (() => {
         singleTabMode: undefined,
         disableFloatingGroups: undefined,
         floatingGroupBounds: undefined,
+        transformFloatingGroupDrag: undefined,
+        floatingGroupDragHandle: undefined,
         popoutUrl: undefined,
         nonce: undefined,
         defaultRenderer: undefined,
         defaultHeaderPosition: undefined,
         debug: undefined,
-        rootOverlayModel: undefined,
         locked: undefined,
         disableDnd: undefined,
         dndStrategy: undefined,
@@ -39,6 +40,12 @@ export const PROPERTY_KEYS_DOCKVIEW = (() => {
         getTabGroupChipContextMenuItems: undefined,
         createTabGroupChipComponent: undefined,
         createGroupDragGhostComponent: undefined,
+        dropOverlayModel: undefined,
+        announcements: undefined,
+        getAnnouncement: undefined,
+        announcer: undefined,
+        messages: undefined,
+        keyboardNavigation: undefined,
         tabGroupColors: undefined,
         tabGroupAccent: undefined,
     };