dockview-core 6.0.7 → 6.2.1

package/dist/dockview-core.noStyle.js

@@ -1,6 +1,6 @@
 /**
  * dockview-core
- * @version 6.0.7
+ * @version 6.2.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) => {
@@ -11513,6 +11539,25 @@
         return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
     };
 
+    /**
+     * Reject popout URLs that aren't same-origin http(s). Blocks `javascript:`,
+     * `data:`, `blob:`, `vbscript:`, and cross-origin URLs that would otherwise
+     * execute in a context the browser still associates with the opener via
+     * `window.opener`.
+     */
+    function assertSameOriginPopoutUrl(url) {
+        let resolved;
+        try {
+            resolved = new URL(url, window.location.href);
+        }
+        catch (_a) {
+            throw new Error(`dockview: invalid popout URL: ${url}`);
+        }
+        const protocolOk = resolved.protocol === 'http:' || resolved.protocol === 'https:';
+        if (!protocolOk || resolved.origin !== window.location.origin) {
+            throw new Error(`dockview: popout URL must be same-origin http(s); got: ${url}`);
+        }
+    }
     class PopoutWindow extends CompositeDisposable {
         get window() {
             var _a, _b;
@@ -11564,6 +11609,7 @@
                     throw new Error('instance of popout window is already open');
                 }
                 const url = `${this.options.url}`;
+                assertSameOriginPopoutUrl(url);
                 const features = Object.entries({
                     top: this.options.top,
                     left: this.options.left,

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/esm/popoutWindow.d.ts

@@ -11,6 +11,13 @@ export type PopoutWindowOptions = {
         window: Window;
     }) => void;
 } & Box;
+/**
+ * Reject popout URLs that aren't same-origin http(s). Blocks `javascript:`,
+ * `data:`, `blob:`, `vbscript:`, and cross-origin URLs that would otherwise
+ * execute in a context the browser still associates with the opener via
+ * `window.opener`.
+ */
+export declare function assertSameOriginPopoutUrl(url: string): void;
 export declare class PopoutWindow extends CompositeDisposable {
     private readonly target;
     private readonly className;

package/dist/esm/popoutWindow.js

@@ -10,6 +10,25 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { addStyles } from './dom';
 import { Emitter, addDisposableListener } from './events';
 import { CompositeDisposable, Disposable } from './lifecycle';
+/**
+ * Reject popout URLs that aren't same-origin http(s). Blocks `javascript:`,
+ * `data:`, `blob:`, `vbscript:`, and cross-origin URLs that would otherwise
+ * execute in a context the browser still associates with the opener via
+ * `window.opener`.
+ */
+export function assertSameOriginPopoutUrl(url) {
+    let resolved;
+    try {
+        resolved = new URL(url, window.location.href);
+    }
+    catch (_a) {
+        throw new Error(`dockview: invalid popout URL: ${url}`);
+    }
+    const protocolOk = resolved.protocol === 'http:' || resolved.protocol === 'https:';
+    if (!protocolOk || resolved.origin !== window.location.origin) {
+        throw new Error(`dockview: popout URL must be same-origin http(s); got: ${url}`);
+    }
+}
 export class PopoutWindow extends CompositeDisposable {
     get window() {
         var _a, _b;
@@ -61,6 +80,7 @@ export class PopoutWindow extends CompositeDisposable {
                 throw new Error('instance of popout window is already open');
             }
             const url = `${this.options.url}`;
+            assertSameOriginPopoutUrl(url);
             const features = Object.entries({
                 top: this.options.top,
                 left: this.options.left,