dockview-core 6.0.6 → 6.1.1

package/dist/package/main.cjs.js

@@ -1,6 +1,6 @@
 /**
  * dockview-core
- * @version 6.0.6
+ * @version 6.1.1
  * @link https://github.com/mathuo/dockview
  * @license MIT
  */
@@ -74,6 +74,63 @@ function getPaneData() {
     return paneTransfer.getData(PaneTransfer.prototype)[0];
 }
 
+exports.DockviewDisposable = void 0;
+(function (Disposable) {
+    Disposable.NONE = {
+        dispose: () => {
+            // noop
+        },
+    };
+    function from(func) {
+        return {
+            dispose: () => {
+                func();
+            },
+        };
+    }
+    Disposable.from = from;
+})(exports.DockviewDisposable || (exports.DockviewDisposable = {}));
+class CompositeDisposable {
+    get isDisposed() {
+        return this._isDisposed;
+    }
+    constructor(...args) {
+        this._isDisposed = false;
+        this._disposables = new Set(args);
+    }
+    addDisposables(...args) {
+        args.forEach((arg) => this._disposables.add(arg));
+    }
+    removeDisposable(disposable) {
+        this._disposables.delete(disposable);
+    }
+    dispose() {
+        if (this._isDisposed) {
+            return;
+        }
+        this._isDisposed = true;
+        this._disposables.forEach((arg) => arg.dispose());
+        this._disposables.clear();
+    }
+}
+class MutableDisposable {
+    constructor() {
+        this._disposable = exports.DockviewDisposable.NONE;
+    }
+    set value(disposable) {
+        if (this._disposable) {
+            this._disposable.dispose();
+        }
+        this._disposable = disposable;
+    }
+    dispose() {
+        if (this._disposable) {
+            this._disposable.dispose();
+            this._disposable = exports.DockviewDisposable.NONE;
+        }
+    }
+}
+
 exports.DockviewEvent = void 0;
 (function (Event) {
     Event.any = (...children) => {
@@ -161,6 +218,7 @@ class Emitter {
         this.options = options;
         this._listeners = [];
         this._disposed = false;
+        this._pauseTokens = new Set();
     }
     get event() {
         if (!this._event) {
@@ -189,6 +247,11 @@ class Emitter {
     }
     fire(e) {
         var _a;
+        if (this._pauseTokens.size > 0) {
+            // while paused, the event is dropped entirely — `_last` is not
+            // updated, so replay subscribers won't see values fired during a pause
+            return;
+        }
         if ((_a = this.options) === null || _a === void 0 ? void 0 : _a.replay) {
             this._last = e;
         }
@@ -196,6 +259,11 @@ class Emitter {
             listener.callback(e);
         }
     }
+    pause() {
+        const token = {};
+        this._pauseTokens.add(token);
+        return exports.DockviewDisposable.from(() => this._pauseTokens.delete(token));
+    }
     dispose() {
         if (!this._disposed) {
             this._disposed = true;
@@ -277,63 +345,6 @@ class AsapEvent {
     }
 }
 
-exports.DockviewDisposable = void 0;
-(function (Disposable) {
-    Disposable.NONE = {
-        dispose: () => {
-            // noop
-        },
-    };
-    function from(func) {
-        return {
-            dispose: () => {
-                func();
-            },
-        };
-    }
-    Disposable.from = from;
-})(exports.DockviewDisposable || (exports.DockviewDisposable = {}));
-class CompositeDisposable {
-    get isDisposed() {
-        return this._isDisposed;
-    }
-    constructor(...args) {
-        this._isDisposed = false;
-        this._disposables = new Set(args);
-    }
-    addDisposables(...args) {
-        args.forEach((arg) => this._disposables.add(arg));
-    }
-    removeDisposable(disposable) {
-        this._disposables.delete(disposable);
-    }
-    dispose() {
-        if (this._isDisposed) {
-            return;
-        }
-        this._isDisposed = true;
-        this._disposables.forEach((arg) => arg.dispose());
-        this._disposables.clear();
-    }
-}
-class MutableDisposable {
-    constructor() {
-        this._disposable = exports.DockviewDisposable.NONE;
-    }
-    set value(disposable) {
-        if (this._disposable) {
-            this._disposable.dispose();
-        }
-        this._disposable = disposable;
-    }
-    dispose() {
-        if (this._disposable) {
-            this._disposable.dispose();
-            this._disposable = exports.DockviewDisposable.NONE;
-        }
-    }
-}
-
 class OverflowObserver extends CompositeDisposable {
     constructor(el) {
         super();
@@ -2409,34 +2420,45 @@ class Gridview {
              */
             maxmizedViewLocation = getGridLocation(maximizedView.element);
         }
-        if (this.hasMaximizedView()) {
-            /**
-             * the saved layout cannot be in its maxmized state otherwise all of the underlying
-             * view dimensions will be wrong
-             *
-             * To counteract this we temporaily remove the maximized view to compute the serialized output
-             * of the grid before adding back the maxmized view as to not alter the layout from the users
-             * perspective when `.toJSON()` is called
-             */
-            this.exitMaximizedView();
-        }
-        const root = serializeBranchNode(this.getView(), this.orientation);
-        const resullt = {
-            root,
-            width: this.width,
-            height: this.height,
-            orientation: this.orientation,
-        };
-        if (maxmizedViewLocation) {
-            resullt.maximizedNode = {
-                location: maxmizedViewLocation,
+        /**
+         * We pause the onDidMaximizedNodeChange events because this method needs to
+         * call `this.exitMaximizedView()`. We don't want this to invoke any listeners
+         * since we undo it before leaving this method
+         */
+        const pauseToken = this._onDidMaximizedNodeChange.pause();
+        try {
+            if (this.hasMaximizedView()) {
+                /**
+                 * the saved layout cannot be in its maxmized state otherwise all of the underlying
+                 * view dimensions will be wrong
+                 *
+                 * To counteract this we temporaily remove the maximized view to compute the serialized output
+                 * of the grid before adding back the maxmized view as to not alter the layout from the users
+                 * perspective when `.toJSON()` is called
+                 */
+                this.exitMaximizedView();
+            }
+            const root = serializeBranchNode(this.getView(), this.orientation);
+            const result = {
+                root,
+                width: this.width,
+                height: this.height,
+                orientation: this.orientation,
             };
+            if (maxmizedViewLocation) {
+                result.maximizedNode = {
+                    location: maxmizedViewLocation,
+                };
+            }
+            if (maximizedView) {
+                // replace any maximzied view that was removed for serialization purposes
+                this.maximizeView(maximizedView);
+            }
+            return result;
         }
-        if (maximizedView) {
-            // replace any maximzied view that was removed for serialization purposes
-            this.maximizeView(maximizedView);
+        finally {
+            pauseToken.dispose();
         }
-        return resullt;
     }
     dispose() {
         this.disposable.dispose();
@@ -7328,8 +7350,23 @@ class Tabs extends CompositeDisposable {
             new PanelTransfer(this.accessor.id, this.group.id, null, tabGroup.id),
         ], PanelTransfer.prototype);
         const iframes = disableIframePointEvents();
+        // The dragend listener on `_tabsList` is unreachable for chip
+        // drags because cross-group drops detach the chip from the DOM
+        // before dragend fires (the source tab group becomes empty, so
+        // `_positionChipForGroup` removes the chip element). Without
+        // bubbling, the tabsList listener never runs and `_animState`,
+        // `_chipDragCleanup`, and the dragging CSS classes leak. Listen
+        // directly on the chip element so cleanup happens regardless of
+        // whether it's still attached.  (Issue #1254.)
+        const chipElement = chip.element;
+        const onChipDragEnd = () => {
+            chipElement.removeEventListener('dragend', onChipDragEnd);
+            this.resetDragAnimation();
+        };
+        chipElement.addEventListener('dragend', onChipDragEnd);
         this._chipDragCleanup = {
             dispose: () => {
+                chipElement.removeEventListener('dragend', onChipDragEnd);
                 panelTransfer.clearData(PanelTransfer.prototype);
                 iframes.release();
             },
@@ -11363,8 +11400,12 @@ class OverlayRenderContainer extends CompositeDisposable {
             if (panel.api.isVisible) {
                 this.positionCache.invalidate();
                 resize();
+                focusContainer.style.pointerEvents = '';
+            }
+            else {
+                focusContainer.style.visibility = 'hidden';
+                focusContainer.style.pointerEvents = 'none';
             }
-            focusContainer.style.display = panel.api.isVisible ? '' : 'none';
         };
         const observerDisposable = new MutableDisposable();
         const correctLayerPosition = () => {
@@ -11400,7 +11441,7 @@ class OverlayRenderContainer extends CompositeDisposable {
          * the dnd events for the expect behaviours to continue to occur in terms of dnd
          *
          * the dnd observer does not need to be conditional on whether the panel is visible since
-         * non-visible panels are 'display: none' and in such case the dnd observer will not fire.
+         * non-visible panels have 'pointer-events: none' and in such case the dnd observer will not fire.
          */
         new DragAndDropObserver(focusContainer, {
             onDragEnd: (e) => {