Ask questions

[echasnovski]

Feel free to ask questions about mini.nvim which are not really suitable for an issue. Like "How do I setup ...?", etc.

Another approach is to create a separate discussion in Q&A category, if you have trouble working with this particular discussion (as it is quite populated already). This approach might be even more preferable as it will allow filtering questions by module.

[pyrox0]

Could you add docs on how I can use mini.pairs or mini.surround with completion plugins such as coq_nvim or cmp-nvim? The windwp/nvim-autopairs plugin provides instructions for using it with these plugins (see https://github.com/windwp/nvim-autopairs#mapping-cr). Is there any way to do this with mini.pairs and mini.surround? Thanks!

[echasnovski]

I am not sure if it will be specifically for coq_nvim, but i planned to document a possible way of mapping <CR>, <Tab>, and <S-Tab>. Are these mappings you are interested about?
Can't see how mini.surround and completion plugin can interfere with each other. What kind of troubles do you have here?

[pyrox0]

I'm not using mini.nvim right now, and I've never used something like mini.surround, so I wanted to make sure that it wouldn't conflict with my completion plugin. If you documented how to integrate mini.nvim with coq_nvim, then I would 100% switch to it so I could replace a bunch of plugins with just one!

[txtyash]

How to disable few mini.surround commands?

  mappings = {
    add = 'ys',           -- Add surrounding
    delete = 'ds',        -- Delete surrounding
    find = 'ysf',          -- Find surrounding (to the right)
    find_left = 'ysF',     -- Find surrounding (to the left)
    highlight = 'ysh',     -- Highlight surrounding
    replace = 'cs',       -- Replace surrounding
    update_n_lines = 'ysn' -- Update `n_lines`
  }

I don't want find_left, highlight, update_n_lines.. commands. I wanted to free
s but I still don't want to those commands with y.

[echasnovski]

To not create one or several mappings, use empty string ('') for them.

I put this information in the comment just above mappings section in default config (-- Mappings. Use `''` (empty string) to disable one.). Where do you expect this information to be put for better discoverability?

[Boggin]

Trying to set up on Windows 10 with packer.nvim and each time I try to use the commands, i.e. sa, it does a substitute instead.

nvim v0.5.0

init.vim

lua require('plugins')

plugins.lua

return require('packer').startup(function()  
  use 'wbthomason/packer.nvim'  
  use {   
	  'echasnovski/mini.nvim',  
	  branch = 'stable',  
	  setup = [[require('mini.surround')]],  
  }  
 end)  

Any ideas what I need to do would be gratefully received! Thanks.

[echasnovski]

In order to "activate" this module, you have to call its setup() function with your config table (or nothing to use default config). So in your case it should be enough to use this line instead of a posted one:

setup = [[require('mini.surround').setup()]],  

[Boggin]

Thanks for that. Working now!

It was also that I'd not read a note on packer.vim. I'll copy it here in case someone else has made the same mistake:
"If you are on Windows 10, you need developer mode enabled in order to use local plugins (creating symbolic links requires admin privileges on Windows - credit to @TimUntersberger for this note)"

[IlyaKisil]

How to make visual selection dot-repeatable with mini.surround? For example, with this mapping

vim.api.nvim_set_keymap('x', 'S', [[:<C-u>lua MiniSurround.add('visual')<CR>]], { noremap = true })

if I select some text in visual mode and then S" this will surround selection with double quotes. But I'd like to repeat this action with . for the other selection.

[echasnovski]

Unfortunately, not possible at the moment. Couple of reasons:

• In my experience, visual mode operations are not really intended to be dot-repeatable. Operations with text objects and motions - are. I understand that it is possible in the way that you describe, just doesn't seem to be widely implemented and used.
• If I remember correctly, originally it was somewhat difficult to make properly due to module design.

[IlyaKisil]

How to repeat jump mini.jump but backwards? For example, with vanilla config

• ; Repeat latest f, t, F or T [count] times
• , Repeat latest f, t, F or T in opposite direction [count] times
  mini.jump config exposes mapping for the forward jump

{
  mappings = {
    ...
    repeat_jump = ';',
  }
}

I've quickly looked through jump.lua and it doesn't look like there is such option or does it 🤷 ?)

[echasnovski]

Yes, there is no builtin option for that. Is it a real inconvenience to swap f (F) for t (T) manually?

There is a MiniJump.state that tracks state of recent jump. Should be possible to write one wrapper. Something like lua MiniJump.jump(nil, not MiniJump.state.backward), maybe?

[IlyaKisil]

Is it a real inconvenience to swap f (F) for t (T) manually?
It is not about swapping them in the config, it is about not re-initiating jumps if you overshoot.

For instance, let's say that you did fo;;;;;;; and then you realised that you over jumped by three positions and need to go three positions back.

vim.api.nvim_set_keymap('n', ',', [[:<C-u>lua MiniJump.jump(nil, not MiniJump.state.backward)<CR>]], { noremap = true })
vim.api.nvim_set_keymap('n', ',', [[:<C-u>lua MiniJump.smart_jump(not MiniJump.state.backward)<CR>]], { noremap = true })

This wouldn't work, as it will just get stuck in a loop, since update_state will be reusing state for subsequent jumps.

However, the following two mappings

vim.api.nvim_set_keymap('n', ',', [[:<C-u>lua MiniJump.jump(nil, true)<CR>]], { noremap = true })
vim.api.nvim_set_keymap('n', ',', [[:<C-u>lua MiniJump.smart_jump(true)<CR>]], { noremap = true })

kinda work, but they would break switch to ;. So in general, , should be considered in a sense of reversing direction of jumps. For instance:

• Instead of using ,,, (go 3 times backwards) it is better to do ,;; (, -> reverse direction and then ;; repeat 2 jumps in that reversed direction).
• Then if you over jumped backwards again, you would need to do , to start going forward and however many times ; to keep going forward, i.e. repeating jumps.

Note, that if you just use ,,, then you lose ability to go forward without re-initiating search with f, as ; will just continue to go to the reversed direction.

Since this is not ideal, so there is a need for wrapper. Here is what I came up with.

local M = {}

function M.repeat_in_oposite_direction()
  local state = {}
  for k, v in pairs(MiniJump.state) do
    state[k] = v
  end
  MiniJump.smart_jump(not MiniJump.state.backward)
  MiniJump.state = state
end

vim.api.nvim_set_keymap('n', ',', [[:<C-u>lua require("<this-module>").repeat_in_oposite_direction()<CR>]], { noremap = true })

return M

This seems to work with f and F just fine, and it will also replicate revert in opposite directions for t or T like in the plain (N)Vim config. But assume that you do to;;; which will stop as shown below

aaaa o aaaaa o aaaa o aaaa o
    ^       ^      ^      ^

But if you over jump and want to go backwards, it will stop after o

aaaa o aaaaa o aaaa o aaaa o
      ^       ^      ^      ^

whereas, I'd like it to just go backwards of the same positions. However, I guess this is outside of scope of this plugin.

[echasnovski]

This wouldn't work, as it will just get stuck in a loop, since update_state will be reusing state for subsequent jumps.

Yeah, you are right.

Basically, lack of intuitiveness (what should jumping in reverse three times be: ,,, or ,;;, etc.) and "symmetry" issues (it reverses direction, but there is also till) that "reverse jump" brings prompted me to not include it in module.

For instance, let's say that you did fo;;;;;;; and then you realised that you over jumped by three positions and need to go three positions back.

The designed way of doing this would be fofffffff and then going three times earlier with 3F.

Since this is not ideal, so there is a need for wrapper. Here is what I came up with.

Nice! Here is how I would write this:

function M.opposite_jump()
  MiniJump.state.backward = not MiniJump.state.backward
  MiniJump.smart_jump()
  MiniJump.state.backward = not MiniJump.state.backward
end

However, I guess this is outside of scope of this plugin.

It is indeed, yes.

[IlyaKisil]

For instance, let's say that you did fo;;;;;;; and then you realised that you over jumped by three positions and need to go three positions back.

The designed way of doing this would be fofffffff and then going three times earlier with 3F.

Ohhh... I didn't realise that fofffffff would work. Although I've watched show-case video but it still didn't settle in my head. I think, I like your design decision of first doing [fFtT]<letter> and then just using [fFtT] instead of ;, to repeat jumps

Initially, I thought this plugin is mainly to replicate default fFtT with default mappings for repeating actions, i.e. ; and ,

• With an option of going across lines
• Being written in Lua

I guess, I got confused by having this option customisable.

repeat_jump = ';',

What is the point of having this if you can essentially repeat jump with either ftTF after the initial fo?

[echasnovski]

Ironically, original author of module wasn't a fan of this option. My motivation behind this was twofold:

• It might be useful for people who don't want to "loose muscle memory of original Vim commands", which can be useful outside of Neovim (like in command line with vi keybindings). I initially used it myself, but after some time found myself using ftFT to repeat.
• It had natural implementation within current design and didn't add much complexity.

[shashanktomar]

Hi, thanks for an amazing plugin. Really appreciate the effort put into documenting everything.

What is the easiest way to map mini.ai function_call mapping to something other than f. Is this the only way to do this?

   custom_textobjects = {
    c = gen_spec.function_call({ name_pattern = '[%w_%.]' }),
    f = spec_treesitter({
      a = '@function.outer',
      i = '@function.inner',
    }),
  },

[echasnovski]

Thanks for kind words!

What is the easiest way to map mini.ai function_call mapping to something other than f. Is this the only way to do this?

Your example setup already uses c to select function call (based on Lua patterns; allows alphanumeric, underscore, and dot to be inside function name) and f to select function definition (based on tree-sitter).

Alternatively, you can use tree-sitter to select function call (has both pros and cons), which can be achieved with this:

local gen_spec = require('mini.ai').gen_spec
require('mini.ai').setup({
  custom_textobjects = {
    c = gen_spec.treesitter({ a = '@call.outer', i = '@call.inner' }),
    f = gen_spec.treesitter({ a = '@function.outer', i = '@function.inner' }),
  },
})

[shashanktomar]

Hi There Again,

I am currently using Comment.nvim but want to give mini.comment a try. The documentation says:
Not supported - Block and sub-line comments. This will only support per-line commenting.

Is there any plan to add block level commenting anytime in the future or it will never be supported.

[echasnovski]

... missing triple backticks in "mini.surround", etc. which make them unusable for me.

If you did mean 'mini.surround', then you can define them in config.custom_surroundings via something like { input = { '```().-()```' }, output = { left = '```', right = '```' } }.

If you meant 'mini.pairs', then yeah, I do at the moment think that it is not the place for this kind of functionality there. It is better suited for snippets, which I hope will be implemented in future 'mini.snippets'.

[txtyash]

Yea, i prolly meant mini.pairs. btw, the one major thing that is missing is gifs for every module in the readme. That'd be really great.

[echasnovski]

... the one major thing that is missing is gifs for every module in the readme. That'd be really great.

They were in README (well mp4, not gif) but file got too big to load which is bad for the main page of plugin. They now are in a separate DEMO.md with links to it inside every module's section in main README. I am currently in the process of reorganizing documentation, so there will be separate READMEs for every module with links to them in main one.

[gibfahn]

If you did mean 'mini.surround', then you can define them in config.custom_surroundings via something like { input = { '().-()' }, output = { left = '', right = '' } }.

Came here looking for a surround option for Markdown code blocks, does this handle newlines? e.g I want to surround the current line with backticks like:

Before:

foo()

After:

```
foo()
```

ideally with an optional codeblock syntax, or at least leaving the cursor at the end of the first set of backticks so you can easily type the language. For comparison here's how you do it in nvim-surround.

Fair enough if that's out of scope for the plugin, just wondered whether I was missing something looking at the setup docs.

[echasnovski]

Came here looking for a surround option for Markdown code blocks, does this handle newlines?

It can be made to, because new lines are respected (with a caveat).

I would do that by creating (in config directory) a 'after/filetype/markdown/lua' file with the following content:

vim.b.minisurround_config = {
  custom_surroundings = {
    c = { input = { '```\n().-()\n```' }, output = { left = '```\n', right = '\n```' } },
  },
}

The caveat here is that this will work only if first line has zero indent. If not, ``` will be inserted after that indent and the first line in code block will have zero indent. Not sure if this will change, as it works for majority of cases.

[konart]

Hi! Thanks for a great toolkit.

mini.surround question here:

Is it possible to surround en element (or by motion) with function call? Based on the readme I'd think I can do something like:

a := "so|me_string" //  `|` is the cursor position.

safW( and have is surrounded with () with cursor before the leftmost ( or something like that.

But I can't really figure this out.

[echasnovski]

Hello! Thanks!

Adding surrounding is done in three steps:

• Initiate "Add surrounding" action via sa.
• Tell what region you want to surround via textobject or motion. For example, in your example it can be "around "" which is a".
• Tell which surrounding you want to add via pressing single character surrounding identifier. For a function call, it is f. It will prompt you to insert function name: type it (if I understood correctly, you want W as a function name) and hit <CR> (Enter).

So, overall sequence on characters you need to press is: saa"fW<CR> (<CR> is single hit on Enter). This will result into following state:

a := W(|"some_string")

I am not sure I have 100% understanding of your question, though. Does this help you figure it out?

Here are some other examples.

[megalithic]

👋 hi @echasnovski; LOVE your work and plugins. Question regarding mini.pairs; I'm looking to move to mini.pairs instead of nvim-autopairs; one thing I'd love to ensure is possible, is the ability to handle endwise matches (aka, lua's then..end, or function() end, etc.; or ruby/elixir's do..end, etc.).

Hopefully this isn't too far out of the realm of possibility (oh, and of course, compatibility with nvim-cmcp).

Thanks!

[txtyash]

👋 hi @echasnovski; LOVE your work and plugins. Question regarding mini.pairs; I'm looking to move to mini.pairs instead of nvim-autopairs; one thing I'd love to ensure is possible, is the ability to handle endwise matches (aka, lua's then..end, or function() end, etc.; or ruby/elixir's do..end, etc.).

Hopefully this isn't too far out of the realm of possibility (oh, and of course, compatibility with nvim-cmcp).

Thanks!

U shudve mentioned triple backticks

[echasnovski]

@megalithic, as you already found a #9, my suggestion is to use snippet engine for these cases. 'mini.pairs' is designed to work with single character left and right parts, and it will be that way (at least, for a while).

[bangedorrunt]

Hi @echasnovski, I'm wondering why mini.completion doesn't come with LSP snippet support?

[echasnovski]

Hi! Mostly because it has complicated implementation. 'mini.completion' is already quite big and complex, so I don't want to overburden it.

[bangedorrunt]

Hi! Mostly because it has complicated implementation. 'mini.completion' is already quite big and complex, so I don't want to overburden it.

I'm aware of the purpose of mini.nvim, but at least for me, trying to make a minimalistic plugin doesn't mean we have to trip off essential features. I think snippet engine is very important and should be a complement to LSP servers. I understand that this means more burden on your shoulder. My suggestion is you might make other plugin such as mini.snip which is complement to mini.completion.

[echasnovski]

Thank you for your suggestion. It is already planned.

[bangedorrunt]

Awesome, couldn't wait! Thank you a tons

[GllmR]

Is there a way to have transparent background in mini.starter ?

[echasnovski]

The background in 'mini.starter' is the same as background in all other windows. It is a Normal highlight group. Usually needs a transparent terminal emulator and hi Normal guibg=NONE somewhere.

Do you have working transparent background for other windows but still have 'mini.starter' open without transparency? Or do you want only Starter buffer to be transparent?

[GllmR]

Ok, sorry, it's another plugin that make the background dark (drop-nvim)
🙇

[galli-miro]

Hi!

I've recently started using mini.comment instead of tpope implementation. The one thing annoying sometimes, is that when I'm trying to comment an entire paragraph with gcap, it also comments the empty line at the end of it. If I were to use dot repeat to revert the change, it instead comments the same paragraph again, as well as the next one.

nvim-comment solved this by adding an option to ignore empty lines. Is this something that mini.comment might also have someday?

[echasnovski]

Hi!

US there any reason to not use gcip? It doesn't select empty lines and can be reverted with ..

[galli-miro]

Aah, you are absolutely right. I don't know why I didn't think about that. Thanks :)

[madjxatw]

It is possible to set rules for mini.pairs like nvim-autopairs does? E.g. I probably don't expect a pair of quotes to be inserted when the cursor is right before a word (|word). I used https://github.com/jiangmiao/auto-pairs and https://github.com/tmsvg/pear-tree before with Vim and I prefer the latter as its default behavior makes more sense to me.

[echasnovski]

The only "rules" 'mini.pairs' supports is conditioning on cursor's neighborhood. So you can set up to insert pair only if cursor's neighborhood matches some two-character neigh_pattern Lua pattern. You can do this either inside config for built-in characters or inside MiniPairs.map() for manual mapping.

You case is thus can be supported with this setup:

require('mini.pairs').setup({
  mappings = {
    ['"'] = { neigh_pattern = '[^\\]%W' },
  }
})

Here it will insert "" only if previous character is not a \ and next character is not an alphanumeric character. See here for more special Lua patterns.

[madjxatw]

But how can I distinguish left neighbor and right neighbor?

[echasnovski]

It is a two-character pattern: first character matches left neighbor, second - right.

[madjxatw]

Got it, I misunderstood the concept of 2-chars a bit before, thanks a lot for the explanation with useful links!

[madjxatw]

Excuse me, another question is how to set up mini.pairs to correctly handle Markdown triple ticks. Now whenever I press ` twice, it produces four `.

[echasnovski]

Unfortunately, there is no way right now and probably won't be. The reason is that 'mini.pairs' is designed to work only for two-character neighborhood. Anything wider is a functionality more suited for snippets, in my opinion.

[RyanzpLee]

Dumb question, but how do I get mini.sessions to work? I've installed the module along with starter. Do I have to type in :lua MiniSessions.write({ name of my session }) or do I setup a keybind? What is a recommended approach to get up and running quickly please!

[echasnovski]

I usually use it like this:

• If I need to save a new session, I do indeed type :lua MiniSessions.write('new_session'). This happens not so often, so I don't have mapping for that.
• If I need to read session, at least 99% of the time it is listed in Starter buffer. If not, I type :lua MiniSessions.select() and it provides an interface to read any of the detected sessions. It can be used not only to read, but to (re)write and delete. See its help.

Couple of things worth mentioning:

• The 'mini.sessions' is basically a convenience wrapper for Neovim's built-in sessions mechanism. See :h mksession and :h sessionoptions.
• You can tell 'mini.sessions' about where to store non-local session files with directory option. I have it like this: require('mini.sessions').setup({ directory = '~/.config/nvim/misc/sessions' })

[RyanzpLee]

ooh I see, I'm able to create a session like that thank you so much.

I tried to make a keymap that would let me type in the session name, but the session name ended up being table: 0x0102e019283. Any ideas why it's not working? keymap("n", "<leader>msw", [[ :lua MiniSessions.write({ vim.fn.input("Session Name > ") })<CR> ]])

Also I tried doing :lua MiniSessions.detected() to see what sessions are available and expected a list to come back, but I get back this error. Am I using it wrong?

E5108: Error executing lua [string ":lua"]:1: attempt to call field 'detected' (a table value)
stack traceback:
        [string ":lua"]:1: in main chunk

Thanks for your awesome plugins btw

[echasnovski]

I tried to make a keymap that would let me type in the session name, but the session name ended up being table: 0x0102e019283. Any ideas why it's not working? keymap("n", "<leader>msw", [[ :lua MiniSessions.write({ vim.fn.input("Session Name > ") })<CR> ]])

The MiniSessions.write() takes a string as session name in first argument. You have { ... } which creates a table.
Try this: vim.keymap.set("n", "<leader>msw", '<Cmd>lua MiniSessions.write(vim.fn.input("Session Name > "))<CR>').

Also I tried doing :lua MiniSessions.detected() to see what sessions are available and expected a list to come back, but I get back this error. Am I using it wrong?

E5108: Error executing lua [string ":lua"]:1: attempt to call field 'detected' (a table value)
stack traceback:
        [string ":lua"]:1: in main chunk

The MiniSessions.detected is already a table with detected sessions. To see them, try :lua =MiniSessions.detected if you are on Neovim>=0.8.2 or :lua print(vim.inspect(MiniSessions.detected)) otherwise.

Thanks for your awesome plugins btw

❤️

[tvsfx]

I'm trying to completely replace my nvim-treesitter/nvim-treesitter-textobjects config with mini-ai navigation, since I have quite a few custom textobjects defined there. treesitter-textobjects has a relatively granular way to define navigate to next/previous start/end of textobject keybinds (and to aggreggate different categories, by e.g. just navigating to next). As far as I can tell, the default keybinds g[ and g] correspond to navigate_to_next_start and navigate_to_next_end in treesitter-textobjects, but is there a simple way to have keybindings for the backwards search functionality as well?

[echasnovski]

As far as I can tell, the default keybinds g[ and g] correspond to navigate_to_next_start and navigate_to_next_end in treesitter-textobjects, but is there a simple way to have keybindings for the backwards search functionality as well?

Not quite. They go to left and right side of the textobject that is found based on the config.search_method. So it is similar to moving to left or right edge of visual selection after va<char>, which with default search_method can be covering or next.

As for the question, there is a move_cursor(). It is not used in more built-in mappings because combinations of "side" and "search method" start being confusing really quick.

You can use it, for example, like this:

local map_move_cursor = function(lhs, side, search_method)
  local rhs = function()
    local ok, tobj_id = pcall(vim.fn.getcharstr)
    if not ok or tobj_id == '\27' then return '' end
    local opts = { search_method = search_method, n_times = vim.v.count1 }
    MiniAi.move_cursor(side, 'a', vim.fn.escape(tobj_id, '\\'), opts)
  end

  local desc = string.format('Move to %s %s side', search_method, side)
  vim.keymap.set({ 'n', 'x', 'o' }, lhs, rhs, { desc = desc })
end

map_move_cursor('g{', 'left', 'prev')
map_move_cursor('g}', 'right', 'prev')

With this, g{ / g} move to left/right side of the previous textobject.. This has at least 95% of functionality. The only thing lacking is seamless dot-repeat, as it would ask for textobject id each time. If this is too inconvenient, then going the built-in route of returning <Cmd>lua ... <CR> string inside an expression mapping is the only good solution here.

[tvsfx]

Thanks a lot for the pointers! Imma tinker with this a bit and see if I can make something work :) I'm thinking of remapping g[<lowercase> to g]<uppercase>, and having g[<lower/uppercase> be the backwards motions, as I feel it's quite standard to have [ be backwards and ] mean forwards, and I'm not using capitals in mini.ai as of right now.

[bnhtho]

Hello @echasnovski . I just wonder is possible to move mini.tabline to the right if neotree open?
I can make it with toggleterm plugin. This is neotree snippet to check state of Neovim tree. I wonder can it work with tabline?

local manager = require("neo-tree.sources.manager")
        local renderer = require("neo-tree.ui.renderer")
        local state = manager.get_state("filesystem")
        local neotree_open = renderer.window_exists(state)
        if neotree_open == true then

[echasnovski]

I am afraid, no. See #73.

[bnhtho]

Ah thanks you so much.. One more thing.
I think there was an error attempt to index a nil value here.
Edit: I just making an bug report here:
#1235

[postelrich]

What is the best way to use mini.completion with copilot? mini clobbers copilot unless it's after a space. If I start to type, I see the copilot suggestion for second until the completion dropdown opens.

[echasnovski]

You can not. It is in development and will be released for public beta-testing when it is more or less ready.

[swahpy]

The 'mini.completion' module supports only two "sources": LSP and fallback (used if there is no LSP candidates). By default fallback is equivalent to <C-n> built-in Insert mode completion, but it can be anything (including expanding snippets from 'friendly-snippets').

That said, I personally find snippets as completion items a bit distracting, so generally would not prioritize this workflow. Instead, the planned 'mini.snippets' (which I am developing and alpha-testing right now) has separate mechanism of matching and suggesting snippets (including the ones from 'friendly-snippets' if user chooses to use them in setup).

Thank you for your information. I'll definitely give it a try if mini.snippets is ready to use. Although I have nvim-cmp in place and working well, I really feel that it is complicated to config( and adding various sources to it). Instead, I love the mini principles and will switch to mini ones if they exist, just like present.
Looking forword to it and thank you for your excellent work!

[bnhtho]

@echasnovski Hi ! Is possible if upcoming mini.snippets allow customize user "Create" their own snippet?
Example: I love to use https://github.com/folke/todo-comments.nvim .
I want to create snippets contains keywords like TODO, NOTE, SECTION...

[echasnovski]

Yes, it will allow creating own snippets (for example, inside '~/.config/nvim/snippets/my_snippets.json' file) using mostly syntax from LSP specification to later load them and expand.

[bnhtho]

Wow that so complicate . Wishes have some good examples 😄

[wroyca]

What's the difference in how mini.hues initially handles chroma compared to how mini.colors handles it? Consider the following:

  hues.setup({
    background = "#14161B",
    foreground = base_colors.foreground,
    saturation = vim.o.background == 'dark' and 'medium' or 'high',
    accent = 'bg',
  })

  vim.g.colors_name = 'randomhue'

When changing chroma directly in the mini.hues source, for example, from 8 to 5, and 16 to 15:

-  local chroma = ({ low = 4, medium = 8, high = 16 })[saturation]
+  local chroma = ({ low = 4, medium = 5, high = 15 })[saturation]

We get:

But changing it with chan_set from mini.colors to the same value:

-- using randomhue
local cs = require("mini.colors").get_colorscheme()
cs:chan_set('chroma', 5):apply()

We get:

Which is unexpected

[echasnovski]

What's the difference in how mini.hues initially handles chroma compared to how mini.colors handles it?

They use the same Oklch color space, so the computing chroma are the same.

They way 'mini.hues' deals with chroma is described in algorithm overview. In particular, it treats foreground/background chroma and chroma value from config.saturation differently.

While chan_set() method of colorscheme from 'mini.colors' set channel to a certain value to all highlight groups by default. For example, in this case it set chroma 5 to both background and foreground of Normal groups resulting in a saturated background.

[NextMerge]

Is it possible to disable the timeout functionality in mini.surround? I de-mapped the default s key function but it will still timeout if I tap s and wait too long to hit the second chord.

As an aside, my ideal setup would be to have hitting s once bring up a which-key.nvim pane with all the possible commands. Is that possible?

[NextMerge]

When I said timeout I mean that whenever I hit s, I have until vim.opt.timeoutlen (which I have set to be very short) to hit a or any other cord before it "resets" and I need to hit s again.

I have both s and S disabled.

vim.keymap.set({ 'n', 'x' }, 's', '<Nop>')
vim.keymap.set({ 'n', 'x' }, 'S', '<Nop>')

[echasnovski]

(which I have set to be very short)

This is the main problem here. Any mapping that consists from several characters has to be typed with at most 'timeoutlen' millisecond between each key press. This is how mappings in Neovim (and Vim) work.

If you rely on some other functionality that enhances mappings (like 'folke/which-key.nvim' or 'mini.clue'), then I'd suggest looking there. In 'mini.clue' it is as easy as adding { mode = 's', keys = 's' } to config.triggers and it works with very low 'timeoutlen'. I think setting 's' as trigger in 'which-key.nvim' should also solve the issue.

[NextMerge]

Added s as a trigger and it seems to both sustain the mapping and give me the hint pane. 👍

[bnhtho]

Hi @echasnovski , i have a silly questions.
Do i need mini.picker installed first then go to mini.extra plugin as depencenices, or they independent?
Because i see the readme of mini.extras say they are extra pickers for.mini.pick
Also, in mini.git, are there options like Gitsign for git folder as repo?
THANKS YOU

[echasnovski]

👋

Do i need mini.picker installed first then go to mini.extra plugin as depencenices, or they independent?
Because i see the readme of mini.extras say they are extra pickers for.mini.pick

Yes, in order to use preconfigured pickers in 'mini.extra' there needs to be set up 'mini.pick'. So something like this:

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

With this added to the 'init.lua' you can now execute, for example, :Pick explorer (which is a user-friendly way for MiniExtra.pickers.explorer()).

Also, in mini.git, are there options like Gitsign for git folder as repo?

Sorry, I don't really understand the question.

'mini.git' is a Git CLI integration for Neovim. Here are its features. Automated tracking should detect non-standard '.git' directory. Same goes for :Git user command if it is executed with current buffer inside detected Git repository.

[xixiaofinland]

The new mark feature in mini.files is not valid across sessions.

The defined mark such as ma is lost after restarting Nvim. Is there a reason for non persistent marks?

[echasnovski]

The defined mark such as ma is lost after restarting Nvim. Is there a reason for non persistent marks?

Yes, there is: not having to implement persistent file-on-disk tracking. And this is consistent with explorer view, as it is also not persistent across sessions.

To implement persistent custom bookmarks, see this example.

[bnhtho]

I can't thank you enough for every work you had done til now <3.
I was take a lot of inspiration from this article and install some useful mini plugins.
I still need a lot thing to improve . But i really love it <3

[echasnovski]

Thank you for kind words! Good luck on your Neovim journey :)

[bnhtho]

No question ! But happy birthday @echasnovski
Sorry i was late 2 days. 😂 😂
May you be blessed with lots of health, happiness, and success in the coming year! 🎉🎂✨🍰🥳

[echasnovski]

Thank you so much for the wishes! I really hope at least some of them will come true 🙏

[ndavd]

In mini.pick, is there a way to filter the files by extension or by a certain pattern? E.g. use MiniPick files on TypeScript files only

[ndavd]

Then I guess for now will skip this one, since searching for a pattern without seeing results as I type kind of defeats the purpose of grep_live.

[echasnovski]

I mean, there is a hacky solution for configuring grep_live described here. You can, for example, write to some temporary file the -g pattern part as a temporary configuration.

[ndavd]

Hmm yeah I was thinking of doing something like that, but it kind of increases complexity too much, I already have a custom .rg that I load everytime, to add another temporary one... Not sure. Thanks anyway.

[ndavd]

In case anyone is looking for something similar in the future, this is how I ended up implementing it ndavd/dotfiles@0c06de3

[echasnovski]

Thanks for sharing! 👍

[bnhtho]

Finally i can made it work. Hey it look like a little complicated. But it work now . The code is not good enough. But at least it work 😂 😂 😂
What is does : When you press <Tab> , it will create edit buffer without losing focus on mini.pick.
If current the cursor is in directory and pressing <Tab> , it will create new mini.pick and cd it to that directory windows by calling vim.cmd(":Pick explorer cwd='" .. selected_entry.path .. "'")
Same behaviour with [Neotree] Opening file without losing sidebar

Code

 {
                "echasnovski/mini.pick",
                version = "*",
                opts = {
                    mappings = {
                        choose = "<CR>",
                        choose_in_vsplit = "<C-l>",
                        choose_in_split = "<C-j>",
                        toggle_preview = "",
                        execute = {
                            char = '<Tab>',
                            func = function()
                                local entries = require("mini.pick").get_picker_matches()
                                if entries and entries.all and entries.current_ind then
                                    local selected_entry = entries.all[entries.current_ind]
                                    if selected_entry.fs_type == "directory" then
                                        vim.cmd(":Pick explorer cwd='" .. selected_entry.path .. "'")
                                    else

                                        require("mini.pick").default_choose(selected_entry.path)
                                    end 
                                end  
                            end  
                        }
                        
                },
                }
            },

Thanks you so much for idea. Need someone help me optimize/refracting a code because it look like a mess. haha

[echasnovski]

I am afraid this setup is a very bad idea. It will disable preview for all pickers, which I would not recommend.
Choosing any other key instead of <Tab> is a better idea. Otherwise having these mappings in a customized explorer picker (see this example) is also a good approach, since this code seems to be tailored for that picker specifically.

Also you can use entries.current directly. Here is how I'd rewrite the main function:

function()
  local current = (MiniPick.get_picker_matches() or {}).current
  if current == nil then return end
  if current.fs_type == 'directory' then return MiniExtra.pickers.explorer({ cwd = current.path }) end
  MiniPick.default_choose(current.path)
end

[bnhtho]

Hi @echasnovski , i want to ask how can i turn off completely the right bottom of mini.pick info plugin?
I check on the docs of mini.pick and this is what i found . It somekind related with latest version of Neovim right?

## User interface ~

UI consists from a single window capable of displaying three different views:
- "Main" - where current query matches are shown.
- "Preview" - preview of current item (toggle with `<Tab>`).
- "Info" - general info about picker and its state (toggle with `<S-Tab>`).

Current prompt is displayed (in Neovim>=0.9) at the top left of the window
border with vertical line indicating caret (current input position).

Bottom part of window border displays (in Neovim>=0.10) extra visual feedback:
- Left part is a picker name.
- Right part contains information in the format >

  <current index in matches> | <match count> | <marked count> / <total count>
<
When picker is busy (like if there are no items yet set or matching is active)
window border changes color to be `MiniPickBorderBusy` after `config.delay.busy`
milliseconds of idle time.

My current Neovim version

NVIM v0.10.2
Build type: Release
LuaJIT 2.1.1727870382
Run "nvim -V1 -v" for more info

[echasnovski]

Hi @echasnovski , i want to ask how can i turn off completely the right bottom of mini.pick info plugin?

There will be no way of doing so. It provides a very helpful information which I don't see the need to remove. The best you can do is to make it "invisible": define MiniPickBorderText highlight group to have both foreground and background the same as background of the whole window. Although, this will both remove a picker name and leave empty spots without border, but that is the best it will get.

[GitMurf]

General question... for things like plugin specs with lazy I like to do the following:

require('lazy.types')
---@type LazyPluginSpec
local M = {
  'some/plugin',
  ...
}

To get the type annotations through the plugin spec. Is there a way to similarly get the types for mini modules to get the types for setup config options? So when I require a mini module like the following, I get lsp completions and hover info for the available setup options:

require('mini.files').setup({
    content = {
        prefix = function() end
        ...
    },
    ...
})

Thanks!

[echasnovski]

Is there a way to similarly get the types for mini modules to get the types for setup config options? So when I require a mini module like the following, I get lsp completions and hover info for the available setup options:

There is no ---@class or anything similar in 'mini.nvim' source code (and probably never be due to it severely inflating overall size). There is a MiniXxx.config field explicitly created but I don't think it is enough for LuaLS to autocreate completions just from that.

[GitMurf]

For mini.sessions is it known / expected that autoread will not work if you lazyload the mini plugin? I have it set to VeryLazy event and cannot get autoread to work.

[echasnovski]

Yes, it is expected. Modules that should operate during startup (and 'mini.sessions' with enabled autoread is one such case) should not be lazy loaded.

[harg]

First of all, thank you for your great and incredible work on those plugins !

mini.pick question :
I'm trying to add an additional keymap to choose a selection.

Here is my non working code trying to add a local keymap :

vim.api.nvim_create_autocmd("User", {
  pattern = "MiniPickStart",
  callback = function(event)
    vim.keymap.set({ "n", "i" }, "<Right>", "<CR>", { buffer = event.buf, desc = "(mini.pick) Choose" })
  end,
})

How can i fix it ?

Thanks!

[echasnovski]

Thanks for kind words!

'mini.pick' actions doesn't follow a regular mappings paths: it has its own key query process. This is needed to implement the "single window UI" design. For example, the query text you see at the top of the window is not an actual text and is specially updated after every key press from the user.

That said, having an extra key for choosing is not something 'mini.pick' was designed for. The "proper" approach is to make <Right> choose current match by setting config.mappings.choose to '<Right>', but I'd highly recommend against it: this will conflict with moving caret to the right and disable <CR>.

One hacky solution is to create custom action which would emulate pressing <CR> after user presses <Right>. This one seems to work:

require('mini.pick').setup({
  mappings = {
    caret_right = '',
    my_choose = { char = '<Right>', func = function() vim.api.nvim_input('\r') end },
  },
})

[harg]

wow! Thank you :)

[fresh2dev]

I am a fan of both mini.surround and mini.pairs.

When coding in Python, I am often found turning text like this...

var: int,

...into this...

var: Optional[int],

I always find myself typing Optional first, then creating the pairs, which creates a mental mess. I'm trying to retrain my approach to first add the brackets, then add Optional.

Is there a simpler way to approach this using mini.surround and mini.pairs?

[fresh2dev]

I'm thinking off something that would allow me to stay in insert mode and type:

Optional|int then press a mapping (say, <C-s>) and enter a motion for the surround.

So, then Optional + C-s + w to turn int into Optional[int].

I guess I could get more comfortable using <C-o> as well.

[echasnovski]

If this happens occasionally, I'd suggest creating a surrounding from user prompt. So that would be:

• Put cursor on int in Normal mode.
• Type saiw?.
• Type Optional[ and <CR> for the left part.
• Type ] and <CR> for the right part.

If you encounter this often (as I assume you do :) ), I'd suggest "investing" into creating custom surrounding. As it is a name in front of the brackets, the "array" name seems reasonable. So it can be something like:

local surr_arr_output = function()
  local arr_name = MiniSurround.user_input('Array name')
  return { left = arr_name .. '[', right = ']' }
end
require('mini.surround').setup({
  custom_surroundings = {
    a = { input = { '%f[%w_%.][%w_%.]+%b[]', '^.-%[().*()%]$' }, output = surr_arr_output },
  },
})

Now adding is a bit simpler (and requires no [ and ]):

• Put cursor on int in Normal mode.
• Type saiwa.
• Type Optional and <CR>.

This also has all the added benefits of a regular custom surrounding:

• sda now can delete (any) array-like surrounding. So it can convert Optional[int] back to int.
• sraa (followed by the replacement name) can replace it with another. So it can convert Optional[int] into Array[int].
• And more: sfa, sha, etc.

---

I'm thinking off something that would allow me to stay in insert mode and type:

Optional|int then press a mapping (say, <C-s>) and enter a motion for the surround.

My personal suggestion would be to get accustomed for exiting into Normal mode frequently for such text editing. Using <C-o> occasionally is also ok, of course.

[fresh2dev]

Ah, I overlooked the user prompt capability, very cool! And while I try to leave plugins as vanilla as possible (lest I venture into endless config churn), the custom surround function definitely seems worth a better understanding and investment. You've given me plenty to chew on, thanks so much!