Mini Jump2d remote action

[leath-dub]

This is a feature from flash.nvim that is really useful. Essentially you can start a operator, for example "y", and type "r" (for remote), this will open mini jump2d. Once you make are brought to the desired location, you will be still in operator pending mode and you can type any motion, like for example "w". Once this motion has been typed, you will be returned back to where you were before you started jumping and in this example you would have yanked the word starting at where you jumped to.

This is a bit hacky, but it can be done by saving the pending operator, jumping, and re applying the pending operator on the range applied to the custom "g@" operator.

First we need a global operator function to assign each time we want to do a remote jump:

local operator
function _G.remote_jump_operator(foo)
  local start_pos = vim.api.nvim_buf_get_mark(0, "[")
  local end_pos = vim.api.nvim_buf_get_mark(0, "]")
  vim.cmd "normal! m'"
  vim.api.nvim_win_set_cursor(0, start_pos)
  vim.cmd('normal! v')
  vim.api.nvim_win_set_cursor(0, end_pos)
  vim.api.nvim_input(vim.api.nvim_replace_termcodes(operator .. '<C-o>', true, false, true))
end

Then just set a operator pending key to trigger the jumping when there is a pending operator (in this case the "r" key):

vim.keymap.set("o", "r", function()
  vim.o.operatorfunc = "v:lua.remote_jump_operator"
  operator = vim.v.operator -- Save the operator
  vim.api.nvim_input(vim.api.nvim_replace_termcodes('<esc>', true, false, true))
  vim.schedule(function()
    MiniJump2d.start(MiniJump2d.builtin_opts.single_character)
    vim.api.nvim_input("g@") -- play custom operator so we can handle when finished
  end)
end, { desc = "Goto to remote word" })

[echasnovski]

Thanks for sharing!

I haven't tried this, but one area I noticed might need an improvement is that it seems to only work in a current window (while jumping to other windows is possible).

---

I do have plans to upgrade 'mini.jump2d' some time in the future. This would include changing default options (to dim and showing 1 step ahead) and spotter. Not quite sure yet to which one: currently testing gen_pattern_spotter('[^%s%p]+') and it's okay, but a bit sparse at times.

Probably will also add the "remote action" feature, as it indeed might be useful from time to time.

[leath-dub]

I haven't tried this, but one area I noticed might need an improvement is that it seems to only work in a current window (while jumping to other windows is possible).

Yeah I guess would need to save and restore the cursor position + window rather than use marks

[pkazmier]

I think you should give MiniJump2d.builtin_opts.single_character a test run for a few days. It’s my favorite mode of operation in jump2d because you can jump anywhere (well, except blank lines). As I look to redo my mini config, I’ve been running your setup the past couple of days and many times I just can’t jump to where I want directly.

[echasnovski]

Funnily enough, I did come to the same conclusion yesterday. Just to see if it is good enough. So I am trying to daily drive it.

First impressions are that It might better than gen_pattern_spotter('[^%s%p]+') ("word start") that I was daily driving for several months. As it indeed makes possible to navigate to more places. What I don't really like about it is:

• It might require typing a not-so-easy-to-type character. Usually if it involves <Shift>.
• There are non-negligible use cases when I want to navigate to something that is either impossible to type (like Unicode characters) or is an inconvenience to do so (like from other human language). This might solved by having a special key (like <BS>) treated to spot any such places (how to find them is another story). The same can done for blank lines.
• I think it usually leads to 4 keys pressed ( - char - ) with occasional 3 ( - char - ). While "word start" is usually 3 ( - ) with occasional 4 ( - ), but not taking into account navigation to a specific char in word, which is usually another two key presses (f - char). So not sure.
• I do find it better to not have to think about what key to type before special labels appear. So like "Press and type label" but for any possible visible text cell. I have an idea for a possible two-stage navigation: first filter target word and then filter target cell in the word. However, that requires taking eyes from the target cell for the first part, which is not great.

Not yet sure about this yet.

---

What I am pretty sure about is that there won't be special "remote action" mapping. Instead there will be a special "go back" mapping (like or a special key if going the single_character route) which will go to the position before the jump. This is more versatile than a separate concept of "remote action" and a <C-o> because it will be possible to jump to a previous window.

[pkazmier]

I agree with the "remote action" conclusion. I use leap and I very rarely use the remote action capability. And I never use its remote action in operator mode. When I do use it, I use the remote action which works just like a normal jump except that after you perform some action like a yank or delete, it will automatically jump back to where you were. I find that far easier than flash's operating pending mode. But, at the end of the day, is that convenience worth wasting another keybinding versus just doing a normal jump, performing some action, and C-o back? Not sure.

I will say that one of the best features that leap has is the concept of equivalence classes. It's genius. Basically, one defines characters that should be treated equivalently. For example

{ ' \t\r\n', '([{', ')]}', '\'"`' }

This means when you want to jump to something like (, you don't need to press shift 9 to reach for the left paren, but rather just press the left square bracket which doesn't require pressing shift. It's a similar idea to your b and q in 'mini.ai'—huge ergonomic wins. Leap is also case insensitive to require less use of the shift key.

[echasnovski]

But, at the end of the day, is that convenience worth wasting another keybinding versus just doing a normal jump, performing some action, and C-o back?

The issue here is that "jump back" should respect multiple windows, while <C-o> might change buffer in the current window. It is not rare (at least for me) to want to jump to split window to yank something and go back to paste it.

I will say that one of the best features that leap has is the concept of equivalence classes.

Yeah, that's a nice idea and can (somewhat straightforwardly) be implemented with the design similar to 'mini.ai' and 'mini.surround': starting jump waits for "spotter id" plus custom_spotters for adjusting that. Need to figure out a way to make it as less breaking as possible.

Edit: Or another approach would be to expand start() to accept function that returns jumping opts plus introducing something like gen_jumper.single_character(). It can then have something like configurable chars with custom effects (for blank lines / line starts, non-typeable characters, "equivalences", etc.).