Persistent colorscheme

[MartinDelille]

Hi!

First of all, thank you for this amazing plugin!

I used to use this telescope extension for my theme picker: https://github.com/andrewberty/telescope-themes/

It had the same colorscheme picker feature but it stores the selected colorscheme in a persistente way. Is there a way to achieve the same using snacks colorscheme picker ?

[drowning-cat]

Simple

Try using these first:

• Share your layouts! #1306 (comment)
• Persistent colorscheme #1239 (comment)

---

Advanced

But personally, I use a more advanced approach with smart preloading of only the target colorscheme plugin and lazy-loading all others:

-- lua/custom/save-colors.lua

local M = {}

M.registery = {}

function M.sync_colorscheme()
  pcall(vim.cmd.rshada)
end

---@param fallback? string
---@return string|nil
function M.get_colorscheme(fallback)
  if not vim.g.COLORS_NAME then
    M.sync_colorscheme()
  end
  if vim.g.COLORS_NAME and vim.g.COLORS_NAME ~= '' then
    return vim.g.COLORS_NAME
  else
    return fallback
  end
end

---@param colorscheme? string
function M.save_colorscheme(colorscheme)
  colorscheme = colorscheme or vim.g.colors_name
  if M.get_colorscheme() == colorscheme then
    return
  end
  vim.g.COLORS_NAME = colorscheme
  vim.cmd.wshada()
end

function M.load_colorscheme()
  return pcall(vim.cmd.colorscheme, M.get_colorscheme())
end

---@module 'lazy.types'

---@class ColorschemePluginSpec : LazyPluginSpec
---@field pattern? string|string[]

---@alias ColorschemeSpec string|ColorschemePluginSpec

local tbl_wrap = function(v)
  return type(v) == 'table' and v or { v }
end

---@param plugins ColorschemeSpec[]
---@return LazyPluginSpec[]
function M.tune_colorscheme_plugins(plugins)
  plugins = vim.iter(plugins):map(tbl_wrap)

  ---@param plug LazyPluginSpec
  local get_name = function(plug)
    local get_name = require('lazy.core.plugin').Spec.get_name
    local name = plug.name --[[@as string]]
      or plug[1] and get_name(plug[1])
      or plug.url and get_name(plug.url)
      or plug.dir and get_name(plug.dir)
    return string.gsub(name, '[-.]nvim$', '')
  end

  local in_registery = function(plug, colorscheme)
    local name = plug[1] or plug.url or plug.dir
    local reg = M.registery[colorscheme]
    if colorscheme:match 'base16%-' and name == 'RRethy/base16-nvim' then
      return true
    end
    if reg == name then
      return true
    end
  end

  local match_colorscheme = function(plug, colorscheme)
    if in_registery(plug, colorscheme) then
      return true
    end
    local pattern = plug.pattern
    if not pattern then
      local name = get_name(plug)
      if name then
        pattern = string.gsub(name, '-', '%%-')
      end
    end
    return vim.iter(tbl_wrap(pattern)):any(function(pat)
      return string.match(colorscheme, pat)
    end)
  end

  local colorscheme = M.get_colorscheme()

  -- local make_config = function(plug)
  --   local config = plug.config
  --   return function(lazy_plug, opts)
  --     if type(config) == 'function' then
  --       config(lazy_plug, opts)
  --     end
  --     if config == true then
  --       require(get_name(plug)).setup(lazy_plug, opts)
  --     end
  --     M.load_colorscheme()
  --   end
  -- end

  plugins = plugins:map(function(plug)
    if match_colorscheme(plug, colorscheme) then
      return vim.tbl_extend('force', plug, {
        lazy = false,
        priority = 1000,
        -- config = make_config(plug),
      })
    else
      return vim.tbl_extend('keep', plug, { lazy = true })
    end
  end)

  return plugins:totable()
end

---@param plugins ColorschemeSpec[]
---@return LazyPluginSpec[]
function M.lazy_setup(plugins)
  local aug = vim.api.nvim_create_augroup('save_colors', { clear = true })
  local on_enter = function()
    if vim.g.colors_name == M.get_colorscheme() then
      return true
    else
      M.load_colorscheme()
    end
  end
  vim.api.nvim_create_autocmd('User', {
    pattern = 'LazyDone',
    once = true,
    group = aug,
    callback = on_enter,
  })
  vim.api.nvim_create_autocmd('VimEnter', {
    once = true,
    group = aug,
    callback = on_enter,
  })
  vim.api.nvim_create_autocmd('ColorScheme', {
    group = aug,
    callback = function(event)
      M.save_colorscheme(event.match)
    end,
  })
  vim.api.nvim_create_autocmd('VimLeavePre', {
    group = aug,
    callback = function()
      M.sync_colorscheme()
      M.save_colorscheme(M.get_colorscheme())
    end,
  })
  return M.tune_colorscheme_plugins(plugins)
end

return M

-- init.lua
 
require('lazy').setup {
  spec = {
    { import = 'plugins' },
  },
  install = {
    colorscheme = { require('custom.save-colors').get_colorscheme 'default' },
  },
}

Warning

Take a look at the pattern option. This is a specific option for custom.save-colors.

Note

The plugin will try to guess the colorscheme name from the link.
If there is no name option (see rose-pine/neovim) and the colorscheme name cannot be derived from its link,
use the pattern option (all - must be escaped).

-- lua/plugins/colorscheme.lua
 
return {
 
  require('custom.save-colors').lazy_setup {
    -- List all colorscheme plugins here.
    { 'folke/tokyonight.nvim' },
    { 'RRethy/base16-nvim', pattern = 'base16%-' }, -- <- `pattern`
    { 'rebelot/kanagawa.nvim', opts = {
      commentStyle = { italic = false },
      keywordStyle = { italic = false },
    } },
    { 'rose-pine/neovim', name = 'rose-pine', opts = {  -- <- `name`
      styles = { italic = false },
    } },
    { 'EdenEast/nightfox.nvim' },
  },

  -- Other plugins
}

[drowning-cat]

You can check which colorscheme is registered in the repro using := C.get_colorscheme(). Fyi, the tokyonight theme (without a -* suffix) automatically picks the last used dark or light style, depending on which one was used most recently.

[xavier7179]

I double-checked the repro you so kindly prepared, anticipating me. If you select tokionight, you get tokionight-moon as saved colorscheme. If I got your last message right, it has to be expected. If so, I confirm your updated script works fine.

[drowning-cat]

What I meant is that if you do the following:

:colorscheme tokyonight-day
:colorscheme tokyonight -- the same as tokyonight-day

and then compare it with:

:colorscheme tokyonight-moon
:colorscheme tokyonight -- the same as tokyonight-moon

the results will be different.

If you have a differently saved colorscheme name, then the problem is clearly in the code itself.
I’ll try to debug it properly over the weekend.

[drowning-cat]

Can you please try this? I hope it works better.

---@param plugins ColorschemeSpec[]
---@return LazyPluginSpec[]
function M.lazy_setup(plugins)
  local aug = vim.api.nvim_create_augroup('save_colors', { clear = true })

  -- When the previous session was forcefully closed,
  --   setting the colorscheme style inside the `LazyDone` is ignored
  vim.api.nvim_create_autocmd('User', {
    pattern = { 'LazyDone', 'VeryLazy' },
    group = aug,
    callback = function()
      if vim.g.colors_name == M.get_colorscheme 'default' then
        return true
      else
        M.load_colorscheme()
      end
    end,
  })
  -- You can also save colorschemes manually instead of relying on the `ColorScheme` event
  vim.api.nvim_create_autocmd('ColorScheme', {
    group = aug,
    callback = function(event)
      M.save_colorscheme(event.match)
    end,
  })
  -- If multiple neovim instances are opened,
  --   the colorscheme from the last exited instance will be forcefully saved.
  -- [Can be deleted]
  vim.api.nvim_create_autocmd('VimLeave', {
    group = aug,
    callback = function()
      M.sync_colorscheme()
      M.save_colorscheme(M.get_colorscheme())
    end,
  })
  return M.tune_colorscheme_plugins(plugins)
end

[xavier7179]

Hi, thanks for the effort! Unfortunately, I confirm that the theme's setting still retrieves the wrong label and that I do not set them twice (first with and then without the -* part. As you were writing, this is undoubtedly related to the specific theme, and maybe it is not solvable without a feature from lazy.vim to extract the list of theme's labels directly.

[MartinDelille]

Hi,

Thank you for taking the time answering my question!

I tried your code without but the colorscheme is not restore if I restart neovim after changing it using Snacks.picker.colorschemes().

Where is it supposed to save and restore the colorscheme ?

[drowning-cat]

You can also try to use these functions instead:

---@param fallback? string
---@return string|nil
function get_colorscheme(fallback)
  if not vim.g.COLORS_NAME then
    vim.cmd.rshada()
  end
  return vim.g.COLORS_NAME or fallback
end

---@param colorscheme? string
function save_colorscheme(colorscheme)
  colorscheme = colorscheme or vim.g.colors_name
  if get_colorscheme() == colorscheme then
    return
  end
  vim.g.COLORS_NAME = colorscheme
  vim.cmd.wshada()
end

[MartinDelille]

My question is when is it saving it ? Do I have to call the save_colorscheme() function manually ?

[drowning-cat]

TL;DR No need to manually save the colorscheme.

When you call require('custom.save-colors').lazy_setup() in the same way as a plugin:

require('lazy').setup {
  spec = {
    -- { 'folke/snacks.nvim', opts = {} },
    -- ... other plugins
 
    -- Return colorscheme plugins, set up events for loading/saving the colorscheme
    require('custom.save-colors').lazy_setup {
      -- List all colorscheme plugins here.
      { 'folke/tokyonight.nvim' },
      { 'RRethy/base16-nvim', pattern = 'base16%-' }, -- <- `pattern`
      { 'rebelot/kanagawa.nvim', opts = {
        commentStyle = { italic = false },
        keywordStyle = { italic = false },
      } },
      { 'rose-pine/neovim', name = 'rose-pine', opts = {  -- <- `name`
        styles = { italic = false },
      } },
      {
        'EdenEast/nightfox.nvim',
      },
    },
  },
  -- Set the colorscheme for the `:Lazy` UI
  install = {
    colorscheme = { require('custom.save-colors').get_colorscheme 'habamax' },
  },
}

It creates the ColorScheme event that automatically saves the conventional variable vim.g.colors_name, which was most likely set by your colorscheme plugin, into the shada variable vim.g.COLORS_NAME that persists between sessions.

vim.api.nvim_create_autocmd('ColorScheme', { -- When the colorscheme changes
  group = aug,
  callback = function()
    M.save_colorscheme()
  end,
})

[drowning-cat]

You can simply send me a link to your current dotfiles, and I will create a fork with an example configuration.

[xavier7179]

I apologize for not following the thread.

As I was wondering why the solutions do not contemplate resorting to the confirm function of the colorscheme picker, I believe the solution would still require a way to make the selection permanent (as far as I tested it, the "default" implementation add a vim.cmd() line with the current selection in some lua file, while the optimum would be both setting the file for writing and replace/update the previous vim.cmd() command). I hope it is not me who is not seeing something in the documentation.

[xavier7179]

Hi all,

Is there a reason no solution is based upon setting a custom function for the option confirm as the doc suggests?

[drowning-cat]

You can do it, and it will be much simpler, but you'll need to preload all the colorschemes you want to use. I believe that if you use fewer than 20 modules, it won’t matter at all. Overall, it’s 👍.

[drowning-cat]

I feel like the discussion is slowly falling apart because I introduced the harder solution first. If you don’t mind preloading colorscheme plugins, you can use this approach:

-- lua/plugins/snacks.lua

return {
  { 'folke/tokyonight.nvim' },
  { 'RRethy/base16-nvim' },
  {
    'folke/snacks.nvim',
    priority = 1000,
    lazy = false,
    init = function()
      vim.api.nvim_create_autocmd('User', {
        pattern = 'LazyDone',
        callback = function()
          vim.cmd.colorscheme(get_colorscheme 'default')
        end,
      })
    end,
    opts = {
      picker = {
        sources = {
          colorschemes = {
            confirm = function(picker, item)
              local source = require('snacks.picker.config.sources').colorschemes
              source.confirm(picker, item)
              save_colorscheme(item.text)
            end,
          },
        },
      },
    },
  },
}

-- init.lua
 
---@param fallback? string
_G.get_colorscheme = function(fallback)
  if not vim.g.COLORS_NAME then
    vim.cmd.rshada()
  end
  if not vim.g.COLORS_NAME or vim.g.COLORS_NAME == '' then
    return fallback or 'default'
  end
  return vim.g.COLORS_NAME
end

---@param colorscheme? string
_G.save_colorscheme = function(colorscheme)
  colorscheme = colorscheme or vim.g.colors_name
  if get_colorscheme() == colorscheme then
    return
  end
  vim.g.COLORS_NAME = colorscheme
  vim.cmd.wshada()
end
 
require('lazy').setup {
  spec = {
    { import = 'plugins' },
  },
  install = {
    -- Set the colorscheme for the `:Lazy` UI
    colorscheme = { get_colorscheme 'default' },
  },
}

[MartinDelille]

Thanks! it looks like more clear to me on what is happening. I'm not an expert at lua and plugin configuration so I wanted to be sure what I was doing before doing random modification to my configuration.

If I understand correctly I need to modify my lazy.lua configuration. Unfortunately, I don't understand what the spec part mean.

I also don't find mention of the install in the documentation: https://lazy.folke.io/configuration

[drowning-cat]

https://lazy.folke.io/installation

---

From the link you provided:

  install = {
    -- install missing plugins on startup. This doesn't increase startup time.
    missing = true,
    -- try to load one of these colorschemes when starting an installation during startup
    colorscheme = { "habamax" },
  },

---

This:

require("lazy").setup({
  spec = {
    { import = "plugins" },
  }
})

is the same as this:

require("lazy").setup({
  { import = "plugins" },
})

[MartinDelille]

Ok thank you for the precision! I had issue loading the colorscheme in the lazy.lua file so I ended up loading it in the root init.lua: 98411814f2a627c40a472657c6f33b69c3ea700d