[mini.extra] Better colorschemes picker

[drowning-cat]

Related: #951

Features:

• Persistent colorscheme
• Live preview without <Tab> (see comment)
• Switch vim.o.background with <C-o>
• Jump to the initial colorscheme with <C-0>

colors.mp4

-- Load

vim.pack.add({ { src = "https://github.com/nvim-mini/mini.nvim" } })

require("mini.extra").setup()
require("mini.pick").setup()

vim.keymap.set("n", "<space>sc", ":Pick colorschemes<Enter>", { desc = "Search colors" })

-- Persistent colorscheme

-- IMPORTANT!
-- WARN: Call this after the colorscheme loads.
-- NOTE: Load the colorscheme like this only if using `vim.pack`.
--       You can also try `vim.schedule` or the `LazyDone` event.
local set_colorscheme = function(bg, name)
  return pcall(function()
    vim.o.background = bg
    vim.cmd.colorscheme(name)
  end)
end
vim.cmd.rshada()
if not set_colorscheme(vim.g.COLORS_BG, vim.g.COLORS_NAME) then
  set_colorscheme("dark", "default")
end

vim.api.nvim_create_autocmd("ColorScheme", {
  group = vim.api.nvim_create_augroup("save_colors", { clear = true }),
  callback = function()
    vim.g.COLORS_NAME = vim.g.colors_name
    vim.g.COLORS_BG = vim.o.background
    -- NOTE: Let Neovim save the shada file on exit.
    --       Picker preview can cause sync issues while the picker is open.
  end,
})

-- Pick `colorschemes`

MiniPick.registry.colorschemes = function(local_opts, opts)
  local aug = vim.api.nvim_create_augroup("pick_colors", { clear = true })
  local cl = vim.g.colors_name or "default"
  local bg = vim.o.background or "dark"
  local fake_buf = vim.api.nvim_create_buf(false, true)

  local preview = function(colors)
    local matches = MiniPick.get_picker_matches()
    if matches then
      local item = colors or matches.current
      local func = MiniPick.get_picker_opts().source.preview
      -- BUG: Issues if two configurations share `packpath` but load different colorschemes
      pcall(func, fake_buf, item)
      -- NOTE: Preview function overrides `vim.o.background`
      vim.o.background = bg
    end
  end

  -- NOTE: Move the cursor to the initial colorscheme
  local match_current = function()
    local matches = MiniPick.get_picker_matches()
    local current = vim.iter(matches.all_inds):find(function(i)
      return cl == matches.all[i]
    end)
    if current then
      MiniPick.set_picker_match_inds({ current }, "current")
    end
  end

  -- NOTE: We assume the next picker is `colorschemes`

  vim.api.nvim_create_autocmd("User", {
    pattern = "MiniPickStart",
    group = aug,
    callback = match_current,
  })
  -- NOTE: Also runs at the start
  vim.api.nvim_create_autocmd("User", {
    pattern = "MiniPickMatch",
    group = aug,
    callback = vim.schedule_wrap(preview),
  })
  vim.api.nvim_create_autocmd("User", {
    pattern = "MiniPickStop",
    group = aug,
    once = true,
    callback = function()
      vim.api.nvim_clear_autocmds({ group = aug })
      vim.api.nvim_buf_delete(fake_buf, { unload = true })
    end,
  })

  local on_move = vim.schedule_wrap(preview)

  local remap_move = function(char, keys)
    return {
      char = char,
      func = function()
        -- ~~vim.api.nvim_feedkeys(vim.keycode(keys), "n", false)~~ -- NOTE: Sync
        vim.api.nvim_input(keys)
        on_move()
      end,
    }
  end

  return MiniExtra.pickers.colorschemes(
    local_opts,
    vim.tbl_deep_extend("keep", opts or {}, {
      source = {
        choose = function(item)
          vim.cmd.colorscheme(item)
          -- NOTE: Save colorscheme in a session-persistent vars
          vim.g.COLORS_NAME = vim.g.colors_name
          vim.g.COLORS_BG = vim.o.background
          vim.cmd.wshada()
        end,
      },
      mappings = {
        -- NOTE: No `MiniPick.default_action(...)`
        move_start = "<C-Home>",
        scroll_down = "<PageDown>",
        scroll_up = "<PageUp>",
        move_down_alt = remap_move("<C-n>", "<Down>"),
        move_up_alt = remap_move("<C-p>", "<Up>"),
        move_start_alt = remap_move("<C-g>", "<C-Home>"),
        scroll_down_alt = remap_move("<C-f>", "<PageDown>"),
        scroll_up_alt = remap_move("<C-b>", "<PageUp>"),
        match_current = {
          char = "<C-0>",
          func = function()
            match_current()
            on_move()
          end,
        },
        change_bg = {
          char = "<C-o>",
          func = function()
            bg = vim.o.background == "dark" and "light" or "dark"
            vim.o.background = bg
          end,
        },
      },
    })
  )
end

[echasnovski]

Thanks for sharing!

MiniExtra.pickers.colorschemes() also has "live preview". Press <Tab> to actually preview and navigate through currently matched items.

[drowning-cat]

Now, it feels kind of crazy that I did all of this just to avoid pressing one button. I knew that beforehand, but it's a bit inconvenient for me because I don’t see the other colorscheme names.

[drowning-cat]

I have a question. I want to change the name of the picker without affecting the current view or the selected item. When I use MiniPick.set_picker_opts, it resets the current position. So, I try to restore the position with set_picker_match_inds. As a result, there’s a brief flash where the cursor jumps first with set_picker_opts and then back with set_picker_match_inds (probably due to a redraw), and sometimes the scroll position changes as well. Is there any way to fix this quirk?

vim.keymap.set("n", "<space>sc", ":Pick colorschemes<Enter>", { desc = "Search colors" })

MiniPick.registry.colorschemes = function(local_opts, opts)
  return MiniExtra.pickers.colorschemes(
    local_opts,
    vim.tbl_deep_extend("keep", opts or {}, {
      mappings = {
        change_name = {
          char = "<F1>",
          func = function()
            local matches = MiniPick.get_picker_matches()
            MiniPick.set_picker_opts({ source = { name = "Colorschemes (" .. "Hello" .. ")" } })
            MiniPick.set_picker_match_inds({ matches.current_ind }, "current")
          end,
        },
      },
    })
  )
end

The actual use case for me is to change vim.o.background with a key inside the colorschemes picker. So it would be nice to have an indication of whether the currently used variant is dark or light. This would also help show whether the colorscheme actually changes with the background option, since some colorschemes don’t support that behavior.

[echasnovski]

@drowning-cat, as I can not reliably reproduce the flickering, could you please apply the following patch and see if the flickering is still there? The patch:

diff --git a/lua/mini/pick.lua b/lua/mini/pick.lua
index 9fb2b56a..ba23d587 100644
--- a/lua/mini/pick.lua
+++ b/lua/mini/pick.lua
@@ -1799,7 +1799,8 @@ MiniPick.set_picker_opts = function(opts)
   picker.opts = vim.tbl_deep_extend('force', picker.opts, opts or {})
   picker.action_keys = H.normalize_mappings(picker.opts.mappings)
   if cur_cwd ~= picker.opts.source.cwd then H.win_set_cwd(picker.windows.main, picker.opts.source.cwd) end
-  H.picker_update(picker, true, true)
+  local do_match = ((opts or {}).source or {}).match ~= nil
+  H.picker_update(picker, do_match, true)
 end
 
 --- Set target window for active picker

---

The centering of the current item is the result of executing the equivalent of the MiniPick.refresh(), which updates the window. This has the side effect of repositioning the current item in the visible area.

In theory it should be possible to pinpoint the exact conditions of when to not do that specifically in set_picker_opts(), but seems to only (visibly) complicate the code while not being that much useful. If there are more serious problems that come with that, it might be worth to reconsider. But not for now.

[drowning-cat]

Yes, the patch fixes the issue. It is better to show:

pick-bug.mp4

[echasnovski]

Thanks! I'll plan to push this patch soon then (in a couple of days).

[echasnovski]

The patch should now be part of the latest main.

[drowning-cat]

Thank you for your work 🙂

[drowning-cat]

I forgot to ask. I wanted to use the CursorMoved or CursorHold events, but they don’t fire while the picker window is open. Is there any way to use autocmds with the state.main window?

If not, is there a chance of adding a MiniPickSelect user event? It would mostly be useful for side effects, like updating the colorscheme on the fly or jump lines with buf_lines when combined with MiniPickMatch. Some tryhards might even use it to implement a floating preview (not me). I don’t have a strong opinion on this, since I’m afraid I might be the only person who would use this feature.

[echasnovski]

I wanted to use the CursorMoved or CursorHold events, but they don’t fire while the picker window is open.

There is no intentional design decision here. If they don't trigger - good, because there should be no dependency on the actual placement of the cursor. Cursor is invisible -> 'mini.pick' implementation can choose to place it however and wherever it needs. More

If not, is there a chance of adding a MiniPickSelect user event?

Judging by the name I'd guess it is something along the lines of "trigger on every choose" (since "select" ~ "choose"). But judging by the use case, it is "trigger on every change of the current item", right?

I did think about it in terms of separate floating window indeed. My concern is that it will trigger relatively frequently for purposes that will be useful to only a few. There is an alternative implementation idea to basically smartly try to preview every N milliseconds.

It would mostly be useful for side effects, like updating the colorscheme on the fly when combined with MiniPickMatch

Unfortunately, this is still not quite enough for this to be implemented. As I said, I mostly would like to suggest to do the preview whenever preview is actively visible (in which case source.preview should take care of it).

The alternative can be to either monkey-patch all move_xxx actions for this specific picker or continuously poll for current item identifier change.

[drowning-cat]

Cursor is invisible

Is it more like a virtual input or a key listener? I’m not really asking about implementation details, but whether it’s possible to implement something like :h i_CTRL-O or similar behavior by triggering a command for the input.

But judging by the use case, it is "trigger on every change of the current item", right?

<C-n>/<C-p>

The alternative can be to either monkey-patch all move_xxx actions for this specific picker or continuously poll for current item identifier change.

Do you mean something like in the code from this discussion? Since H.actions isn’t accessible, maybe something like this:

mappings = {
  move_down = "<C-n>",
  move_down2 = {
    char = "<C-j>",
    func = function()
      vim.api.nvim_feedkeys(vim.keycode("<C-n>"), "n", false)
    end,
  }

To be honest, thinking about all the possible mappings gives me a headache.

[echasnovski]

Is it more like a virtual input or a key listener? I’m not really asking about implementation details, but whether it’s possible to implement something like :h i_CTRL-O or similar behavior by triggering a command for the input.

'mini.pick' has a separate key query process. Basically, every key is intercepted via vim.fn.getcharstr() and processed via defined actions. So thinking in regular Neovim terms (modes and cursors) is not really useful here.

Do you mean something like in the code from this discussion? Since H.actions isn’t accessible, maybe something like this:

Something like this, but it should be possible to override <C-n> / <C-p> to use Down / <Up> via vim.api.nvim_input() (feedkeys() is not really a good solution here).

[drowning-cat]

Thanks 👍