fix(inspector): prevent window overflow on inspector pane toggle

Author: J2TeamNNL

CHANGELOG.md

@@ -27,6 +27,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Installing or updating a plugin right after updating TablePro now refetches the current plugin list first, so it no longer fails against a stale cached list (the error a restart used to clear). (#1380)
 - Pressing Esc to close the Raw SQL filter suggestions, or to clear a search field, no longer also exits fullscreen. (#1403)
 - Connecting an OAuth-capable MCP client like Claude Code with an invalid or expired token now shows a clear error instead of a confusing "Invalid OAuth error response". (#1409)
+- Toggling the right inspector in a narrow editor window now updates the window minimum width from the visible split panes, so the inspector no longer squeezes content or overflows.
 
 ## [0.44.0] - 2026-05-23
 

TablePro/Core/Services/Infrastructure/MainSplitViewController.swift

@@ -40,6 +40,7 @@ internal final class MainSplitViewController: NSSplitViewController, InspectorVi
     private var detailHosting: NSHostingController<AnyView>!
     private var inspectorHosting: NSHostingController<AnyView>!
     private var hasMaterializedInspector = false
+    private var baseWindowContentMinSize: NSSize?
 
     // MARK: - Toolbar
 
@@ -169,6 +170,94 @@ internal final class MainSplitViewController: NSSplitViewController, InspectorVi
         inspectorHosting.rootView = AnyView(buildInspectorView())
     }
 
+    internal struct PaneMinimum {
+        internal let minimumThickness: CGFloat
+        internal let isCollapsed: Bool
+    }
+
+    internal static func resolvedContentMinSize(
+        base: NSSize,
+        panes: [PaneMinimum],
+        dividerThickness: CGFloat
+    ) -> NSSize {
+        let visiblePanes = panes.filter { !$0.isCollapsed }
+        let paneWidth = visiblePanes.reduce(CGFloat.zero) { partialResult, pane in
+            partialResult + max(CGFloat.zero, pane.minimumThickness)
+        }
+        let dividerCount = max(visiblePanes.count - 1, 0)
+        let resolvedWidth = max(base.width, paneWidth + (CGFloat(dividerCount) * dividerThickness))
+        return NSSize(width: resolvedWidth, height: base.height)
+    }
+
+    private func recomputeWindowMinimumSize(
+        sidebarCollapsed: Bool? = nil,
+        inspectorCollapsed: Bool? = nil
+    ) {
+        guard let window = view.window else { return }
+
+        if baseWindowContentMinSize == nil {
+            baseWindowContentMinSize = window.contentRect(forFrameRect: NSRect(origin: .zero, size: window.minSize)).size
+        }
+        guard let baseWindowContentMinSize else { return }
+
+        let resolvedMinSize = Self.resolvedContentMinSize(
+            base: baseWindowContentMinSize,
+            panes: [
+                PaneMinimum(
+                    minimumThickness: sidebarSplitItem?.minimumThickness ?? .zero,
+                    isCollapsed: sidebarCollapsed ?? (sidebarSplitItem?.isCollapsed ?? true)
+                ),
+                PaneMinimum(
+                    minimumThickness: detailSplitItem?.minimumThickness ?? .zero,
+                    isCollapsed: detailSplitItem?.isCollapsed ?? false
+                ),
+                PaneMinimum(
+                    minimumThickness: inspectorSplitItem?.minimumThickness ?? .zero,
+                    isCollapsed: inspectorCollapsed ?? (inspectorSplitItem?.isCollapsed ?? true)
+                )
+            ],
+            dividerThickness: splitView.dividerThickness
+        )
+
+        if window.contentMinSize != resolvedMinSize {
+            window.contentMinSize = resolvedMinSize
+        }
+
+        let currentContentSize = window.contentRect(forFrameRect: window.frame).size
+        guard currentContentSize.width < resolvedMinSize.width || currentContentSize.height < resolvedMinSize.height else { return }
+        window.setContentSize(NSSize(
+            width: max(currentContentSize.width, resolvedMinSize.width),
+            height: max(currentContentSize.height, resolvedMinSize.height)
+        ))
+    }
+
+    private func setCollapsed(
+        _ isCollapsed: Bool,
+        for splitItem: NSSplitViewItem?,
+        prepareWindowMinimumSize: (() -> Void)? = nil
+    ) {
+        guard let splitItem else { return }
+
+        if splitItem.isCollapsed == isCollapsed {
+            recomputeWindowMinimumSize()
+            return
+        }
+
+        prepareWindowMinimumSize?()
+
+        guard view.window?.isVisible == true else {
+            splitItem.isCollapsed = isCollapsed
+            recomputeWindowMinimumSize()
+            return
+        }
+
+        NSAnimationContext.runAnimationGroup { _ in
+            splitItem.animator().isCollapsed = isCollapsed
+        } completionHandler: { [weak self] in
+            self?.recomputeWindowMinimumSize()
+        }
+    }
+
     override func viewWillAppear() {
         super.viewWillAppear()
         guard let window = view.window else { return }
@@ -192,6 +281,7 @@ internal final class MainSplitViewController: NSSplitViewController, InspectorVi
         }
 
         installObservers()
+        recomputeWindowMinimumSize()
     }
 
     override func viewDidDisappear() {
@@ -257,11 +347,7 @@ internal final class MainSplitViewController: NSSplitViewController, InspectorVi
                 sessionState = nil
                 currentSession = nil
                 sidebarContainer.updateSidebarState(nil, windowState: nil)
-                if view.window?.isVisible == true {
-                    sidebarSplitItem.animator().isCollapsed = true
-                } else {
-                    sidebarSplitItem.isCollapsed = true
-                }
+                setCollapsed(true, for: sidebarSplitItem)
             }
             return
         }
@@ -289,10 +375,9 @@ internal final class MainSplitViewController: NSSplitViewController, InspectorVi
         }
 
         let collapseSidebar = newSession.driver == nil
-        if view.window?.isVisible == true {
-            sidebarSplitItem.animator().isCollapsed = collapseSidebar
-        } else {
-            sidebarSplitItem.isCollapsed = collapseSidebar
+        setCollapsed(collapseSidebar, for: sidebarSplitItem) { [weak self] in
+            guard !collapseSidebar else { return }
+            self?.recomputeWindowMinimumSize(sidebarCollapsed: false)
         }
         rebuildPanes()
     }
@@ -450,12 +535,14 @@ internal final class MainSplitViewController: NSSplitViewController, InspectorVi
 
     func showInspector() {
         materializeInspectorIfNeeded()
-        inspectorSplitItem?.animator().isCollapsed = false
+        setCollapsed(false, for: inspectorSplitItem) { [weak self] in
+            self?.recomputeWindowMinimumSize(inspectorCollapsed: false)
+        }
         UserDefaults.standard.set(true, forKey: Self.inspectorPresentedKey)
     }
 
     func hideInspector() {
-        inspectorSplitItem?.animator().isCollapsed = true
+        setCollapsed(true, for: inspectorSplitItem)
         UserDefaults.standard.set(false, forKey: Self.inspectorPresentedKey)
     }
 
@@ -475,9 +562,11 @@ internal final class MainSplitViewController: NSSplitViewController, InspectorVi
 
         if sidebarSplitItem?.isCollapsed == true {
             sidebarState.selectedSidebarTab = tab
-            sidebarSplitItem?.animator().isCollapsed = false
+            setCollapsed(false, for: sidebarSplitItem) { [weak self] in
+                self?.recomputeWindowMinimumSize(sidebarCollapsed: false)
+            }
         } else if sidebarState.selectedSidebarTab == tab {
-            sidebarSplitItem?.animator().isCollapsed = true
+            setCollapsed(true, for: sidebarSplitItem)
         } else {
             sidebarState.selectedSidebarTab = tab
         }

TableProTests/Core/Services/Infrastructure/MainSplitViewControllerWindowMinimumSizeTests.swift

@@ -0,0 +1,56 @@
+import AppKit
+import Testing
+
+@testable import TablePro
+
+@Suite("MainSplitViewController window minimum size")
+@MainActor
+struct MainSplitViewControllerWindowMinimumSizeTests {
+    @Test("Uses all visible pane minimums when the inspector is shown")
+    func includesVisibleInspectorPane() {
+        let size = MainSplitViewController.resolvedContentMinSize(
+            base: NSSize(width: 720, height: 448),
+            panes: [
+                .init(minimumThickness: 280, isCollapsed: false),
+                .init(minimumThickness: 400, isCollapsed: false),
+                .init(minimumThickness: 270, isCollapsed: false)
+            ],
+            dividerThickness: 2
+        )
+
+        #expect(size.width == 954)
+        #expect(size.height == 448)
+    }
+
+    @Test("Keeps the base width floor when the inspector is hidden")
+    func keepsBaseWidthWhenInspectorHidden() {
+        let size = MainSplitViewController.resolvedContentMinSize(
+            base: NSSize(width: 720, height: 448),
+            panes: [
+                .init(minimumThickness: 280, isCollapsed: false),
+                .init(minimumThickness: 400, isCollapsed: false),
+                .init(minimumThickness: 270, isCollapsed: true)
+            ],
+            dividerThickness: 2
+        )
+
+        #expect(size.width == 720)
+        #expect(size.height == 448)
+    }
+
+    @Test("Relaxes to the base width when only detail and inspector remain")
+    func keepsBaseWidthWithSidebarCollapsed() {
+        let size = MainSplitViewController.resolvedContentMinSize(
+            base: NSSize(width: 720, height: 448),
+            panes: [
+                .init(minimumThickness: 280, isCollapsed: true),
+                .init(minimumThickness: 400, isCollapsed: false),
+                .init(minimumThickness: 270, isCollapsed: false)
+            ],
+            dividerThickness: 2
+        )
+
+        #expect(size.width == 720)
+        #expect(size.height == 448)
+    }
+}