[mini.files] traverse three styles: Left, center and right. Toggle fullscreen.

[abeldekat]

mini_files_layouts.mp4

The new module, mini.input, allows the user to traverse the various styles of the view. It is mentioned in the 'Miscellaneous' section of :h MiniInput.default_key().

This is my attempt to have something similar in mini.files. The styles are "L", "C" and "R".
It's mostly for fun, but could be practical when an important piece of text is hidden by the explorer.

I admire the "custom side-scrolling layout" introduced in this discussion. That layout is, with some changes, included as style "C". Thanks @edisj for a great idea!

Since this commit, the implementation of the "custom side-scrolling layout" can be approached a bit differently. Now, when a MiniFilesWindowUpdate fires, all windows have already been processed:

• It's a bit easier to find the focused window. No need for vim.api.nvim_buf_get_name(ev.data.buf_id):match('^minifiles://%d+/(.*)$').
• Instead of working with "depth offset", it's possible to calculate the position of each col in one pass.

@echasnovski, would you accept a PR adding an extra MiniFilesExplorerUpdate event? Its data could contain the index of the focused window in state.windows. Its purpose is similar to MiniFilesWindowUpdate, but it only fires once instead of per window.

One downside of the centered layout is it being more difficult to determine that all files in a directory are shown. Perhaps it would be nice to have a footer showing a symbol when that is not the case.

The code, updated 20262508, including fullscreen toggle:

files_layout.lua

---@diagnostic disable: undefined-global
-- mini.files with layouts: left(l), center(c), right(r). Toggle full-screen.
-- See https://github.com/nvim-mini/mini.nvim/discussions/2448
-- Requirement: MiniFiles active
--[[

  -- Example usage:
  require('mini.files').setup()
  require('<this_file>').setup()
  local gr = vim.api.nvim_create_augroup('my-files-layout', {})
  vim.api.nvim_create_autocmd('User', {
    group = gr,
    pattern = 'MiniFilesBufferCreate',
    callback = function(args)
      local b = args.data.buf_id
      vim.keymap.set('n', '<C-s>', FilesLayout.traverse, { buffer = b })
      vim.keymap.set('n', 'gf', FilesLayout.toggle_full_screen, { buffer = b })
    end
  })

--]]

-- The layout to start with, and the order of traversal
local layout_current, layout_next = 'C', { L = 'C', C = 'R', R = 'L' }
-- Full screen flag, and max_windows when in full screen
local is_full_screen, full_screen_max_number = false, 3
-- If enabled and the layout is center, also center vertically
local center_vert = {
  enable = true,
  height_focus = 32,
  height = 30,
  -- Ensure that all windows have the same top row
  align_titles = false,
  -- Do not center vertically if remaining vertical space is lower than threshold
  threshold = 6,
}
-- Left and right border to take into account. Col position vs inner width
local x_margin = 2

-- Start copied from mini.files
-- Skipped the override for windows OS as I don't use windows
local fs_normalize_path = function(path) return (path:gsub('/+', '/'):gsub('(.)/$', '%1')) end
-- Centering: change first visible title when expected first window is hidden
local fit_to_width = function(text, width)
  local t_width = vim.fn.strchars(text)
  return t_width <= width and text or ('…' .. vim.fn.strcharpart(text, t_width - width + 1, width - 1))
end
local sanitize_string = function(x) return ((x or ''):gsub('\n', '<NL>'):gsub('%z', '')) end
local fs_shorten_path = function(path)
  -- Replace home directory with '~'
  path = fs_normalize_path(path)
  local home_dir = fs_normalize_path(vim.loop.os_homedir() or '~')
  return (path:gsub('^' .. vim.pesc(home_dir), '~'))
end
-- Full screen: calculate max height
local window_get_max_height = function()
  local has_tabline = vim.o.showtabline == 2 or (vim.o.showtabline == 1 and #vim.api.nvim_list_tabpages() > 1)
  local has_statusline = vim.o.laststatus > 0
  -- Remove 2 from maximum height to account for top and bottom borders
  return vim.o.lines - vim.o.cmdheight - (has_tabline and 1 or 0) - (has_statusline and 1 or 0) - 2
end
-- End copied from mini.files

local get_win_data = function(windows, idx)
  local win_id = windows[idx].win_id
  local config = vim.api.nvim_win_get_config(win_id)
  return win_id, config, config.width + x_margin
end

local center_update_first_visible_title = function(windows, idx)
  local win = windows[idx]
  local config = vim.api.nvim_win_get_config(win.win_id)
  if not type(config.title) == string then return end

  -- Copied from mini.files, see H.explorer_refresh_depth_window
  config.title = ' ' .. sanitize_string(fs_shorten_path(win.path)) .. ' '
  config.title = fit_to_width(config.title, config.width)
  vim.api.nvim_win_set_config(win.win_id, config)
end

local center_set_config = function(config, win_id, show, is_focused, vert_enable)
  if vert_enable then
    local v = center_vert
    config.height = is_focused and v.height_focus or v.height
    config.row = math.floor(0.5 * (vim.o.lines - (v.align_titles and v.height or config.height)))
  end
  config.height = not show and 1 or config.height

  local line_count = vim.api.nvim_buf_line_count(vim.api.nvim_win_get_buf(win_id))
  config.footer = { { line_count > config.height and ' · ' or '', 'MiniFilesTitle' } }
  config.footer_pos = 'right'
  vim.api.nvim_win_set_config(win_id, config)
end

local center = function(windows, idx_focused)
  local is_vert = center_vert.enable and (vim.o.lines - center_vert.height_focus >= center_vert.threshold)
  local _, _, width_focused = get_win_data(windows, idx_focused)
  if vim.o.columns <= width_focused then return end

  local col_focused = math.floor((vim.o.columns - width_focused) * 0.5)
  -- From focused to left edge
  local hidden = {}
  local col = col_focused + width_focused
  for i = idx_focused, 1, -1 do
    local win_id, config, width = get_win_data(windows, i)
    local show = i == idx_focused or col >= width

    config.col = show and col - width or col_focused
    center_set_config(config, win_id, show, i == idx_focused, is_vert)
    if not show then table.insert(hidden, i) end
    col = show and config.col or 0
  end
  if #hidden > 0 then center_update_first_visible_title(windows, hidden[1] + 1) end

  -- From focused + 1 to right edge
  col = col_focused + width_focused
  for i = idx_focused + 1, #windows do
    local win_id, config, width = get_win_data(windows, i)
    local show = (vim.o.columns - col) >= width

    config.col = show and col or col_focused
    center_set_config(config, win_id, show, false, is_vert)
    col = show and config.col + width or vim.o.columns
  end
end

local right = function(windows, _)
  -- In the default layout, the first window is aligned to the left edge of the editor
  -- Here, the last window is aligned to the right edge of the editor
  local config_last_window = vim.api.nvim_win_get_config(windows[#windows].win_id)
  local offset = (vim.o.columns - config_last_window.col) - config_last_window.width - x_margin
  for _, win in ipairs(windows) do
    local win_id = win.win_id
    local config = vim.api.nvim_win_get_config(win_id)
    config.col = offset + config.col
    config.footer = config.footer and '' or config.footer
    vim.api.nvim_win_set_config(win_id, config)
  end
end

local full_screen = function(windows, _)
  local nr_of_windows = #windows
  -- All windows have (almost) the same width
  local col_distance = math.floor(vim.o.columns / nr_of_windows)
  local height = window_get_max_height()

  local col = 0
  for i = 1, nr_of_windows do
    local win_id, config, _ = get_win_data(windows, i)
    -- Set the col to the new position
    col = (i == 1 and config.col) or (col + col_distance)

    config.col, config.height = col, height
    -- Set the width, and ensure there is no gap after last window
    config.width = (i == nr_of_windows and (vim.o.columns - col) or col_distance) - x_margin
    config.footer = config.footer and '' or config.footer
    vim.api.nvim_win_set_config(win_id, config)
  end
end

local toggle_full_screen = function()
  is_full_screen = not is_full_screen
  local max_number = MiniFiles.config.windows.max_number
  max_number = is_full_screen and full_screen_max_number or max_number
  MiniFiles.refresh({ windows = { max_number = max_number } })
end
local full_screen_reset = function() is_full_screen = false end
local full_screen_vim_enter = function(args)
  if not MiniFiles.config.options.use_as_default_explorer then return end
  if vim.fn.isdirectory(args.file) ~= 1 then return end
  vim.schedule(toggle_full_screen)
end

local ensure_layout = function(args)
  -- Built-in layout, return early
  if layout_current == 'L' and not is_full_screen then return end

  -- If there is no state, return early
  local state = MiniFiles.get_explorer_state()
  if state == nil then return end

  -- Optimize: If event is not for last window, return early
  local windows = state.windows
  if not (args.data.win_id == windows[#windows].win_id) then return end

  -- If the index of the focused window is not found, return early
  local idx_focused
  local path_focused = state.branch[state.depth_focus]
  for i, w in ipairs(windows) do
    if w.path == path_focused then idx_focused = i end
  end
  if idx_focused == nil then return end

  -- Make explorer appear full screen
  if is_full_screen then return full_screen(windows, idx_focused) end

  -- Apply center or right in all other cases
  local layout_fn = layout_current == 'C' and center or right
  layout_fn(windows, idx_focused)
end

local FilesLayout = {}
FilesLayout.setup = function()
  _G.FilesLayout = FilesLayout

  local gr = vim.api.nvim_create_augroup('FilesLayout', {})
  local au = function(event, pattern, callback, desc)
    local opts = { group = gr, pattern = pattern, callback = callback, desc = desc }
    vim.api.nvim_create_autocmd(event, opts)
  end
  au('VimEnter', '*', full_screen_vim_enter, 'Full screen on vim <dir>')
  au('User', 'MiniFilesExplorerClose', full_screen_reset, 'Reset full screen')
  au('User', 'MiniFilesWindowUpdate', ensure_layout, 'Ensure layout')
end
FilesLayout.toggle_full_screen = toggle_full_screen
FilesLayout.traverse = function()
  layout_current = layout_next[layout_current]
  MiniFiles.refresh()
end
return FilesLayout

files_layout.lua v2

---@diagnostic disable: undefined-global
-- mini.files with layouts: left(l), center(c), right(r). Toggle full-screen.
-- See https://github.com/nvim-mini/mini.nvim/discussions/2448
--
-- Requirement: MiniFiles active
-- Example usage:
--[[
  require('mini.files').setup()
  require('<this_file>').setup()
  local gr = vim.api.nvim_create_augroup('my-files-layout', {})
  vim.api.nvim_create_autocmd('User', {
    group = gr,
    pattern = 'MiniFilesBufferCreate',
    callback = function(args)
      local b = args.data.buf_id
      vim.keymap.set('n', '<C-s>', FilesLayout.traverse, { buffer = b })
      vim.keymap.set('n', 'gf', FilesLayout.toggle_full_screen, { buffer = b })
    end
  })
--]]

-- The layout to start with, and the order of traversal
local layout_current, layout_next = 'C', { L = 'C', C = 'R', R = 'L' }
-- Full screen flag, and max_windows when in full screen
local is_full_screen, full_screen_max_number = false, 3
-- If enabled and the layout is center, also center vertically
local vertical = {
  enable = true,
  height_focus = 32,
  height = 30,
  -- Ensure that all windows have the same top row
  align_horizontal = false,
  -- Do not center vertically if remaining vertical space is lower than threshold
  threshold = 6,
}
-- Left and right border to take into account. Col position vs inner width
local x_margin = 2

-- Start copied from mini.files
-- Skipped the override for windows OS as I don't use windows
local fs_normalize_path = function(path) return (path:gsub('/+', '/'):gsub('(.)/$', '%1')) end
-- Centering: change first visible title when expected first window is hidden
local fit_to_width = function(text, width)
  local t_width = vim.fn.strchars(text)
  return t_width <= width and text or ('…' .. vim.fn.strcharpart(text, t_width - width + 1, width - 1))
end
local sanitize_string = function(x) return ((x or ''):gsub('\n', '<NL>'):gsub('%z', '')) end
local fs_shorten_path = function(path)
  -- Replace home directory with '~'
  path = fs_normalize_path(path)
  local home_dir = fs_normalize_path(vim.loop.os_homedir() or '~')
  return (path:gsub('^' .. vim.pesc(home_dir), '~'))
end
-- Full screen: calculate max height
local window_get_max_height = function()
  local has_tabline = vim.o.showtabline == 2 or (vim.o.showtabline == 1 and #vim.api.nvim_list_tabpages() > 1)
  local has_statusline = vim.o.laststatus > 0
  -- Remove 2 from maximum height to account for top and bottom borders
  return vim.o.lines - vim.o.cmdheight - (has_tabline and 1 or 0) - (has_statusline and 1 or 0) - 2
end
-- End copied from mini.files

local get_win_data = function(windows, idx)
  local win_id = windows[idx].win_id
  local config = vim.api.nvim_win_get_config(win_id)
  return config.width + x_margin, config, win_id
end

local center_update_first_visible_title = function(windows, idx)
  local win = windows[idx]
  local config = vim.api.nvim_win_get_config(win.win_id)
  if not type(config.title) == string then return end

  -- Copied from mini.files, see H.explorer_refresh_depth_window
  config.title = ' ' .. sanitize_string(fs_shorten_path(win.path)) .. ' '
  config.title = fit_to_width(config.title, config.width)
  vim.api.nvim_win_set_config(win.win_id, config)
end

local center_set_config = function(config, win_id, show, is_focused, vert)
  if vert then
    local v = vertical
    config.height = is_focused and v.height_focus or v.height
    config.row = math.floor(0.5 * (vim.o.lines - (v.align_horizontal and v.height or config.height)))
  end
  config.height = not show and 1 or config.height

  if show then
    local line_count = vim.api.nvim_buf_line_count(vim.api.nvim_win_get_buf(win_id))
    config.footer = { { line_count > config.height and ' · ' or '', 'MiniFilesTitle' } }
    config.footer_pos = 'right'
  end
  vim.api.nvim_win_set_config(win_id, config)
end

local center = function(windows, idx_focused)
  local vert = vertical.enable and (vim.o.lines - vertical.height_focus >= vertical.threshold)
  local width_focused = get_win_data(windows, idx_focused)
  if vim.o.columns <= width_focused then return end

  -- Calculate left_offset. Initialize to col_focused, decrease when earlier window fits
  local col_focused = math.floor((vim.o.columns - width_focused) * 0.5)
  local left_offset, left_hidden = col_focused, {}
  for i = idx_focused - 1, 1, -1 do
    local width = get_win_data(windows, i)
    if left_hidden[1] == nil and left_offset >= width then
      left_offset = left_offset - width
    else
      table.insert(left_hidden, i)
    end
  end

  -- Apply, starting from left_offset.
  local show = false
  for i = 1, #windows do
    local width, config, win_id = get_win_data(windows, i)
    if i <= idx_focused then
      show = i == idx_focused or not vim.tbl_contains(left_hidden, i)
    else
      show = show and (vim.o.columns - left_offset) >= width
    end
    config.col = show and left_offset or col_focused
    if show then left_offset = left_offset + width end
    center_set_config(config, win_id, show, i == idx_focused, vert)
  end
  if #left_hidden > 0 then center_update_first_visible_title(windows, left_hidden[1] + 1) end
end

local right = function(windows, _)
  -- In the default layout, the first window is aligned to the left edge of the editor
  -- Here, the last window is aligned to the right edge of the editor
  local config_last_window = vim.api.nvim_win_get_config(windows[#windows].win_id)
  local offset = (vim.o.columns - config_last_window.col) - config_last_window.width - x_margin
  for _, win in ipairs(windows) do
    local win_id = win.win_id
    local config = vim.api.nvim_win_get_config(win_id)
    config.col = offset + config.col
    config.footer = config.footer and '' or config.footer
    vim.api.nvim_win_set_config(win_id, config)
  end
end

local full_screen = function(windows, _)
  local nr_of_windows = #windows
  -- All windows have (almost) the same width
  local col_distance = math.floor(vim.o.columns / nr_of_windows)
  local height = window_get_max_height()

  local col = 0
  for i = 1, nr_of_windows do
    local _, config, win_id = get_win_data(windows, i)
    -- Set the col to the new position
    col = (i == 1 and config.col) or (col + col_distance)

    config.col, config.height = col, height
    -- Set the width, and ensure there is no gap after last window
    config.width = (i == nr_of_windows and (vim.o.columns - col) or col_distance) - x_margin
    config.footer = config.footer and '' or config.footer

    -- Schedule is needed to ensure that max height is always set
    vim.schedule(function() pcall(vim.api.nvim_win_set_config, win_id, config) end)
  end
end

local toggle_full_screen = function()
  is_full_screen = not is_full_screen
  local max_number = MiniFiles.config.windows.max_number
  max_number = is_full_screen and full_screen_max_number or max_number
  MiniFiles.refresh({ windows = { max_number = max_number } })
end
local full_screen_reset = function() is_full_screen = false end
local full_screen_vim_enter = function(args)
  if not MiniFiles.config.options.use_as_default_explorer then return end
  if vim.fn.isdirectory(args.file) ~= 1 then return end
  vim.schedule(toggle_full_screen)
end

local ensure_layout = function(args)
  -- Built-in layout, return early
  if layout_current == 'L' and not is_full_screen then return end

  -- If there is no state, return early
  local state = MiniFiles.get_explorer_state()
  if state == nil then return end

  -- Optimize: If event is not for first window, return early
  local windows = state.windows
  if not (args.data.win_id == windows[1].win_id) then return end

  -- If the index of the focused window is not found, return early
  local idx_focused
  local path_focused = state.branch[state.depth_focus]
  for i, w in ipairs(windows) do
    if w.path == path_focused then idx_focused = i end
  end
  if idx_focused == nil then return end

  -- Make explorer appear full screen
  if is_full_screen then return full_screen(windows, idx_focused) end

  -- Apply center or right in all other cases
  local layout_fn = layout_current == 'C' and center or right
  layout_fn(windows, idx_focused)
end

local FilesLayout = {}
FilesLayout.setup = function()
  _G.FilesLayout = FilesLayout

  local gr = vim.api.nvim_create_augroup('FilesLayout', {})
  local au = function(event, pattern, callback, desc)
    local opts = { group = gr, pattern = pattern, callback = callback, desc = desc }
    vim.api.nvim_create_autocmd(event, opts)
  end
  au('VimEnter', '*', full_screen_vim_enter, 'Full screen on vim <dir>')
  au('User', 'MiniFilesExplorerClose', full_screen_reset, 'Reset full screen')
  au('User', 'MiniFilesWindowUpdate', ensure_layout, 'Ensure layout')
end
FilesLayout.toggle_full_screen = toggle_full_screen
FilesLayout.traverse = function()
  layout_current = layout_next[layout_current]
  MiniFiles.refresh()
end
return FilesLayout

The code as a separate internal module in my config: akextra.files_layout

A suggestion of the "center" layout when added to mini.files itself:

mini.files.lua

-- Renamed H.compute_visible_depth_range(explorer, explorer.opts):
H.compute_visible = function(explorer, opts)
-- Some trivial changes...
end

-- New function to center:
H.compute_visible_centered = function(explorer, opts)
  -- Compute maximum number of windows possible to fit in current Neovim width
  -- Add 2 to widths to take into account width of left and right borders
  local x_margin = 2
  local width_focus, width_nofocus = opts.windows.width_focus + x_margin, opts.windows.width_nofocus + x_margin
  local depth_focus, branch_depth, branch = explorer.depth_focus, #explorer.branch, explorer.branch
  local res = { from = depth_focus, to = depth_focus, x_initial_offset = 0, x_margin = x_margin }

  if vim.o.columns <= width_focus then return res end

  local pos_focus = math.floor((vim.o.columns - width_focus) * 0.5)
  res.x_initial_offset = pos_focus

  for i = depth_focus - 1, 1, -1 do
    if not (branch[i] and res.x_initial_offset >= width_nofocus) then break end
    res.from = res.from - 1
    res.x_initial_offset = res.x_initial_offset - width_nofocus
  end

  local has_preview = explorer.opts.windows.preview and depth_focus < branch_depth
  local width_preview = opts.windows.width_preview + x_margin
  local right_remaining = vim.o.columns - (pos_focus + width_focus)

  for i = depth_focus + 1, branch_depth do
    local width = has_preview and i == depth_focus + 1 and width_preview or width_nofocus

    if not (branch[i] and right_remaining >= width) then break end
    res.to = res.to + 1
    right_remaining = right_remaining - width
  end

  return res
end

-- Added: x_margin to support layouts
H.explorer_refresh = function(explorer, opts)

    -- Existing code....

    -- Compute depth range which is possible to show in current Neovim width
    local to_show = explorer.opts.windows.style == 'C' and H.compute_visible_centered(explorer, explorer.opts)
    or H.compute_visible(explorer, explorer.opts)

    -- Refresh window for every target depth keeping track of position column
    local cur_win_col, cur_win_count, opened_windows = to_show.x_initial_offset, 0, {}
    for depth = to_show.from, to_show.to do
        cur_win_count = cur_win_count + 1
        local cur_width, was_opened = H.explorer_refresh_depth_window(explorer, depth, cur_win_count, cur_win_col)
        opened_windows[explorer.windows[cur_win_count]] = was_opened

        -- Add x_margin to account for left and right borders
        cur_win_col = cur_win_col + cur_width + to_show.x_margin
    end

    -- More existing code....
end

[echasnovski]

@echasnovski, would you accept a PR adding an extra MiniFilesExplorerUpdate event? Its data could contain the index of the focused window in state.windows. Its purpose is similar to MiniFilesWindowUpdate, but it only fires once instead of per window.

I don't immediately like the idea of this type of event. Probably mostly because it leads to a duplication of events (if always essentially triggered after the last MiniFilesWindowUpdate). Also because there are plans to make the whole layout management more first class (like with MiniFiles.config.layout function).

So it is not a "no", but "I don't think I like this at the moment".

[abeldekat]

I updated the code a little bit.

If a window cannot be shown, I am using the col of the focused window, setting the height to 1. As such, I do not need to also set a zindex.

If a window cannot show all content, I am adding a footer displaying the number of lines in the buffer:

  -- Added to center_set_config:

  local line_count = vim.api.nvim_buf_line_count(vim.api.nvim_win_get_buf(win_id))
  config.footer = { { line_count > config.height and ' · ' or '', 'MiniFilesTitle' } }
  config.footer_pos = 'right'

[edisj]

this is a neat idea... I wouldn't use a "L" or "R" style, but it got me thinking what about a "F" (fullscreen) toggle, where the open explorer windows fill up the whole view? It would be useful when opening mini.files as a netrw replacement

[abeldekat]

Interesting!

[abeldekat]

On MiniFilesWindowUpdate, we know for sure that all state.windows 'fit' from left to right given their default widths. The algorithm would only need to increase each window by a certain factor, and maximize the height.

[abeldekat]

mini_files_full_screen.mp4

MiniFiles with full-screen toggle. Also uses full screen when neovim is started with a directory.

I "stubbed" the C and R layouts to fallback to L, in order to focus on the full-screen code.

What do you think? Currently, the widths are equalized. The focused window could be more prominent.

The code

---@diagnostic disable: undefined-global
local layout_current, layout_next = 'L', { L = 'R', R = 'L' }
local is_full_screen = false
local full_screen_max_number = 3 -- math.huge

-- Left and right border to take into account. Col position vs inner width
local x_margin = 2

-- Copied from mini.files to support full screen
local window_get_max_height = function()
  local has_tabline = vim.o.showtabline == 2 or (vim.o.showtabline == 1 and #vim.api.nvim_list_tabpages() > 1)
  local has_statusline = vim.o.laststatus > 0
  -- Remove 2 from maximum height to account for top and bottom borders
  return vim.o.lines - vim.o.cmdheight - (has_tabline and 1 or 0) - (has_statusline and 1 or 0) - 2
end
-- End copied from mini.files

local get_win_data = function(windows, idx)
  local win_id = windows[idx].win_id
  local config = vim.api.nvim_win_get_config(win_id)
  return win_id, config, config.width + x_margin
end

local center = function(windows, idx_focused)
  -- Dummy for full screen demo. Fall back to 'L'
end
local right = function(windows, _) -- idx_focused
  -- Dummy for full screen demo. Fall back to 'L'
end

local full_screen = function(windows, _)
  local nr_of_windows = #windows
  -- All windows have max_height
  local height = window_get_max_height()
  -- All windows have (almost) the same width
  local col_distance = math.floor(vim.o.columns / nr_of_windows)

  local col = 0
  for i = 1, nr_of_windows do
    local win_id, config, _ = get_win_data(windows, i)
    -- Set the col to the new position
    col = (i == 1 and config.col) or (col + col_distance)

    config.col, config.height = col, height
    -- Set the width, and ensure there is no gap after last window
    config.width = (i == nr_of_windows and (vim.o.columns - col) or col_distance) - x_margin
    vim.api.nvim_win_set_config(win_id, config)
  end
end

require('mini.files').setup({ windows = { preview = true } })

local gr = vim.api.nvim_create_augroup('custom-config', {})
local new_autocmd = function(event, pattern, callback, desc)
  local opts = { group = gr, pattern = pattern, callback = callback, desc = desc }
  vim.api.nvim_create_autocmd(event, opts)
end

local full_screen_toggle = function()
  is_full_screen = not is_full_screen
  local max_number = MiniFiles.config.windows.max_number
  max_number = is_full_screen and full_screen_max_number or max_number
  MiniFiles.refresh({ windows = { max_number = max_number } })
end

local full_screen_reset = function() is_full_screen = false end

local full_screen_vim_enter = function(args)
  if vim.fn.isdirectory(args.file) ~= 1 then return end
  vim.schedule(full_screen_toggle)
end

local add_buffer_mappings = function(args)
  local traverse_layout = function()
    layout_current = layout_next[layout_current]
    MiniFiles.refresh()
  end
  vim.keymap.set('n', '<C-s>', traverse_layout, { buffer = args.data.buf_id, desc = 'Traverse layout' })
  vim.keymap.set('n', 'gf', full_screen_toggle, { buffer = args.data.buf_id, desc = 'Toggle full screen' })
end

local ensure_layout = function(args)
  -- Built-in layout, return early
  if layout_current == 'L' and not is_full_screen then return end

  -- If there is no state, return early
  local state = MiniFiles.get_explorer_state()
  if state == nil then return end

  -- If event is not for focused window, return early
  local focused_path = state.branch[state.depth_focus]
  local idx_focused
  for i, win in ipairs(state.windows) do
    if win.path == focused_path and win.win_id == args.data.win_id then idx_focused = i end
  end
  if idx_focused == nil then return end

  -- Make explorer appear full screen
  if is_full_screen then return full_screen(state.windows, idx_focused) end

  -- Apply center or right in all other cases
  local layout_fn = layout_current == 'C' and center or right
  layout_fn(state.windows, idx_focused)
end

new_autocmd('User', 'MiniFilesExplorerClose', full_screen_reset, 'Reset full screen')
new_autocmd('VimEnter', '*', full_screen_vim_enter, 'Full screen on vim <dir>')
new_autocmd('User', 'MiniFilesBufferCreate', add_buffer_mappings, 'Add buffer mappings')
new_autocmd('User', 'MiniFilesWindowUpdate', ensure_layout, 'Ensure layout')

[abeldekat]

I updated the main code of this discussion to also include the fullscreen toggle.

[edisj]

sorry I forgot to get back to you @abeldekat, it looks great!

[abeldekat]

I updated the code to v2