dockview-core 6.6.1 → 7.0.3

package/dist/cjs/dockview/dockviewShell.js

@@ -17,39 +17,55 @@ var lifecycle_1 = require("../lifecycle");
 var splitview_1 = require("../splitview/splitview");
 var dom_1 = require("../dom");
 var EdgeGroupView = /** @class */ (function () {
-    function EdgeGroupView(options, group, orientation) {
+    function EdgeGroupView(options, group, orientation, gapAdd) {
+        if (gapAdd === void 0) { gapAdd = 0; }
         var _a, _b, _c;
         this._onDidChange = new events_1.Emitter();
         this.onDidChange = this._onDidChange.event;
         this.snap = false;
         this.priority = splitview_1.LayoutPriority.Low;
         this._isCollapsed = false;
+        this._tabSizeDisposables = new lifecycle_1.CompositeDisposable();
         this._group = group;
         this._orientation = orientation;
         group.element.classList.add('dv-edge-group');
         group.element.dataset.testid = "dv-edge-group-".concat(options.id);
-        this._collapsedSize = (_a = options.collapsedSize) !== null && _a !== void 0 ? _a : 35;
+        this._baseCollapsedSize = (_a = options.collapsedSize) !== null && _a !== void 0 ? _a : 35;
+        this._baseMinimumSize = options.minimumSize;
+        this._gapAdd = gapAdd;
         this._expandedMaximumSize =
             (_b = options.maximumSize) !== null && _b !== void 0 ? _b : Number.POSITIVE_INFINITY;
-        // If the caller explicitly provides a minimumSize, respect it.
-        // Otherwise fall back to collapsedSize + 50 so the expanded state is
-        // visually distinguishable from the collapsed state.
-        this._expandedMinimumSize =
-            options.minimumSize !== undefined
-                ? options.minimumSize
-                : this._collapsedSize + 50;
         this._lastExpandedSize = (_c = options.initialSize) !== null && _c !== void 0 ? _c : 200;
         if (options.collapsed) {
             this._isCollapsed = true;
             group.element.classList.add('dv-edge-collapsed');
         }
+        this._observeTabStrip();
     }
+    Object.defineProperty(EdgeGroupView.prototype, "_effectiveBaseCollapsed", {
+        /**
+         * The effective (pre-gap) collapsed size: the measured tab-strip size when
+         * available, otherwise the configured/theme base.
+         */
+        get: function () {
+            var _a;
+            return (_a = this._measuredTabSize) !== null && _a !== void 0 ? _a : this._baseCollapsedSize;
+        },
+        enumerable: false,
+        configurable: true
+    });
     Object.defineProperty(EdgeGroupView.prototype, "minimumSize", {
         get: function () {
             // When collapsed, lock size to collapsedSize so sash can't drag it open
-            return this._isCollapsed
-                ? this._collapsedSize
-                : this._expandedMinimumSize;
+            if (this._isCollapsed) {
+                return this.collapsedSize;
+            }
+            // If the caller explicitly provides a minimumSize, respect it.
+            // Otherwise fall back to collapsedSize + 50 so the expanded state is
+            // visually distinguishable from the collapsed state.
+            return this._baseMinimumSize !== undefined
+                ? this._baseMinimumSize + this._gapAdd
+                : this._effectiveBaseCollapsed + 50 + this._gapAdd;
         },
         enumerable: false,
         configurable: true
@@ -58,7 +74,7 @@ var EdgeGroupView = /** @class */ (function () {
         get: function () {
             // When collapsed, lock size to collapsedSize so sash can't drag it open
             return this._isCollapsed
-                ? this._collapsedSize
+                ? this.collapsedSize
                 : this._expandedMaximumSize;
         },
         enumerable: false,
@@ -87,11 +103,43 @@ var EdgeGroupView = /** @class */ (function () {
     });
     Object.defineProperty(EdgeGroupView.prototype, "collapsedSize", {
         get: function () {
-            return this._collapsedSize;
+            return this._effectiveBaseCollapsed + this._gapAdd;
         },
         enumerable: false,
         configurable: true
     });
+    /**
+     * Watch the group's tab strip so the collapsed size follows the live tab
+     * height. The strip's cross-axis size (height for top/bottom, width for
+     * left/right) is exactly what a collapsed edge group should occupy; a
+     * ResizeObserver keeps them in sync when the tab height changes at runtime.
+     */
+    EdgeGroupView.prototype._observeTabStrip = function () {
+        var _this = this;
+        var strip = this._group.element.querySelector('.dv-tabs-and-actions-container');
+        if (!strip) {
+            return;
+        }
+        this._tabSizeDisposables.addDisposables((0, dom_1.watchElementResize)(strip, function () {
+            _this._applyMeasuredTabSize(_this._orientation === 'vertical'
+                ? strip.offsetHeight
+                : strip.offsetWidth);
+        }));
+    };
+    /**
+     * Apply a freshly-measured tab-strip cross size. When the group is
+     * collapsed this resizes it in the parent splitview so the collapsed strip
+     * always shows the full tab height.
+     */
+    EdgeGroupView.prototype._applyMeasuredTabSize = function (size) {
+        if (size <= 0 || size === this._measuredTabSize) {
+            return;
+        }
+        this._measuredTabSize = size;
+        if (this._isCollapsed) {
+            this._onDidChange.fire({ size: this.collapsedSize });
+        }
+    };
     EdgeGroupView.prototype.layout = function (size, orthogonalSize) {
         // Track the last expanded size so we can restore it after collapsing
         if (!this._isCollapsed) {
@@ -126,15 +174,18 @@ var EdgeGroupView = /** @class */ (function () {
         this._lastExpandedSize = size;
     };
     /**
-     * Apply new effective collapsed and expanded-minimum sizes after a theme
-     * or gap change. The caller (ShellManager) is responsible for computing
-     * the correct values from the original config and the new gap.
+     * Apply a new base (pre-gap) collapsed size, base minimum size and gap
+     * contribution after a theme or gap change. Base values come from the
+     * original config; the ShellManager owns the gap arithmetic. A live
+     * measured tab size (if any) continues to win over the base collapsed size.
      */
-    EdgeGroupView.prototype.updateCollapsedSize = function (newCollapsedSize, newExpandedMinimumSize) {
-        this._collapsedSize = newCollapsedSize;
-        this._expandedMinimumSize = newExpandedMinimumSize;
+    EdgeGroupView.prototype.updateSizing = function (baseCollapsedSize, baseMinimumSize, gapAdd) {
+        this._baseCollapsedSize = baseCollapsedSize;
+        this._baseMinimumSize = baseMinimumSize;
+        this._gapAdd = gapAdd;
     };
     EdgeGroupView.prototype.dispose = function () {
+        this._tabSizeDisposables.dispose();
         this._onDidChange.dispose();
     };
     return EdgeGroupView;
@@ -279,15 +330,6 @@ var MiddleColumnView = /** @class */ (function () {
     };
     return MiddleColumnView;
 }());
-function adjustedOpts(base, defaultCollapsed, gapAdd) {
-    var _a;
-    var effectiveCollapsed = ((_a = base.collapsedSize) !== null && _a !== void 0 ? _a : defaultCollapsed) + gapAdd;
-    var result = __assign(__assign({}, base), { collapsedSize: effectiveCollapsed });
-    if (base.minimumSize !== undefined) {
-        result.minimumSize = base.minimumSize + gapAdd;
-    }
-    return result;
-}
 var ShellManager = /** @class */ (function () {
     function ShellManager(container, dockviewElement, layoutGrid, gap, defaultCollapsedSize) {
         if (gap === void 0) { gap = 0; }
@@ -316,6 +358,26 @@ var ShellManager = /** @class */ (function () {
         this._middleIndex = 0;
         this._outerSplitview.addView(this._middleColumn, { type: 'distribute' }, 0);
         this._disposables.addDisposables((0, dom_1.watchElementResize)(this._shellElement, function (entry) {
+            /**
+             * When the shell (or an ancestor) becomes hidden — e.g. a
+             * nested dockview whose `onlyWhenVisible` host panel is
+             * deactivated — the element collapses to (0, 0) or is detached
+             * from the DOM. Propagating that zero size would relayout the
+             * edge-group splitview at 0, clamping the low-priority edge
+             * groups down to their minimum size and destroying the user's
+             * sizing. Skip these cases so sizes are preserved while hidden;
+             * mirrors the guard in the `Resizable` base class. See #1495.
+             *
+             * offsetParent === null is equivalent to display: none on the
+             * element or one of its ancestors.
+             * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/offsetParent
+             */
+            if (!_this._shellElement.offsetParent) {
+                return;
+            }
+            if (!(0, dom_1.isInDocument)(_this._shellElement)) {
+                return;
+            }
             var width = Math.round(entry.contentRect.width);
             var height = Math.round(entry.contentRect.height);
             if (width === _this._currentWidth &&
@@ -356,7 +418,7 @@ var ShellManager = /** @class */ (function () {
         var isHorizontal = position === 'left' || position === 'right';
         var gapAdd = isHorizontal ? outerGapAdd : innerGapAdd;
         var orientation = isHorizontal ? 'horizontal' : 'vertical';
-        var view = new EdgeGroupView(adjustedOpts(__assign({ collapsedSize: this._defaultCollapsedSize }, options), this._defaultCollapsedSize, gapAdd), group, orientation);
+        var view = new EdgeGroupView(__assign({ collapsedSize: this._defaultCollapsedSize }, options), group, orientation, gapAdd);
         var initialSize = view.isCollapsed
             ? view.collapsedSize
             : view.lastExpandedSize;
@@ -423,10 +485,7 @@ var ShellManager = /** @class */ (function () {
         var updateView = function (view, baseCfg, gapAdd) {
             var _a;
             var baseCS = (_a = baseCfg.collapsedSize) !== null && _a !== void 0 ? _a : defaultCollapsedSize;
-            var newCS = baseCS + gapAdd;
-            var baseMS = baseCfg.minimumSize;
-            var newMS = baseMS !== undefined ? baseMS + gapAdd : newCS + 50;
-            view.updateCollapsedSize(newCS, newMS);
+            view.updateSizing(baseCS, baseCfg.minimumSize, gapAdd);
         };
         var topCfg = this._viewConfigs.get('top');
         if (this._topView && topCfg) {
@@ -677,9 +736,8 @@ var ShellManager = /** @class */ (function () {
         }
     };
     ShellManager.prototype.dispose = function () {
-        var _a;
         this._disposables.dispose();
-        (_a = this._shellElement.parentElement) === null || _a === void 0 ? void 0 : _a.removeChild(this._shellElement);
+        this._shellElement.remove();
     };
     return ShellManager;
 }());

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); },
+});