dockview-core 6.0.7 → 6.1.1

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

@@ -13,6 +13,7 @@ var __values = (this && this.__values) || function(o) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsapEvent = exports.Emitter = exports.AcceptableEvent = exports.DockviewEvent = exports.Event = void 0;
 exports.addDisposableListener = addDisposableListener;
+var lifecycle_1 = require("./lifecycle");
 var Event;
 (function (Event) {
     Event.any = function () {
@@ -114,6 +115,7 @@ var Emitter = /** @class */ (function () {
         this.options = options;
         this._listeners = [];
         this._disposed = false;
+        this._pauseTokens = new Set();
     }
     Emitter.setLeakageMonitorEnabled = function (isEnabled) {
         if (isEnabled !== Emitter.ENABLE_TRACKING) {
@@ -166,6 +168,11 @@ var Emitter = /** @class */ (function () {
     Emitter.prototype.fire = function (e) {
         var e_1, _a;
         var _b;
+        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 ((_b = this.options) === null || _b === void 0 ? void 0 : _b.replay) {
             this._last = e;
         }
@@ -183,6 +190,12 @@ var Emitter = /** @class */ (function () {
             finally { if (e_1) throw e_1.error; }
         }
     };
+    Emitter.prototype.pause = function () {
+        var _this = this;
+        var token = {};
+        this._pauseTokens.add(token);
+        return lifecycle_1.Disposable.from(function () { return _this._pauseTokens.delete(token); });
+    };
     Emitter.prototype.dispose = function () {
         var _this = this;
         if (!this._disposed) {

package/dist/cjs/gridview/gridview.js

@@ -375,34 +375,45 @@ var Gridview = /** @class */ (function () {
              */
             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();
-        }
-        var root = serializeBranchNode(this.getView(), this.orientation);
-        var resullt = {
-            root: 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
+         */
+        var 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();
+            }
+            var root = serializeBranchNode(this.getView(), this.orientation);
+            var result = {
+                root: 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;
     };
     Gridview.prototype.dispose = function () {
         this.disposable.dispose();

package/dist/cjs/overlay/overlayRenderContainer.js

@@ -192,8 +192,12 @@ var OverlayRenderContainer = /** @class */ (function (_super) {
             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';
         };
         var observerDisposable = new lifecycle_1.MutableDisposable();
         var correctLayerPosition = function () {
@@ -231,7 +235,7 @@ var OverlayRenderContainer = /** @class */ (function (_super) {
          * 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 dnd_1.DragAndDropObserver(focusContainer, {
             onDragEnd: function (e) {

package/dist/dockview-core.js

@@ -1,6 +1,6 @@
 /**
  * dockview-core
- * @version 6.0.7
+ * @version 6.1.1
  * @link https://github.com/mathuo/dockview
  * @license MIT
  */
@@ -108,6 +108,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) => {
@@ -195,6 +252,7 @@
           this.options = options;
           this._listeners = [];
           this._disposed = false;
+          this._pauseTokens = new Set();
       }
       get event() {
           if (!this._event) {
@@ -223,6 +281,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;
           }
@@ -230,6 +293,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;
@@ -311,63 +379,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();
@@ -2443,34 +2454,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();
@@ -11412,8 +11434,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 = () => {
@@ -11449,7 +11475,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) => {