Nested keymaps with v3

[ranjithshegde]

Just discovered the changes in v3. One thing I am unable to find (or does not exist) is the way to nest and group keyamps,
for example, I have things like these

    require('which-key').register {
        ['<leader>n'] = {
            name = 'Noice',
            n = { vim.cmd.Noice, 'Noice window' },
            e = { vim.cmd.NoiceErrors, 'Open error list' },
            m = { vim.cmd.messages, 'Open messages' },
            c = {
                function()
                    vim.cmd.messages 'clear'
                end,
                'Clear all messaages',
            },
        },
    }

Is this no longer possible with which-key v3? Do I need to perpend <leader>n to all subsequent keymaps?
If so, it removes some of the cleanliness and elegance in my opinion

[folke]

no longer possible

[azzamsa]

no longer possible

Any reason for this? Would you like to elaborate more?

[folke]

Why? No

[ranjithshegde]

Thanks for the quick response.
Its a shame that its no longer possible. Given that my setup uses this form extensively and for all plugins, I will simply pin to a commit once these go from deprecated to removed.

Thanks for all your hard work!

[folke]

If you do :checkhealth which-key you will get a suggested table for the new format.

[ranjithshegde]

Seeing as its already part of 'legacy' code and given people's interest, would you consider supporting this method?

[folke]

I'm not bringing that back. Sorry

[PrinceHallGA]

Is there a particular reason to why? Is it harder to maintain? I really liked this pattern when maintaining my which-key bindings.

[erooke]

This was explained elsewhere: #734 (reply in thread)

[PrinceHallGA]

Ok, I understand. Thanks for the reference!!

[erooke]

My setup also uses this form extensively. I'm working around it with this helper function

local function expand(arg)
  result = {}
  queue = { arg }

  item = table.remove(queue)
  while item do
    local children = item["children"]
    if children then
      for i, v in ipairs(children) do
        v["prefix"] = (item["prefix"] or "") .. (v["prefix"] or "")
        table.insert(queue, v)
      end

      local name = item["name"]

      if name then
        table.insert(result, { item["prefix"], group = name })
      end
    else
      item[1] = (item["prefix"] or "") .. item[1]
      item["prefix"] = nil
      table.insert(result, item)
    end

    item = table.remove(queue)
  end

  return result
end

It takes a tree structure and flattens it into the format that which-key now expect. For example, your structure would be represented as:

{
  prefix = "<leader>n",
  name = "Noice",
  children = {
    { "n", vim.cmd.Noice, desc = "Noice window" },
    { "e", vim.cmd.NoiceErrors, desc = "Open error list" },
    { "m", vim.cmd.messages, desc = "Open messages" },
    {
      "c",
      function()
        vim.cmd.messages("clear")
      end,
      desc = "Clear all messaages",
    },
  },
}

You can nest as much as you want and it only creates a group for any level you give a name to. For example you could also represent your structure as:

{
  prefix = "<leader>",
  children = {
    {
      prefix = "n",
      name = "Noice",
      children = {
        { "n", vim.cmd.Noice, desc = "Noice window" },
        { "e", vim.cmd.NoiceErrors, desc = "Open error list" },
        { "m", vim.cmd.messages, desc = "Open messages" },
        {
          "c",
          function()
            vim.cmd.messages("clear")
          end,
          desc = "Clear all messaages",
        },
      },
    },
  },
}

Its kinda noisy with all the key names but it did what I needed it to do...