feat(layout)!: use size instead of height and width (#116)

Author: igorlfs

docs/src/routes/configuration/+page.md

@@ -84,10 +84,10 @@ return {
         },
     },
     windows = {
-        height = 0.25,
+        size = 0.25,
         position = "below",
         terminal = {
-            width = 0.5,
+            size = 0.5,
             position = "left",
             -- List of debug adapters for which the terminal should be ALWAYS hidden
             hide = {},

docs/src/routes/dynamic-layout/+page.md

@@ -3,7 +3,7 @@ title: Dynamic Layout
 category: Recipes
 ---
 
-You can assign different positions to `nvim-dap-view`'s windows using functions.
+You can assign different positions and sizes to `nvim-dap-view`'s windows using functions.
 
 ## Example
 
@@ -12,20 +12,38 @@ When there's a single window in the current tab, you can use a _vertical_ layout
 ```lua
 return {
     windows = {
-        position = function()
-            return vim.tbl_count(vim.iter(vim.api.nvim_tabpage_list_wins(0))
+        -- `prev` is the last used position, might be nil
+        position = function(prev)
+            local wins = api.nvim_tabpage_list_wins(0)
+
+            -- Restores previous position if terminal is visible
+            if
+                vim.iter(wins):find(function(win)
+                    return vim.w[win].dapview_win_term
+                end)
+            then
+                return prev
+            end
+
+            return vim.tbl_count(vim.iter(wins)
                 :filter(function(win)
-                    local buf = vim.api.nvim_win_get_buf(win)
-                    -- extui has some funky windows
-                    return vim.bo[buf].buftype == ""
+                    local buf = api.nvim_win_get_buf(win)
+                    local valid_buftype =
+                        vim.tbl_contains({ "", "help", "prompt", "quickfix", "terminal" }, vim.bo[buf].buftype)
+                    local dapview_win = vim.w[win].dapview_win or vim.w[win].dapview_win_term
+                    return valid_buftype and not dapview_win
                 end)
                 :totable()) > 1 and "below" or "right"
         end,
+        size = function(pos)
+            return pos == "below" and 0.25 or 0.5
+        end,
         terminal = {
             -- `pos` is the position for the regular window
             position = function(pos)
                 return pos == "below" and "right" or "below"
             end,
+            size = 0.5,
         },
     },
 }

lua/dap-view/actions.lua

@@ -13,6 +13,7 @@ local traversal = require("dap-view.tree.traversal")
 local M = {}
 
 local api = vim.api
+local go = vim.go
 
 ---@param hide_terminal? boolean
 M.toggle = function(hide_terminal)
@@ -88,30 +89,82 @@ M.open = function(hide_terminal)
     local term_config = windows_config.terminal
 
     local position = windows_config.position
-    local win_pos = (type(position) == "function" and position()) or (type(position) == "string" and position)
+    local win_pos = (type(position) == "function" and position(state.win_pos))
+        or (type(position) == "string" and position)
 
     ---@cast win_pos dapview.Position
 
+    state.win_pos = win_pos
+
     local term_position_ = term_config.position
     local term_win_pos = (type(term_position_) == "function" and term_position_(win_pos))
         or (type(term_position_) == "string" and term_position_)
 
     ---@cast term_win_pos dapview.Position
 
-    local term_position = util.inverted_directions[term_win_pos]
+    local inv_term_position = util.inverted_directions[term_win_pos]
 
     local anchor_win = windows_config.anchor and windows_config.anchor()
     local is_anchor_win_valid = util.is_win_valid(anchor_win)
 
+    local size_ = windows_config.size
+    local size__ = (type(size_) == "function" and size_(win_pos)) or size_
+
+    ---@cast size__ number
+
+    local is_vertical = win_pos == "above" or win_pos == "below"
+
+    local term_size_ = term_config.size
+    local term_size__ = (type(term_size_) == "function" and term_size_(inv_term_position)) or term_size_
+
+    ---@cast term_size__ number
+
+    local term_is_vertical = term_win_pos == "above" or term_win_pos == "below"
+
+    local is_win_valid = is_anchor_win_valid or is_term_win_valid
+
+    local size = size__ < 1 and math.floor((is_vertical and go.lines or go.columns) * size__) or size__
+
+    local shared_split = term_is_vertical == is_vertical
+
+    local winfix_setting = is_vertical and "winfixheight" or "winfixwidth"
+
+    -- Temporarily disable fixed size
+    -- If the window exists, it's using the space of both
+    -- Do not touch anchor because we don't own it
+    if is_term_win_valid and shared_split then
+        vim.wo[state.term_winnr][winfix_setting] = false
+
+        -- `size` is already an integer at this point
+        if term_size__ < 1 then
+            term_size__ = term_size__ * size
+        end
+    end
+
+    local go_max = term_is_vertical and go.lines or go.columns
+
+    local term_size = term_size__ < 1 and math.floor(go_max * term_size__) or math.floor(term_size__)
+
     local winnr = api.nvim_open_win(bufnr, false, {
-        split = (is_anchor_win_valid or is_term_win_valid) and term_position or win_pos,
+        split = is_win_valid and inv_term_position or win_pos,
         win = is_anchor_win_valid and anchor_win or is_term_win_valid and term_winnr or -1,
-        height = windows_config.height < 1 and math.floor(vim.go.lines * windows_config.height)
-            or windows_config.height,
-        width = term_config.width < 1 and math.floor(vim.go.columns * (1 - term_config.width))
-            or math.floor(vim.go.columns - term_config.width),
+        -- Oh lord
+        height = (
+            is_win_valid and (term_is_vertical and ((is_vertical and size or go.lines) - term_size) or size)
+            or (is_vertical and size or nil)
+        ),
+        width = (
+            is_win_valid
+                and (not term_is_vertical and ((not is_vertical and size or go.columns) - term_size) or size)
+            or (not is_vertical and size or nil)
+        ),
     })
 
+    -- Restore fixed size
+    if is_term_win_valid and shared_split then
+        vim.wo[state.term_winnr][winfix_setting] = true
+    end
+
     assert(winnr ~= 0, "Failed to create nvim-dap-view window")
 
     state.winnr = winnr

lua/dap-view/autocmds.lua

@@ -9,10 +9,26 @@ local winbar = require("dap-view.options.winbar")
 
 local api = vim.api
 
+api.nvim_create_autocmd("WinClosed", {
+    callback = function(args)
+        local w = vim.w[tonumber(args.file)]
+
+        -- Resize main window on term close to
+        if w.dapview_win_term and util.is_win_valid(state.winnr) then
+            require("dap-view.util.window").resize(state.winnr)
+        end
+
+        -- Similarly for closing main
+        if w.dapview_win and util.is_win_valid(state.term_winnr) then
+            require("dap-view.util.window").resize(state.term_winnr)
+        end
+    end,
+})
+
 api.nvim_create_autocmd({ "WinClosed", "WinNew" }, {
     callback = function()
         vim.schedule(function()
-            if state.winnr ~= nil then
+            if util.is_win_valid(state.winnr) then
                 winbar.refresh_winbar()
             end
         end)

lua/dap-view/config.lua

@@ -12,14 +12,14 @@ local M = {}
 
 ---@class dapview.TerminalConfig
 ---@field hide string[] List of adapters for which the terminal should be hidden
----@field position dapview.Position|fun(position: dapview.Position): dapview.Position
----@field width number If > 1 number of columns, else percentage the terminal window should use
+---@field position dapview.Position|fun(position: dapview.Position): dapview.Position Can be a function, receiving the main window's position as its argument
+---@field size number|fun(position: dapview.Position): number Size of the terminal window's split. Either a number, where if > 1 it's the absolute size, or else the percentage. Can also be a function, receiving the position and returning a number, that then follows the same logic.
 ---@field start_hidden boolean Don't show the terminal window when starting a new session
 
 ---@class dapview.WindowsConfig
----@field height number If > 1 number of lines, else percentage the windows should use
----@field position dapview.Position|fun(): dapview.Position
----@field anchor? fun(): integer? Function that returns a window number for the main nvim-dap-view window to follow
+---@field size number|fun(position: dapview.Position): number Size of the main window's split. Either a number, where if > 1 it's the absolute size, or else the percentage. Can also be a function, receiving the position and returning a number, that then follows the same logic.
+---@field position dapview.Position|fun(prev_position?: dapview.Position): dapview.Position Position of the top level split. Can also be a function, receiving its previous position (if any) as its argument.
+---@field anchor? fun(): integer? Function that returns a window number for the main nvim-dap-view window to treat as the terminal window
 ---@field terminal dapview.TerminalConfig
 
 ---@alias dapview.DefaultIcons dapview.DefaultButton | "pause"
@@ -148,10 +148,10 @@ M.config = {
         },
     },
     windows = {
-        height = 0.25,
+        size = 0.25,
         position = "below",
         terminal = {
-            width = 0.5,
+            size = 0.5,
             position = "left",
             hide = {},
             start_hidden = true,

lua/dap-view/console/view.lua

@@ -11,6 +11,7 @@ local scroll = require("dap-view.console.scroll")
 local M = {}
 
 local api = vim.api
+local go = vim.go
 
 ---Workaround to fetch the term_buf for sessions created via `startDebugging` from js-debug-adapter
 ---Only the top-level session owns the buf, children need to traverse parents to get it
@@ -112,24 +113,73 @@ M.open_term_buf_win = function()
         local is_win_valid = util.is_win_valid(state.winnr)
 
         local position = windows_config.position
-        local win_pos = (type(position) == "function" and position()) or (type(position) == "string" and position)
+        local win_pos = (type(position) == "function" and position(state.win_pos))
+            or (type(position) == "string" and position)
 
         ---@cast win_pos dapview.Position
 
+        state.win_pos = win_pos
+
         local term_position = term_config.position
         local term_win_pos = (type(term_position) == "function" and term_position(win_pos))
             or (type(term_position) == "string" and term_position)
 
         ---@cast term_win_pos dapview.Position
 
+        local size_ = windows_config.size
+        local size__ = (type(size_) == "function" and size_(win_pos)) or size_
+
+        ---@cast size__ number
+
+        local is_vertical = win_pos == "above" or win_pos == "below"
+
+        local go_max = is_vertical and go.lines or go.columns
+
+        local size = size__ < 1 and math.floor(go_max * size__) or size__
+
+        local term_size_ = term_config.size
+        local term_size__ = (type(term_size_) == "function" and term_size_(term_win_pos)) or term_size_
+
+        ---@cast term_size__ number
+
+        local term_is_vertical = term_win_pos == "above" or term_win_pos == "below"
+
+        local shared_split = term_is_vertical == is_vertical
+
+        local winfix_setting = is_vertical and "winfixheight" or "winfixwidth"
+
+        -- Temporarily disable fixed size
+        -- If the window exists, it's using the space of both
+        if is_win_valid and shared_split then
+            vim.wo[state.winnr][winfix_setting] = false
+
+            -- `size` is already an integer at this point
+            if term_size__ < 1 then
+                term_size__ = term_size__ * size
+            end
+        end
+
+        local term_go_max = term_is_vertical and go.lines or go.columns
+
+        local term_size = math.floor(term_size__ < 1 and term_go_max * term_size__ or term_size__)
+
         local term_winnr = api.nvim_open_win(term_bufnr, false, {
             split = is_win_valid and term_win_pos or win_pos,
             win = is_win_valid and state.winnr or -1,
-            height = windows_config.height < 1 and math.floor(vim.go.lines * windows_config.height)
-                or windows_config.height,
-            width = term_config.width < 1 and math.floor(vim.go.columns * term_config.width) or term_config.width,
+            -- If there is a valid main window, we just need to apply whatever the term config says
+            -- Which means that we'd only set the height for vertical terms
+            -- Else, we need to create the window as if it occupied the space of both windows
+            -- Which means that, we'd only set the height if the main window is a vertical split
+            height = (is_win_valid and (term_is_vertical and term_size or nil)) or (is_vertical and size or nil),
+            -- Symmetric for width
+            width = (is_win_valid and (not term_is_vertical and term_size or nil) or (not is_vertical and size or nil)),
         })
 
+        -- Restore fixed size
+        if is_win_valid and shared_split then
+            vim.wo[state.winnr][winfix_setting] = true
+        end
+
         -- Track the state of the last term win, so it can be closed later if becomes a leftover window
         if state.term_winnr and term_winnr ~= state.term_winnr then
             state.last_term_winnr = state.term_winnr

lua/dap-view/setup/validate/windows.lua

@@ -5,7 +5,7 @@ local validate = require("dap-view.setup.validate.util").validate
 ---@param config dapview.WindowsConfig
 function M.validate(config)
     validate("windows", {
-        height = { config.height, "number" },
+        size = { config.size, { "number", "function" } },
         position = { config.position, { "string", "function" } },
         terminal = { config.terminal, "table" },
         anchor = { config.anchor, { "function", "nil" } },
@@ -14,7 +14,7 @@ function M.validate(config)
     validate("windows.terminal", {
         position = { config.terminal.position, { "string", "function" } },
         hide = { config.terminal.hide, "table" },
-        width = { config.terminal.width, "number" },
+        size = { config.terminal.size, { "number", "function" } },
         start_hidden = { config.terminal.start_hidden, "boolean" },
     }, config.terminal)
 end

lua/dap-view/state.lua

@@ -45,6 +45,7 @@
 ---@field watched_expressions table<string, dapview.ExpressionView>
 ---@field expr_count integer
 ---@field cur_pos table<dapview.DefaultSection,integer?>
+---@field win_pos? dapview.Position
 local M = {
     expr_count = 0,
     threads_filter = "",

lua/dap-view/util/init.lua

@@ -3,10 +3,10 @@ local M = {}
 local api = vim.api
 
 M.inverted_directions = {
-    ["above"] = "below",
-    ["below"] = "above",
-    ["right"] = "left",
-    ["left"] = "right",
+    above = "below",
+    below = "above",
+    right = "left",
+    left = "right",
 }
 
 ---@param bufnr? integer

lua/dap-view/util/window.lua

@@ -1,3 +1,6 @@
+local state = require("dap-view.state")
+local setup = require("dap-view.setup")
+
 local api = vim.api
 
 local M = {}
@@ -26,4 +29,35 @@ M.fetch_window = function(opts)
     end
 end
 
+---Restores the configured size for a given window
+---@param winnr integer
+M.resize = function(winnr)
+    local wo = vim.wo[winnr]
+
+    local size_ = setup.config.windows.size
+    local size__ = ((type(size_) == "function" and size_(state.win_pos)) or size_)
+
+    ---@cast size__ number
+
+    if wo.winfixheight then
+        wo.winfixheight = false
+
+        local size = math.floor(size__ < 1 and size__ * vim.go.lines or size__)
+
+        api.nvim_win_set_height(state.term_winnr, size)
+
+        wo.winfixheight = true
+    end
+
+    if wo.winfixwidth then
+        wo.winfixwidth = false
+
+        local size = math.floor(size__ < 1 and size__ * vim.go.columns or size__)
+
+        api.nvim_win_set_width(state.term_winnr, size)
+
+        wo.winfixwidth = true
+    end
+end
+
 return M