dockview-core 6.6.1 → 7.0.3

package/dist/cjs/dockview/popoutWindowService.js

@@ -0,0 +1,261 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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));
+};
+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.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PopoutWindowModule = exports.PopoutWindowService = void 0;
+var events_1 = require("../events");
+var array_1 = require("../array");
+var modules_1 = require("./modules");
+var PopoutWindowService = /** @class */ (function () {
+    function PopoutWindowService(host) {
+        this._entries = [];
+        this._popupServices = new Map();
+        this._restorationCleanups = new Set();
+        this._restorationPromise = Promise.resolve();
+        this._onDidRemove = new events_1.Emitter();
+        this.onDidRemove = this._onDidRemove.event;
+        this._host = host;
+    }
+    Object.defineProperty(PopoutWindowService.prototype, "entries", {
+        get: function () {
+            return this._entries;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PopoutWindowService.prototype, "restorationPromise", {
+        get: function () {
+            return this._restorationPromise;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PopoutWindowService.prototype.add = function (entry) {
+        this._entries.push(entry);
+    };
+    PopoutWindowService.prototype.remove = function (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 ((0, array_1.remove)(this._entries, entry) && !this._host.isDisposed) {
+            this._onDidRemove.fire(entry);
+        }
+    };
+    PopoutWindowService.prototype.findByGroup = function (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(function (entry) {
+            return entry.popoutGroup === group ||
+                entry.gridview.element.contains(group.element);
+        });
+    };
+    PopoutWindowService.prototype.findReferenceGroupId = function (group) {
+        var _a;
+        return (_a = this._entries.find(function (entry) { return 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).
+     */
+    PopoutWindowService.prototype.observeGridviewSize = function (popoutWindow, gridview, overlayRenderContainer) {
+        var _this = this;
+        var _a;
+        var PopoutResizeObserver = (_a = popoutWindow.window) === null || _a === void 0 ? void 0 : _a.ResizeObserver;
+        if (!PopoutResizeObserver) {
+            return undefined;
+        }
+        var lastWidth = -1;
+        var lastHeight = -1;
+        var relayout = function () {
+            var win = popoutWindow.window;
+            if (_this._host.isDisposed || !win || win.closed) {
+                return;
+            }
+            var width = Math.round(gridview.element.clientWidth);
+            var 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();
+        };
+        var observer = new PopoutResizeObserver(function () {
+            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.
+            var 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: function () { return observer.disconnect(); } };
+    };
+    PopoutWindowService.prototype.getPopupService = function (groupId) {
+        return this._popupServices.get(groupId);
+    };
+    PopoutWindowService.prototype.setPopupService = function (groupId, service) {
+        this._popupServices.set(groupId, service);
+    };
+    PopoutWindowService.prototype.deletePopupService = function (groupId) {
+        this._popupServices.delete(groupId);
+    };
+    PopoutWindowService.prototype.scheduleRestoration = function (delayMs, work, onCancel) {
+        var _this = this;
+        return new Promise(function (resolve) {
+            var cleanup = function () {
+                _this._restorationCleanups.delete(cleanup);
+                clearTimeout(handle);
+                onCancel === null || onCancel === void 0 ? void 0 : onCancel();
+                resolve();
+            };
+            var handle = setTimeout(function () {
+                _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);
+        });
+    };
+    PopoutWindowService.prototype.finishRestoration = function (promises) {
+        this._restorationPromise = Promise.all(promises).then(function () { return void 0; });
+    };
+    PopoutWindowService.prototype.cancelPendingRestorations = function () {
+        var e_1, _a;
+        try {
+            for (var _b = __values(__spreadArray([], __read(this._restorationCleanups), false)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var cleanup = _c.value;
+                cleanup();
+            }
+        }
+        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; }
+        }
+        this._restorationCleanups.clear();
+    };
+    PopoutWindowService.prototype.serialize = function () {
+        return this._entries.map(function (entry) {
+            var grid = entry.gridview.serialize();
+            var root = grid.root;
+            var url = entry.popoutGroup.api.location.type === 'popout'
+                ? entry.popoutGroup.api.location.popoutUrl
+                : undefined;
+            var base = {
+                gridReferenceGroup: entry.referenceGroup,
+                position: entry.window.dimensions(),
+                url: 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 __assign(__assign({}, base), { data: root.data[0].data });
+            }
+            return __assign(__assign({}, base), { grid: grid });
+        });
+    };
+    PopoutWindowService.prototype.disposeAll = function () {
+        var e_2, _a;
+        try {
+            for (var _b = __values(__spreadArray([], __read(this._entries), false)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var entry = _c.value;
+                entry.disposable.dispose();
+            }
+        }
+        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; }
+        }
+    };
+    PopoutWindowService.prototype.dispose = function () {
+        this.cancelPendingRestorations();
+        this.disposeAll();
+        this._onDidRemove.dispose();
+    };
+    return PopoutWindowService;
+}());
+exports.PopoutWindowService = PopoutWindowService;
+exports.PopoutWindowModule = (0, modules_1.defineModule)({
+    name: 'PopoutWindow',
+    serviceKey: 'popoutWindowService',
+    create: function (host) { return new PopoutWindowService(host); },
+});

package/dist/cjs/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/cjs/dockview/rootDropTargetService.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RootDropTargetModule = exports.RootDropTargetService = void 0;
+var events_1 = require("../events");
+var backend_1 = require("../dnd/backend");
+var dataTransfer_1 = require("../dnd/dataTransfer");
+var modules_1 = require("./modules");
+var DEFAULT_ROOT_OVERLAY_MODEL = {
+    activationSize: { type: 'pixels', value: 10 },
+    size: { type: 'pixels', value: 20 },
+};
+var RootDropTargetService = /** @class */ (function () {
+    function RootDropTargetService(host) {
+        var canDisplayOverlay = function (event, position) {
+            var data = (0, dataTransfer_1.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);
+        };
+        var overlayModel = typeof host.options.dndEdges === 'object' &&
+            host.options.dndEdges !== null
+            ? host.options.dndEdges
+            : DEFAULT_ROOT_OVERLAY_MODEL;
+        this._html5Target = backend_1.html5Backend.createDropTarget(host.element, {
+            className: 'dv-drop-target-edge',
+            canDisplayOverlay: canDisplayOverlay,
+            acceptedTargetZones: ['top', 'bottom', 'left', 'right', 'center'],
+            overlayModel: overlayModel,
+            getOverrideTarget: function () { return host.rootDropTargetOverrideTarget(); },
+        });
+        this._pointerTarget = backend_1.pointerBackend.createDropTarget(host.element, {
+            className: 'dv-drop-target-edge',
+            canDisplayOverlay: canDisplayOverlay,
+            acceptedTargetZones: ['top', 'bottom', 'left', 'right', 'center'],
+            overlayModel: overlayModel,
+            getOverrideTarget: function () { return host.rootDropTargetOverrideTarget(); },
+        });
+        this.onWillShowOverlay = events_1.Event.any(this._html5Target.onWillShowOverlay, this._pointerTarget.onWillShowOverlay);
+        this.onDrop = events_1.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);
+    }
+    RootDropTargetService.prototype.setOptions = function (options) {
+        if ('dndEdges' in options) {
+            var 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);
+            }
+        }
+    };
+    RootDropTargetService.prototype.dispose = function () {
+        this._html5Target.dispose();
+        this._pointerTarget.dispose();
+    };
+    return RootDropTargetService;
+}());
+exports.RootDropTargetService = RootDropTargetService;
+exports.RootDropTargetModule = (0, modules_1.defineModule)({
+    name: 'RootDropTarget',
+    serviceKey: 'rootDropTargetService',
+    create: function (host) { return new RootDropTargetService(host); },
+});

package/dist/cjs/dockview/strictEventsSequencing.js

@@ -36,11 +36,11 @@ var StrictEventsSequencing = /** @class */ (function (_super) {
                 panels.add(panel.api.id);
             }
         }), this.accessor.onDidRemovePanel(function (panel) {
-            if (!panels.has(panel.api.id)) {
-                throw new Error("dockview: Invalid event sequence. [onDidRemovePanel] called for panel ".concat(panel.api.id, " but panel does not exists"));
+            if (panels.has(panel.api.id)) {
+                panels.delete(panel.api.id);
             }
             else {
-                panels.delete(panel.api.id);
+                throw new Error("dockview: Invalid event sequence. [onDidRemovePanel] called for panel ".concat(panel.api.id, " but panel does not exists"));
             }
         }), this.accessor.onDidAddGroup(function (group) {
             if (groups.has(group.api.id)) {
@@ -50,11 +50,11 @@ var StrictEventsSequencing = /** @class */ (function (_super) {
                 groups.add(group.api.id);
             }
         }), this.accessor.onDidRemoveGroup(function (group) {
-            if (!groups.has(group.api.id)) {
-                throw new Error("dockview: Invalid event sequence. [onDidRemoveGroup] called for group ".concat(group.api.id, " but group does not exists"));
+            if (groups.has(group.api.id)) {
+                groups.delete(group.api.id);
             }
             else {
-                groups.delete(group.api.id);
+                throw new Error("dockview: Invalid event sequence. [onDidRemoveGroup] called for group ".concat(group.api.id, " but group does not exists"));
             }
         }));
     };

package/dist/cjs/dockview/tabGroup.js

@@ -147,9 +147,9 @@ var TabGroup = /** @class */ (function (_super) {
         if (this._panelIds.includes(panelId)) {
             return;
         }
-        var insertIndex = index !== undefined
-            ? Math.max(0, Math.min(index, this._panelIds.length))
-            : this._panelIds.length;
+        var insertIndex = index === undefined
+            ? this._panelIds.length
+            : Math.max(0, Math.min(index, this._panelIds.length));
         this._panelIds.splice(insertIndex, 0, panelId);
         this._onDidPanelChange.fire({ panelId: panelId, type: 'add' });
     };

package/dist/cjs/dockview/tabGroupAccent.js

@@ -99,9 +99,7 @@ var _fallbackPalette;
  * palette through.
  */
 function getFallbackPalette() {
-    if (!_fallbackPalette) {
-        _fallbackPalette = new TabGroupColorPalette(exports.DEFAULT_TAB_GROUP_COLORS, true);
-    }
+    _fallbackPalette !== null && _fallbackPalette !== void 0 ? _fallbackPalette : (_fallbackPalette = new TabGroupColorPalette(exports.DEFAULT_TAB_GROUP_COLORS, true));
     return _fallbackPalette;
 }
 /**

package/dist/cjs/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/cjs/dockview/watermarkService.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatermarkModule = exports.WatermarkService = void 0;
+var lifecycle_1 = require("../lifecycle");
+var dom_1 = require("../dom");
+var events_1 = require("../events");
+var modules_1 = require("./modules");
+var WatermarkService = /** @class */ (function () {
+    function WatermarkService(host) {
+        this._watermark = null;
+        this._host = host;
+    }
+    WatermarkService.prototype.update = function () {
+        if (this._host.hasVisibleGridGroup()) {
+            this._unmount();
+            return;
+        }
+        if (this._watermark) {
+            return;
+        }
+        this._watermark = this._host.createWatermarkComponent();
+        this._watermark.init({ containerApi: this._host.api });
+        var container = document.createElement('div');
+        container.className = 'dv-watermark-container';
+        (0, dom_1.addTestId)(container, 'watermark-component');
+        container.appendChild(this._watermark.element);
+        this._host.mountElement.appendChild(container);
+    };
+    WatermarkService.prototype.refresh = function () {
+        this._unmount();
+        this.update();
+    };
+    WatermarkService.prototype._unmount = function () {
+        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;
+    };
+    WatermarkService.prototype.dispose = function () {
+        this._unmount();
+    };
+    return WatermarkService;
+}());
+exports.WatermarkService = WatermarkService;
+exports.WatermarkModule = (0, modules_1.defineModule)({
+    name: 'Watermark',
+    serviceKey: 'watermarkService',
+    create: function (host) { return new WatermarkService(host); },
+    init: function (host, service) {
+        // Initial evaluation reflects the watermark state at construction time.
+        service.update();
+        return new lifecycle_1.CompositeDisposable(events_1.Event.any(host.onDidAdd, host.onDidRemove)(function () {
+            service.update();
+        }), host.onDidViewVisibilityChangeMicroTaskQueue(function () {
+            service.update();
+        }));
+    },
+});

package/dist/cjs/dom.js

@@ -179,7 +179,7 @@ var FocusTracker = /** @class */ (function (_super) {
         var onBlur = function () {
             if (hasFocus) {
                 loosingFocus = true;
-                window.setTimeout(function () {
+                globalThis.setTimeout(function () {
                     if (loosingFocus) {
                         loosingFocus = false;
                         hasFocus = false;

package/dist/cjs/events.js

@@ -95,7 +95,7 @@ var Stacktrace = /** @class */ (function () {
     }
     Stacktrace.create = function () {
         var _a;
-        return new Stacktrace((_a = new Error().stack) !== null && _a !== void 0 ? _a : '');
+        return new Stacktrace((_a = new Error('listener stacktrace').stack) !== null && _a !== void 0 ? _a : '');
     };
     Stacktrace.prototype.print = function () {
         console.warn('dockview: stacktrace', this.value);

package/dist/cjs/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/cjs/gridview/baseComponentGridview.js

@@ -90,8 +90,7 @@ var BaseGrid = /** @class */ (function (_super) {
         }), _this.onDidViewVisibilityChangeMicroTaskQueue(function () {
             _this.forceRelayout();
         }), lifecycle_1.Disposable.from(function () {
-            var _a;
-            (_a = _this.element.parentElement) === null || _a === void 0 ? void 0 : _a.removeChild(_this.element);
+            _this.element.remove();
         }), _this.gridview.onDidChange(function () {
             _this._bufferOnDidLayoutChange.fire();
         }), events_1.Event.any(_this.onDidAdd, _this.onDidRemove, _this.onDidActiveChange)(function () {
@@ -223,9 +222,10 @@ var BaseGrid = /** @class */ (function (_super) {
     BaseGrid.prototype.hasMaximizedGroup = function () {
         return this.gridview.hasMaximizedView();
     };
-    BaseGrid.prototype.doAddGroup = function (group, location, size) {
+    BaseGrid.prototype.doAddGroup = function (group, location, size, gridview) {
         if (location === void 0) { location = [0]; }
-        this.gridview.addView(group, size !== null && size !== void 0 ? size : splitview_1.Sizing.Distribute, location);
+        if (gridview === void 0) { gridview = this.gridview; }
+        gridview.addView(group, size !== null && size !== void 0 ? size : splitview_1.Sizing.Distribute, location);
         this._onDidAdd.fire(group);
     };
     BaseGrid.prototype.doRemoveGroup = function (group, options) {
@@ -268,9 +268,7 @@ var BaseGrid = /** @class */ (function (_super) {
     };
     BaseGrid.prototype.moveToNext = function (options) {
         var _a;
-        if (!options) {
-            options = {};
-        }
+        options !== null && options !== void 0 ? options : (options = {});
         if (!options.group) {
             if (!this.activeGroup) {
                 return;
@@ -283,9 +281,7 @@ var BaseGrid = /** @class */ (function (_super) {
     };
     BaseGrid.prototype.moveToPrevious = function (options) {
         var _a;
-        if (!options) {
-            options = {};
-        }
+        options !== null && options !== void 0 ? options : (options = {});
         if (!options.group) {
             if (!this.activeGroup) {
                 return;

package/dist/cjs/gridview/branchNode.js

@@ -66,16 +66,7 @@ var BranchNode = /** @class */ (function (_super) {
         _this._size = size;
         _this.element = document.createElement('div');
         _this.element.className = 'dv-branch-node';
-        if (!childDescriptors) {
-            _this.splitview = new splitview_1.Splitview(_this.element, {
-                orientation: _this.orientation,
-                proportionalLayout: proportionalLayout,
-                styles: styles,
-                margin: margin,
-            });
-            _this.splitview.layout(_this.size, _this.orthogonalSize);
-        }
-        else {
+        if (childDescriptors) {
             var descriptor = {
                 views: childDescriptors.map(function (childDescriptor) {
                     return {
@@ -98,6 +89,15 @@ var BranchNode = /** @class */ (function (_super) {
                 margin: margin,
             });
         }
+        else {
+            _this.splitview = new splitview_1.Splitview(_this.element, {
+                orientation: _this.orientation,
+                proportionalLayout: proportionalLayout,
+                styles: styles,
+                margin: margin,
+            });
+            _this.splitview.layout(_this.size, _this.orthogonalSize);
+        }
         _this.disabled = disabled;
         _this.addDisposables(_this._onDidChange, _this._onDidVisibilityChange, _this.splitview.onDidSashEnd(function () {
             _this._onDidChange.fire({});
@@ -218,15 +218,11 @@ var BranchNode = /** @class */ (function (_super) {
             if (this.children.length === 0) {
                 return splitview_1.LayoutPriority.Normal;
             }
-            var priorities = this.children.map(function (c) {
-                return typeof c.priority === 'undefined'
-                    ? splitview_1.LayoutPriority.Normal
-                    : c.priority;
-            });
-            if (priorities.some(function (p) { return p === splitview_1.LayoutPriority.High; })) {
+            var priorities = new Set(this.children.map(function (c) { var _a; return (_a = c.priority) !== null && _a !== void 0 ? _a : splitview_1.LayoutPriority.Normal; }));
+            if (priorities.has(splitview_1.LayoutPriority.High)) {
                 return splitview_1.LayoutPriority.High;
             }
-            else if (priorities.some(function (p) { return p === splitview_1.LayoutPriority.Low; })) {
+            else if (priorities.has(splitview_1.LayoutPriority.Low)) {
                 return splitview_1.LayoutPriority.Low;
             }
             return splitview_1.LayoutPriority.Normal;