dockview-core 6.6.1 → 7.0.2

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

@@ -0,0 +1,38 @@
+import { IDisposable } from '../lifecycle';
+import { DockviewGroupPanel } from './dockviewGroupPanel';
+import { EdgeGroupPosition } from './dockviewShell';
+/**
+ * EdgeGroupService is a pure registry: it tracks which positions are
+ * occupied and owns each edge group's per-instance cleanup disposable.
+ *
+ * The ShellManager (layout infrastructure) and the addEdgeGroup
+ * orchestration remain on DockviewComponent.
+ */
+export interface IEdgeGroupServiceHost {
+}
+export interface IEdgeGroupService extends IDisposable {
+    add(position: EdgeGroupPosition, group: DockviewGroupPanel, autoCollapseDisposable: IDisposable): void;
+    remove(position: EdgeGroupPosition): void;
+    get(position: EdgeGroupPosition): DockviewGroupPanel | undefined;
+    has(position: EdgeGroupPosition): boolean;
+    hasAny(): boolean;
+    entries(): IterableIterator<[EdgeGroupPosition, DockviewGroupPanel]>;
+    includes(group: DockviewGroupPanel): boolean;
+    findPositionOf(group: DockviewGroupPanel): EdgeGroupPosition | undefined;
+    disposeAll(): void;
+}
+export declare class EdgeGroupService implements IEdgeGroupService {
+    private readonly _edgeGroups;
+    private readonly _edgeGroupDisposables;
+    add(position: EdgeGroupPosition, group: DockviewGroupPanel, autoCollapseDisposable: IDisposable): void;
+    remove(position: EdgeGroupPosition): void;
+    get(position: EdgeGroupPosition): DockviewGroupPanel | undefined;
+    has(position: EdgeGroupPosition): boolean;
+    hasAny(): boolean;
+    entries(): IterableIterator<[EdgeGroupPosition, DockviewGroupPanel]>;
+    includes(group: DockviewGroupPanel): boolean;
+    findPositionOf(group: DockviewGroupPanel): EdgeGroupPosition | undefined;
+    disposeAll(): void;
+    dispose(): void;
+}
+export declare const EdgeGroupModule: import("./modules").DockviewModule<IEdgeGroupServiceHost>;

package/dist/cjs/dockview/edgeGroupService.js

@@ -0,0 +1,128 @@
+"use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdgeGroupModule = exports.EdgeGroupService = void 0;
+var modules_1 = require("./modules");
+var EdgeGroupService = /** @class */ (function () {
+    function EdgeGroupService() {
+        this._edgeGroups = new Map();
+        this._edgeGroupDisposables = new Map();
+    }
+    // No constructor needed — the host is currently unused. The
+    // IEdgeGroupServiceHost slot stays for symmetry with the other modules
+    // and to leave room for future host callbacks.
+    EdgeGroupService.prototype.add = function (position, group, autoCollapseDisposable) {
+        this._edgeGroups.set(position, group);
+        this._edgeGroupDisposables.set(position, autoCollapseDisposable);
+    };
+    EdgeGroupService.prototype.remove = function (position) {
+        var _a;
+        (_a = this._edgeGroupDisposables.get(position)) === null || _a === void 0 ? void 0 : _a.dispose();
+        this._edgeGroupDisposables.delete(position);
+        this._edgeGroups.delete(position);
+    };
+    EdgeGroupService.prototype.get = function (position) {
+        return this._edgeGroups.get(position);
+    };
+    EdgeGroupService.prototype.has = function (position) {
+        return this._edgeGroups.has(position);
+    };
+    EdgeGroupService.prototype.hasAny = function () {
+        return this._edgeGroups.size > 0;
+    };
+    EdgeGroupService.prototype.entries = function () {
+        return this._edgeGroups.entries();
+    };
+    EdgeGroupService.prototype.includes = function (group) {
+        var e_1, _a;
+        try {
+            for (var _b = __values(this._edgeGroups.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var edgeGroup = _c.value;
+                if (edgeGroup === group) {
+                    return true;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return false;
+    };
+    EdgeGroupService.prototype.findPositionOf = function (group) {
+        var e_2, _a;
+        try {
+            for (var _b = __values(this._edgeGroups), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), position = _d[0], edgeGroup = _d[1];
+                if (edgeGroup === group) {
+                    return position;
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return undefined;
+    };
+    EdgeGroupService.prototype.disposeAll = function () {
+        var e_3, _a;
+        try {
+            for (var _b = __values(this._edgeGroupDisposables.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var disposable = _c.value;
+                disposable.dispose();
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        this._edgeGroupDisposables.clear();
+        this._edgeGroups.clear();
+    };
+    EdgeGroupService.prototype.dispose = function () {
+        this.disposeAll();
+    };
+    return EdgeGroupService;
+}());
+exports.EdgeGroupService = EdgeGroupService;
+exports.EdgeGroupModule = (0, modules_1.defineModule)({
+    name: 'EdgeGroup',
+    serviceKey: 'edgeGroupService',
+    create: function () { return new EdgeGroupService(); },
+});

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

@@ -0,0 +1,37 @@
+import { IDisposable } from '../lifecycle';
+import { Gridview } from '../gridview/gridview';
+import { Overlay } from '../overlay/overlay';
+import { DockviewFloatingGroupPanel } from './dockviewFloatingGroupPanel';
+import { DockviewGroupPanel } from './dockviewGroupPanel';
+import { DockviewOptions } from './options';
+import { SerializedFloatingGroup } from './dockviewComponent';
+/**
+ * Narrow callback surface the FloatingGroupService needs from its host
+ * component. Keeps the service decoupled from DockviewComponent.
+ */
+export interface IFloatingGroupHost {
+    fireLayoutChange(): void;
+}
+export interface IFloatingGroupService extends IDisposable {
+    readonly floatingGroups: readonly DockviewFloatingGroupPanel[];
+    add(group: DockviewGroupPanel, overlay: Overlay, gridview: Gridview): DockviewFloatingGroupPanel;
+    findByGroup(group: DockviewGroupPanel): DockviewFloatingGroupPanel | undefined;
+    serialize(): SerializedFloatingGroup[];
+    constrainBounds(): void;
+    updateBounds(options: Partial<DockviewOptions>): void;
+    disposeAll(): void;
+}
+export declare class FloatingGroupService implements IFloatingGroupService {
+    private readonly _host;
+    private readonly _floatingGroups;
+    get floatingGroups(): readonly DockviewFloatingGroupPanel[];
+    constructor(host: IFloatingGroupHost);
+    add(group: DockviewGroupPanel, overlay: Overlay, gridview: Gridview): DockviewFloatingGroupPanel;
+    findByGroup(group: DockviewGroupPanel): DockviewFloatingGroupPanel | undefined;
+    serialize(): SerializedFloatingGroup[];
+    constrainBounds(): void;
+    updateBounds(options: Partial<DockviewOptions>): void;
+    disposeAll(): void;
+    dispose(): void;
+}
+export declare const FloatingGroupModule: import("./modules").DockviewModule<IFloatingGroupHost>;

package/dist/cjs/dockview/floatingGroupService.js

@@ -0,0 +1,231 @@
+"use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FloatingGroupModule = exports.FloatingGroupService = void 0;
+var lifecycle_1 = require("../lifecycle");
+var array_1 = require("../array");
+var dom_1 = require("../dom");
+var constants_1 = require("../constants");
+var dockviewFloatingGroupPanel_1 = require("./dockviewFloatingGroupPanel");
+var modules_1 = require("./modules");
+var FloatingGroupService = /** @class */ (function () {
+    function FloatingGroupService(host) {
+        this._floatingGroups = [];
+        this._host = host;
+    }
+    Object.defineProperty(FloatingGroupService.prototype, "floatingGroups", {
+        get: function () {
+            return this._floatingGroups;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    FloatingGroupService.prototype.add = function (group, overlay, gridview) {
+        var _this = this;
+        var floatingGroupPanel = new dockviewFloatingGroupPanel_1.DockviewFloatingGroupPanel(group, overlay, gridview);
+        var disposable = new lifecycle_1.CompositeDisposable(group.api.onDidActiveChange(function (event) {
+            if (event.isActive) {
+                overlay.bringToFront();
+            }
+        }), (function () {
+            // The floating window's nested gridview fills the overlay
+            // beneath the (optional) title bar; size it from its own
+            // measured box so it follows the overlay as the user drags
+            // / resizes the window.
+            var lastWidth = -1;
+            var lastHeight = -1;
+            return (0, dom_1.watchElementResize)(gridview.element, function (entry) {
+                var width = Math.round(entry.contentRect.width);
+                var height = Math.round(entry.contentRect.height);
+                if (width === lastWidth && height === lastHeight) {
+                    return;
+                }
+                lastWidth = width;
+                lastHeight = height;
+                gridview.layout(width, height);
+            });
+        })());
+        // Floating windows are non-modal dialogs (role set in Overlay). Give
+        // the dialog an accessible name from the representative group's active
+        // panel, refreshed as the active panel changes. An untitled panel
+        // leaves the dialog unnamed rather than hard-coding a label string.
+        var updateDialogLabel = function () {
+            var _a;
+            var title = (_a = group.activePanel) === null || _a === void 0 ? void 0 : _a.title;
+            if (title) {
+                overlay.element.setAttribute('aria-label', title);
+            }
+            else {
+                overlay.element.removeAttribute('aria-label');
+            }
+        };
+        updateDialogLabel();
+        floatingGroupPanel.addDisposables(group.api.onDidActivePanelChange(function () { return updateDialogLabel(); }), overlay.onDidChange(function () {
+            gridview.layout(gridview.width, gridview.height);
+        }), overlay.onDidChangeEnd(function () {
+            _this._host.fireLayoutChange();
+        }), group.onDidChange(function (event) {
+            // `event.height` is the group's requested *content* height.
+            // When a dedicated title bar is present the overlay's outer
+            // box is taller by the header, so add it back to preserve the
+            // requested content size.
+            overlay.setBounds({
+                height: typeof (event === null || event === void 0 ? void 0 : event.height) === 'number'
+                    ? event.height + overlay.headerHeight
+                    : event === null || event === void 0 ? void 0 : event.height,
+                width: event === null || event === void 0 ? void 0 : event.width,
+            });
+        }), {
+            dispose: function () {
+                disposable.dispose();
+                (0, array_1.remove)(_this._floatingGroups, floatingGroupPanel);
+                group.model.location = { type: 'grid' };
+            },
+        });
+        this._floatingGroups.push(floatingGroupPanel);
+        return floatingGroupPanel;
+    };
+    FloatingGroupService.prototype.findByGroup = function (group) {
+        // A floating window may host several groups in a nested gridview, so
+        // match by membership (DOM containment) rather than only the anchor
+        // group. `floating.group === group` covers the brief window before the
+        // anchor's element is attached to the gridview.
+        return this._floatingGroups.find(function (floating) {
+            return floating.group === group ||
+                floating.gridview.element.contains(group.element);
+        });
+    };
+    FloatingGroupService.prototype.serialize = function () {
+        return this._floatingGroups.map(function (floating) {
+            var grid = floating.gridview.serialize();
+            var position = floating.overlay.toJSON();
+            var root = grid.root;
+            // A single-group window keeps the legacy `data` shape so layouts
+            // round-trip byte-stably and older readers keep working; only
+            // genuine multi-group windows emit the nested `grid` form.
+            if (root.type === 'branch' &&
+                root.data.length === 1 &&
+                root.data[0].type === 'leaf') {
+                return {
+                    data: root.data[0].data,
+                    position: position,
+                };
+            }
+            return { grid: grid, position: position };
+        });
+    };
+    FloatingGroupService.prototype.constrainBounds = function () {
+        var e_1, _a;
+        try {
+            for (var _b = __values(this._floatingGroups), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var floating = _c.value;
+                floating.overlay.setBounds();
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    };
+    FloatingGroupService.prototype.updateBounds = function (options) {
+        var e_2, _a;
+        var _b, _c;
+        if (!('floatingGroupBounds' in options)) {
+            return;
+        }
+        try {
+            for (var _d = __values(this._floatingGroups), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var group = _e.value;
+                switch (options.floatingGroupBounds) {
+                    case 'boundedWithinViewport':
+                        group.overlay.minimumInViewportHeight = undefined;
+                        group.overlay.minimumInViewportWidth = undefined;
+                        break;
+                    case undefined:
+                        group.overlay.minimumInViewportHeight =
+                            constants_1.DEFAULT_FLOATING_GROUP_OVERFLOW_SIZE;
+                        group.overlay.minimumInViewportWidth =
+                            constants_1.DEFAULT_FLOATING_GROUP_OVERFLOW_SIZE;
+                        break;
+                    default:
+                        group.overlay.minimumInViewportHeight =
+                            (_b = options.floatingGroupBounds) === null || _b === void 0 ? void 0 : _b.minimumHeightWithinViewport;
+                        group.overlay.minimumInViewportWidth =
+                            (_c = options.floatingGroupBounds) === null || _c === void 0 ? void 0 : _c.minimumWidthWithinViewport;
+                }
+                group.overlay.setBounds();
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    };
+    FloatingGroupService.prototype.disposeAll = function () {
+        var e_3, _a;
+        try {
+            for (var _b = __values(__spreadArray([], __read(this._floatingGroups), false)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var floating = _c.value;
+                floating.dispose();
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+    };
+    FloatingGroupService.prototype.dispose = function () {
+        this.disposeAll();
+    };
+    return FloatingGroupService;
+}());
+exports.FloatingGroupService = FloatingGroupService;
+exports.FloatingGroupModule = (0, modules_1.defineModule)({
+    name: 'FloatingGroup',
+    serviceKey: 'floatingGroupService',
+    create: function (host) { return new FloatingGroupService(host); },
+});

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

@@ -0,0 +1,32 @@
+import { IDisposable } from '../lifecycle';
+import { Event } from '../events';
+import { DockviewComponentOptions } from './options';
+import { DockviewGroupPanel } from './dockviewGroupPanel';
+import { DockviewApi } from '../api/component.api';
+export interface IHeaderActionsHost {
+    readonly api: DockviewApi;
+    readonly options: DockviewComponentOptions;
+    readonly groups: DockviewGroupPanel[];
+    readonly onDidAddGroup: Event<DockviewGroupPanel>;
+    readonly onDidRemoveGroup: Event<DockviewGroupPanel>;
+}
+export interface IHeaderActionsService extends IDisposable {
+    /** Re-mount the three header action slots on a single group. */
+    refresh(group: DockviewGroupPanel): void;
+    /** Re-mount on every group; used when one of the three options changes. */
+    refreshAll(): void;
+    /** Tear down per-group renderer state. */
+    disposeGroup(group: DockviewGroupPanel): void;
+}
+export declare class HeaderActionsService implements IHeaderActionsService {
+    private readonly _host;
+    private readonly _perGroup;
+    constructor(host: IHeaderActionsHost);
+    refresh(group: DockviewGroupPanel): void;
+    refreshAll(): void;
+    disposeGroup(group: DockviewGroupPanel): void;
+    dispose(): void;
+    private _ensureState;
+    private _refreshSlot;
+}
+export declare const HeaderActionsModule: import("./modules").DockviewModule<IHeaderActionsHost>;

package/dist/cjs/dockview/headerActionsService.js

@@ -0,0 +1,149 @@
+"use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeaderActionsModule = exports.HeaderActionsService = void 0;
+var lifecycle_1 = require("../lifecycle");
+var modules_1 = require("./modules");
+var SLOT_OPTION_KEY = {
+    left: 'createLeftHeaderActionComponent',
+    right: 'createRightHeaderActionComponent',
+    prefix: 'createPrefixHeaderActionComponent',
+};
+var HeaderActionsService = /** @class */ (function () {
+    function HeaderActionsService(host) {
+        this._perGroup = new Map();
+        this._host = host;
+    }
+    HeaderActionsService.prototype.refresh = function (group) {
+        // The headerPosition setter on DockviewGroupPanelModel fires inside
+        // the model's constructor — before the parent DockviewGroupPanel has
+        // assigned its `_model` field, and in tests where the parent panel
+        // may be null. Skip; DockviewGroupPanel.initialize() will refresh
+        // once construction completes for real groups.
+        if (!(group === null || group === void 0 ? void 0 : group.model)) {
+            return;
+        }
+        var state = this._ensureState(group);
+        this._refreshSlot('left', group, state.left);
+        this._refreshSlot('right', group, state.right);
+        this._refreshSlot('prefix', group, state.prefix);
+    };
+    HeaderActionsService.prototype.refreshAll = function () {
+        var e_1, _a;
+        try {
+            for (var _b = __values(this._host.groups), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var group = _c.value;
+                this.refresh(group);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    };
+    HeaderActionsService.prototype.disposeGroup = function (group) {
+        var state = this._perGroup.get(group);
+        if (!state) {
+            return;
+        }
+        state.left.dispose();
+        state.right.dispose();
+        state.prefix.dispose();
+        this._perGroup.delete(group);
+    };
+    HeaderActionsService.prototype.dispose = function () {
+        var e_2, _a;
+        try {
+            for (var _b = __values(__spreadArray([], __read(this._perGroup.keys()), false)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var group = _c.value;
+                this.disposeGroup(group);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    };
+    HeaderActionsService.prototype._ensureState = function (group) {
+        var state = this._perGroup.get(group);
+        if (!state) {
+            state = {
+                left: new lifecycle_1.MutableDisposable(),
+                right: new lifecycle_1.MutableDisposable(),
+                prefix: new lifecycle_1.MutableDisposable(),
+            };
+            this._perGroup.set(group, state);
+        }
+        return state;
+    };
+    HeaderActionsService.prototype._refreshSlot = function (slot, group, disposable) {
+        var factory = this._host.options[SLOT_OPTION_KEY[slot]];
+        if (factory) {
+            var renderer = factory(group);
+            disposable.value = renderer;
+            renderer.init({
+                containerApi: this._host.api,
+                api: group.api,
+                group: group,
+            });
+            group.model.attachHeaderAction(slot, renderer.element);
+        }
+        else {
+            disposable.dispose();
+            group.model.attachHeaderAction(slot, undefined);
+        }
+    };
+    return HeaderActionsService;
+}());
+exports.HeaderActionsService = HeaderActionsService;
+exports.HeaderActionsModule = (0, modules_1.defineModule)({
+    name: 'HeaderActions',
+    serviceKey: 'headerActionsService',
+    create: function (host) { return new HeaderActionsService(host); },
+    init: function (host, service) {
+        return new lifecycle_1.CompositeDisposable(host.onDidRemoveGroup(function (group) {
+            service.disposeGroup(group);
+        }));
+    },
+});

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

@@ -0,0 +1,53 @@
+import { CompositeDisposable, IDisposable } from '../lifecycle';
+import { Event } from '../events';
+import { IDockviewPanel } from './dockviewPanel';
+import { DockviewGroupPanel } from './dockviewGroupPanel';
+import { DockviewLayoutMutationEvent, DockviewMaximizedGroupChangeEvent } from './dockviewComponent';
+import { DockviewComponentOptions } from './options';
+/**
+ * The narrow surface the {@link LiveRegionService} needs from the host
+ * (the `DockviewComponent`) — somewhere to mount the region and the layout
+ * events to narrate. `onWill/onDidMutateLayout` are used to suppress the
+ * bulk-load / clear burst (one transaction, not N panel announcements).
+ */
+export interface ILiveRegionHost {
+    readonly element: HTMLElement;
+    readonly options: DockviewComponentOptions;
+    readonly onDidAddPanel: Event<IDockviewPanel>;
+    readonly onDidRemovePanel: Event<IDockviewPanel>;
+    readonly onWillMutateLayout: Event<DockviewLayoutMutationEvent>;
+    readonly onDidMutateLayout: Event<DockviewLayoutMutationEvent>;
+    readonly onDidMaximizedGroupChange: Event<DockviewMaximizedGroupChangeEvent>;
+    readonly onDidAddGroup: Event<DockviewGroupPanel>;
+    readonly onDidRemoveGroup: Event<DockviewGroupPanel>;
+}
+export interface ILiveRegionService extends IDisposable {
+    /**
+     * Announce a message to assistive technology via the live region. The
+     * shared sink — the accessibility module writes keyboard-docking
+     * narration here too, so all announcements use one region.
+     */
+    announce(message: string, politeness?: 'polite' | 'assertive'): void;
+}
+/**
+ * Narrates layout state changes to screen readers via visually-hidden
+ * `aria-live` regions. Free / core (WCAG 4.1.3). Announces panel open/close +
+ * the shared `announce()` sink (the accessibility module narrates docking here too).
+ * Two regions: a **polite** one for routine status and an **assertive** one
+ * for errors/cancellations. The bulk load/clear burst is suppressed via the
+ * mutation-transaction events, and an app can take over delivery entirely with
+ * the `announcer` option.
+ */
+export declare class LiveRegionService extends CompositeDisposable implements ILiveRegionService {
+    private readonly _host;
+    private readonly _polite;
+    private readonly _assertive;
+    private _suppressDepth;
+    private readonly _locationSubs;
+    constructor(host: ILiveRegionHost);
+    private _trackLocation;
+    announce(message: string, politeness?: 'polite' | 'assertive'): void;
+    private _announce;
+    private _defaultMessage;
+}
+export declare const LiveRegionModule: import("./modules").DockviewModule<ILiveRegionHost>;