dockview-core 6.0.7 → 6.1.1

package/dist/dockview-core.noStyle.js

@@ -1,6 +1,6 @@
 /**
  * dockview-core
- * @version 6.0.7
+ * @version 6.1.1
  * @link https://github.com/mathuo/dockview
  * @license MIT
  */
@@ -78,6 +78,63 @@
         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) => {
@@ -165,6 +222,7 @@
             this.options = options;
             this._listeners = [];
             this._disposed = false;
+            this._pauseTokens = new Set();
         }
         get event() {
             if (!this._event) {
@@ -193,6 +251,11 @@
         }
         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;
             }
@@ -200,6 +263,11 @@
                 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;
@@ -281,63 +349,6 @@
         }
     }
 
-    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();
@@ -2413,34 +2424,45 @@
                  */
                 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();
@@ -11382,8 +11404,12 @@
                 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 = () => {
@@ -11419,7 +11445,7 @@
              * 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) => {

package/dist/esm/events.d.ts

@@ -45,6 +45,7 @@ export declare class Emitter<T> implements IDisposable {
     private _last?;
     private _listeners;
     private _disposed;
+    private readonly _pauseTokens;
     static ENABLE_TRACKING: boolean;
     static readonly MEMORY_LEAK_WATCHER: LeakageMonitor;
     static setLeakageMonitorEnabled(isEnabled: boolean): void;
@@ -52,6 +53,7 @@ export declare class Emitter<T> implements IDisposable {
     constructor(options?: EmitterOptions | undefined);
     get event(): Event<T>;
     fire(e: T): void;
+    pause(): IDisposable;
     dispose(): void;
 }
 export declare function addDisposableListener<K extends keyof WindowEventMap>(element: Window, type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions): IDisposable;

package/dist/esm/events.js

@@ -1,3 +1,4 @@
+import { Disposable } from './lifecycle';
 export var Event;
 (function (Event) {
     Event.any = (...children) => {
@@ -85,6 +86,7 @@ export class Emitter {
         this.options = options;
         this._listeners = [];
         this._disposed = false;
+        this._pauseTokens = new Set();
     }
     get event() {
         if (!this._event) {
@@ -118,6 +120,11 @@ export 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;
         }
@@ -125,6 +132,11 @@ export class Emitter {
             listener.callback(e);
         }
     }
+    pause() {
+        const token = {};
+        this._pauseTokens.add(token);
+        return Disposable.from(() => this._pauseTokens.delete(token));
+    }
     dispose() {
         if (!this._disposed) {
             this._disposed = true;

package/dist/esm/gridview/gridview.js

@@ -277,34 +277,45 @@ export 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();

package/dist/esm/overlay/overlayRenderContainer.js

@@ -136,8 +136,12 @@ export 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 = () => {
@@ -173,7 +177,7 @@ export 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) => {

package/dist/package/main.cjs.js

@@ -1,6 +1,6 @@
 /**
  * dockview-core
- * @version 6.0.7
+ * @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();
@@ -11378,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 = () => {
@@ -11415,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) => {