[mini.pick] Augment -all- pickers with labels and hotkeys

[abeldekat]

mini_pick_labeled.mp4

Initially, I implemented Pick buffers with labels, discussed here. The motivation for doing so is also explained.

@echasnovski, I implemented your suggestion:

My mind immediately went in the direction of making a more general make_labeled_picker(). Which takes a picker source and modifies it to be "labeled":

The code is contained in a single lua module which can be loaded after mini.pick has been setup.

I was not able to follow your suggestions literally. Hopefully the comments in the code explain why.

mini_pick_labeled.lua

-- Useful when:
-- Picker has limited items (ie buffers, ui_select: hotkeys activated)
-- Picker displays most valuable results on top(ie oldfiles, visits)
local Pick = require("mini.pick")
local H = {}

-- Labels to use
H.labels = "abcdefghijklmnopqrstuvwxyz"
-- Visual clues namespace
H.ns_id = {
  labels = vim.api.nvim_create_namespace("MiniPickLabels"),
}
-- Copied
H.clear_namespace = function(buf_id, ns_id) pcall(vim.api.nvim_buf_clear_namespace, buf_id, ns_id, 0, -1) end
-- Copied
H.set_extmark = function(...) pcall(vim.api.nvim_buf_set_extmark, ...) end
-- Copied from :h MiniPick
H.make_centered_window = function()
  return {
    config = function()
      local height = math.floor(0.618 * vim.o.lines)
      local width = math.floor(0.618 * vim.o.columns)
      return {
        anchor = "NW",
        height = height,
        width = width,
        row = math.floor(0.5 * (vim.o.lines - height)),
        col = math.floor(0.5 * (vim.o.columns - width)),
      }
    end,
  }
end
-- Returns label at index
H.label_at_index = function(idx) return H.labels:sub(idx, idx) end

-- NOTE: When source.items is a schedule-wrapped function, calling set_picker_items directly,
-- overriding source.items is not possible. Example: MiniExtra.oldfiles
--
-- NOTE: When the items are strings, it's not possible to add a label field to the item
-- Example: MiniExtra.oldfiles. Oldfiles is not working when items(list of strings)
-- are transformed to items(list of { label = "<somelabel", text = "contents of item"}).
H.make_override_set_items = function(picker_set_items_orig, runtime_vars)
  local nr_of_labels = #H.labels
  return function(items, opts)
    Pick.set_picker_items = picker_set_items_orig -- items are known, restore original
    local nr_of_items = #items
    runtime_vars.items = items -- used to test equality, finding label for displayed item
    for i = 1, nr_of_labels do -- store label-item combination for the first x items
      if i > nr_of_items then break end
      local label = H.label_at_index(i)
      runtime_vars.labels_to_items[label] = items[i]
    end
    if nr_of_items <= nr_of_labels then runtime_vars.use_hotkey = true end

    -- Invoke original set_picker_items function
    picker_set_items_orig(items, opts)
  end
end

-- 1. stritems and inds are always the same on each match invocation
-- 2. items and stritems are related, having the same ordering and length.
H.make_override_match = function(match_orig)
  local labels_have_been_added = false
  local nr_of_labels = #H.labels
  return function(stritems, inds, query, do_sync)
    -- Add labels
    local nr_of_stritems = #stritems
    if not labels_have_been_added then
      for i = 1, nr_of_labels do -- label as first char, forcing selection:
        if i > nr_of_stritems then break end
        stritems[i] = string.format("%s %s", H.label_at_index(i), stritems[i])
      end
    end
    labels_have_been_added = true
    -- Invoke original match function
    return match_orig(stritems, inds, query, do_sync)
  end
end

-- Add clues to the items displayed.
H.make_override_show = function(show_orig, runtime_vars)
  local nr_of_labels = #H.labels
  return function(buf_id, items, query, opts)
    show_orig(buf_id, items, query, opts) -- invoke original show function

    local add_clues = function(idx, item_displayed, hl)
      local find_label = function()
        for label, item in pairs(runtime_vars.labels_to_items) do
          if item == item_displayed then return label end
        end
      end
      local label = find_label()
      if not label then return end

      local virt_text = { { string.format("[%s]", label), hl } }
      local extmark_opts = { hl_mode = "combine", priority = 200, virt_text = virt_text, virt_text_pos = "eol" }
      H.set_extmark(buf_id, H.ns_id.labels, idx - 1, 0, extmark_opts)
    end
    local submit = function()
      local key = vim.api.nvim_replace_termcodes("<cr>", true, false, true)
      vim.api.nvim_feedkeys(key, "n", false)
      vim.api.nvim_feedkeys("<Ignore>", "n", false) -- prevent extra cr cursor movement
    end

    H.clear_namespace(buf_id, H.ns_id.labels) -- remove virtual clues and hl
    local use_hotkey = runtime_vars.use_hotkey
    for i, item_displayed in ipairs(items) do
      if i > nr_of_labels then break end -- item can't have a label
      add_clues(i, item_displayed, use_hotkey and #query == 0 and "MiniPickMatchRanges" or "Comment")
    end
    if use_hotkey and #query == 1 and vim.tbl_contains(vim.tbl_keys(runtime_vars.labels_to_items), query[1]) then
      submit()
    end
  end
end

H.make_override_start = function(start_orig)
  return function(opts)
    Pick.start = start_orig -- Picker started, restore original
    local runtime_vars = {
      items = {}, -- Pick.get_picker_items returns a deepcopy, preventing simple equality test
      use_hotkey = false, -- Only when all items are labeled a hotkey can be used
      labels_to_items = {}, -- Key is the label, value is corresponding item
    }
    Pick.set_picker_items = H.make_override_set_items(Pick.set_picker_items, runtime_vars)
    opts.source.match = H.make_override_match(opts.source.match or Pick.default_match)
    opts.source.show = H.make_override_show(opts.source.show or Pick.default_show, runtime_vars)

    -- Invoke the original Pick.start:
    return start_orig(opts)
  end
end

H.make_labeled_ui_select = function()
  return function(items, opts, on_choice)
    -- Override Pick.start before picker_func executes:
    Pick.start = H.make_override_start(Pick.start)
    -- Invoke Pick.ui_select
    Pick.ui_select(items, opts, on_choice)
  end
end

-- https://github.com/echasnovski/mini.nvim/discussions/1096
-- Notion of a picker func: Any function calling Pick.start
--
-- Advantage of this approach:
-- 1. The picker function is responsible for both items and show
-- 2. Reusability(no need to copy code from Pick.builtin.*)
-- Drawback: Another level of abstraction, decorating Pick.start temporarily
H.make_labeled = function(picker_func)
  return function(local_opts, start_opts)
    -- Override Pick.start before picker_func executes:
    Pick.start = H.make_override_start(Pick.start)
    -- Invoke the picker function:
    picker_func(local_opts, start_opts)
  end
end

-- POC: Override pickers defined in ak/config/editor/mini_pick.lua

-- Most relevant usage of labels in a picker because hotkeys are likely to be activated
Pick.registry.labeled_buffers = function(local_opts, _)
  local show_icons = true -- default true in Pick.builtin.buffers
  local source = { show = not show_icons and Pick.default_show or nil }
  local window = true and H.make_centered_window() or nil -- consistency with grapple
  local opts = { source = source, window = window }

  local picker_func = H.make_labeled(Pick.builtin.buffers)
  picker_func(local_opts, opts)
end

Pick.registry.labeled_lsp = function(local_opts, opts)
  local picker_func = H.make_labeled(MiniExtra.pickers.lsp)
  picker_func(local_opts, opts)
end

Pick.registry.labeled_oldfiles = function(local_opts, opts)
  local picker_func = H.make_labeled(MiniExtra.pickers.oldfiles)
  picker_func(local_opts, opts)
end

Pick.registry.labeled_history = function(local_opts, opts)
  local picker_func = H.make_labeled(MiniExtra.pickers.history)
  picker_func(local_opts, opts)
end

-- Not useful, top results have no extra value for the user
Pick.registry.labeled_files = function(local_opts, opts)
  local picker_func = H.make_labeled(Pick.builtin.files)
  picker_func(local_opts, opts)
end

Pick.registry.labeled_ui_select = function(items, opts, on_choice)
  local picker_ui_select = H.make_labeled_ui_select()
  picker_ui_select(items, opts, on_choice)
end

local map = vim.keymap.set
map("n", "<leader>;", Pick.registry.labeled_buffers, { desc = "Labeled buffers pick", silent = true })
map(
  "n",
  "<leader>b",
  function() Pick.registry.labeled_lsp({ scope = "document_symbol" }, {}) end,
  { desc = "Labeled buffer symbols", silent = true }
)
map(
  "n",
  "<leader>r",
  function() Pick.registry.labeled_oldfiles({ current_dir = true }, {}) end,
  { desc = "Labeled recent (rel)", silent = true }
)
map("n", "<leader>f:", function() Pick.registry.labeled_history({ scope = ":" }) end, { desc = "Labeled ':' history" })
map("n", "<leader>ff", Pick.registry.labeled_files, { desc = "Labeled files", silent = true })
map("n", "<leader>fU", function()
  vim.ui.select = Pick.registry.labeled_ui_select -- Pick.ui_select
  local hello = "Hello"
  vim.ui.select({ hello, "Helloo", "Hellooo", "Helloooo", "Hellooooo", "Helloooooo" }, {
    prompt = "Choose your Hello version",
  }, function(choice)
    if not choice then return end
    hello = choice
  end)
  vim.notify(hello)
end, { desc = "Labeled files", silent = true })
-- Pick.setup({})

EDIT: 20240805, refactored version

mini_pick_labeled

local Pick = require("mini.pick")

-- L: Labeled pickers. Useful when:
-- Picker has limited items (ie buffers, ui_select: hotkeys activated)
-- Picker displays most valuable results on top(ie oldfiles, visits)
-- Less useful: Pick.files, top results have no extra meaning
local L = {}

L.invert = function(tbl_in)
  local tbl_out = {}
  -- stylua: ignore
  for idx, l in ipairs(tbl_in) do tbl_out[l] = idx end
  return tbl_out
end
L.labels = vim.split("abcdefghijklmnopqrstuvwxyz", "")
L.labels_inv = L.invert(L.labels)
L.ns_id = { labels = vim.api.nvim_create_namespace("MiniPickLabels") } -- clues

-- Copied from mini.pick:
L.clear_namespace = function(buf_id, ns_id) pcall(vim.api.nvim_buf_clear_namespace, buf_id, ns_id, 0, -1) end
L.set_extmark = function(...) pcall(vim.api.nvim_buf_set_extmark, ...) end
L.make_centered_window = function() -- Copied from :h MiniPick
  return {
    config = function()
      local height = math.floor(0.618 * vim.o.lines)
      local width = math.floor(0.618 * vim.o.columns)
      return {
        anchor = "NW",
        height = height,
        width = width,
        row = math.floor(0.5 * (vim.o.lines - height)),
        col = math.floor(0.5 * (vim.o.columns - width)),
      }
    end,
  }
end

L.make_override_match = function(match, data)
  -- premisse: items and stritems are constant and related, having the same ordering and length.
  return function(stritems, inds, query, do_sync)
    -- Restore previously modified stritem
    if data.idx_selected then
      local idx = data.idx_selected
      stritems[idx] = string.sub(stritems[idx], 2)
    end
    data.idx_selected = nil

    -- Can query hold a label
    if #query ~= 1 then return match(stritems, inds, query, do_sync) end

    -- Find label idx
    local char = query[1]
    local label_idx = L.labels_inv[char]
    if not label_idx or label_idx > data.max_labels then return match(stritems, inds, query, do_sync) end

    -- Apply label: In most cases, the items is shown as first item in list
    stritems[label_idx] = string.format("%s%s", char, stritems[label_idx])
    data.idx_selected = label_idx -- remember to restore stritem if needed on next query input
    return match(stritems, inds, query, do_sync)
  end
end

L.make_override_show = function(show, data)
  local enter_key = vim.api.nvim_replace_termcodes("<cr>", true, true, true)
  local first_item -- detect scrolling
  local autosubmit -- all available items must fit in window and have a label
  return function(buf_id, items, query, opts) -- items are items --displayed--
    if data.idx_selected and autosubmit then -- label matched
      vim.api.nvim_feedkeys(enter_key, "n", false)
      vim.api.nvim_feedkeys("<Ignore>", "n", false)
      return
    end

    if not first_item then first_item = items[1] end
    if not autosubmit then
      data.max_labels = math.min(#L.labels, #items)
      autosubmit = #(Pick.get_picker_items() or {}) == data.max_labels
    end

    show(buf_id, items, query, opts)
    L.clear_namespace(buf_id, L.ns_id.labels)
    if not (#query == 0 and first_item == items[1]) then return end

    local hl = autosubmit and "MiniPickMatchRanges" or "Comment"
    for i, label in ipairs(L.labels) do
      if i > data.max_labels then break end
      local virt_text = { { string.format("[%s]", label), hl } }
      local extmark_opts = { hl_mode = "combine", priority = 200, virt_text = virt_text, virt_text_pos = "eol" }
      L.set_extmark(buf_id, L.ns_id.labels, i - 1, 0, extmark_opts)
    end
  end
end

L.make_override_choose = function(choose, data)
  -- must override, in edge cases the items is not shown as first item in list
  return function(item)
    if data.idx_selected then item = Pick.get_picker_items()[data.idx_selected] end
    return choose(item)
  end
end

-- Override public function Pick.start temporarily
-- Only needed to reuse code in Pick.builtin and Extra.pickers
L.make_override_start = function(start)
  return function(opts)
    Pick.start = start -- Picker started, restore original
    local data = {
      idx_selected = nil, -- set in match when label is detected
      max_labels = nil, -- set in show
    }
    opts.source.match = L.make_override_match(opts.source.match or Pick.default_match, data)
    opts.source.show = L.make_override_show(opts.source.show or Pick.default_show, data)
    opts.source.choose = L.make_override_choose(opts.source.choose or Pick.default_choose, data)

    return start(opts)
  end
end

-- https://github.com/echasnovski/mini.nvim/discussions/1109
L.make_labeled_ui_select = function()
  return function(items, opts, on_choice)
    Pick.start = L.make_override_start(Pick.start)
    Pick.ui_select(items, opts, on_choice)
  end
end

-- https://github.com/echasnovski/mini.nvim/discussions/1109
L.make_labeled = function(picker_func)
  return function(local_opts, start_opts)
    Pick.start = L.make_override_start(Pick.start)
    picker_func(local_opts, start_opts)
  end
end

Pick.registry.labeled_buffers = function(local_opts, _)
  local show_icons = true
  local source = { show = not show_icons and Pick.default_show or nil }
  local window = true and L.make_centered_window() or nil
  local opts = { source = source, window = window }

  local picker_func = L.make_labeled(Pick.builtin.buffers)
  picker_func(local_opts, opts)
end

Pick.registry.labeled_lsp = function(local_opts, opts)
  local picker_func = L.make_labeled(MiniExtra.pickers.lsp)
  picker_func(local_opts, opts)
end

Pick.registry.labeled_oldfiles = function(local_opts, opts)
  local picker_func = L.make_labeled(MiniExtra.pickers.oldfiles)
  picker_func(local_opts, opts)
end

Pick.registry.labeled_history = function(local_opts, opts)
  local picker_func = L.make_labeled(MiniExtra.pickers.history)
  picker_func(local_opts, opts)
end

-- Use vim.ui.select = Pick.registry.labeled_ui_select -- Pick.ui_select
Pick.registry.labeled_ui_select = function(items, opts, on_choice)
  local picker_ui_select = L.make_labeled_ui_select()
  picker_ui_select(items, opts, on_choice)
end

local map = vim.keymap.set

local buffers = Pick.registry.labeled_buffers
map("n", "<leader>;", buffers, { desc = "Labeled buffers pick", silent = true })

local lsp = function() Pick.registry.labeled_lsp({ scope = "document_symbol" }, {}) end
map("n", "<leader>b", lsp, { desc = "Labeled buffer symbols", silent = true })

local oldfiles = function() Pick.registry.labeled_oldfiles({ current_dir = true }, {}) end
map("n", "<leader>r", oldfiles, { desc = "Labeled recent (rel)", silent = true })

local his = function() Pick.registry.labeled_history({ scope = ":" }) end
map("n", "<leader>f:", his, { desc = "Labeled ':' history" })

local hellos = { "hello", "Helloo", "Hellooo", "Helloooo", "Hellooooo", "Helloooooo" }
local on_choice = function(choice)
  if not choice then return end
  vim.notify(choice)
end
local ui_select = function()
  local org = vim.ui.select
  vim.ui.select = Pick.registry.labeled_ui_select -- Pick.ui_select
  vim.ui.select(hellos, { prompt = "Say hi" }, on_choice)
  vim.ui.select = org
end
map("n", "<leader>fU", ui_select, { desc = "Labeled ui select", silent = true })

EDIT: 20240808, Using autocommand MiniPickStart:

mini_pick_labeled

-- Edge cases that are hard to fix:
-- 1:
-- a. Pick buffers, labeled, lots of buffers starting with "lua", autosubmit is not active
-- b. Press label 'l'(also first letter of "lua")
-- c  Note that the labeled item is -not- placed as first item in the list
-- d. Press enter
-- e.  Note that the labeled item is opened correctly, instead of the first item displayed

local Pick = require("mini.pick")
local Extra = require("mini.extra")

-- ELP: "Extra Labeled Picker"" functionality. Could be added to "H" in "mini.extra"
-- Useful when: Picker has limited items (ie buffers, ui_select: hotkeys activated)
-- Useful when: Picker displays most valuable results on top(ie oldfiles, visits)
-- Less useful: Pick.files, top results have no extra meaning
local ELP = {}

-- Helper data ================================================================

ELP.invert = function(tbl_in)
  local tbl_out = {}
  -- stylua: ignore
  for idx, l in ipairs(tbl_in) do tbl_out[l] = idx end
  return tbl_out
end
ELP.labels = vim.split("abcdefghijklmnopqrstuvwxyz", "")
ELP.labels_inv = ELP.invert(ELP.labels)
ELP.ns_id = { labels = vim.api.nvim_create_namespace("MiniExtraLabeledPick") } -- clues

-- Copied from mini.pick:
ELP.clear_namespace = function(buf_id, ns_id) pcall(vim.api.nvim_buf_clear_namespace, buf_id, ns_id, 0, -1) end
ELP.set_extmark = function(...) pcall(vim.api.nvim_buf_set_extmark, ...) end
ELP.ui_select_marker = "+ELP+"

-- Copied from :h MiniPick
ELP.make_centered_window = function()
  return {
    config = function()
      local height = math.floor(0.618 * vim.o.lines)
      local width = math.floor(0.618 * vim.o.columns)
      return {
        anchor = "NW",
        height = height,
        width = width,
        row = math.floor(0.5 * (vim.o.lines - height)),
        col = math.floor(0.5 * (vim.o.columns - width)),
      }
    end,
  }
end

ELP.make_override_match = function(match, data)
  -- premisse: items and stritems are constant and related, having the same ordering and length.
  return function(stritems, inds, query, do_sync)
    -- Restore previously modified stritem
    if data.idx_selected then
      local idx = data.idx_selected
      stritems[idx] = string.sub(stritems[idx], 2)
    end
    data.idx_selected = nil

    -- Can query hold a label
    if #query ~= 1 then return match(stritems, inds, query, do_sync) end

    -- Find label idx
    local char = query[1]
    local label_idx = ELP.labels_inv[char]
    if not label_idx or label_idx > data.max_labels then return match(stritems, inds, query, do_sync) end

    -- Apply label: In most cases, the item is shown as first item in list
    stritems[label_idx] = string.format("%s%s", char, stritems[label_idx])
    data.idx_selected = label_idx -- remember to restore stritem if needed on next query input
    return match(stritems, inds, query, do_sync)
  end
end

ELP.make_override_show = function(show, data)
  local enter_key = vim.api.nvim_replace_termcodes("<cr>", true, true, true)
  local first_item -- detect scrolling
  local autosubmit -- all available items must fit in window and have a label
  return function(buf_id, items, query, opts) -- items are items --displayed--
    if data.idx_selected and autosubmit then -- label matched
      vim.api.nvim_feedkeys(enter_key, "n", false)
      vim.api.nvim_feedkeys("<Ignore>", "n", false)
      return
    end

    if not first_item then first_item = items[1] end
    if not autosubmit then
      data.max_labels = math.min(#ELP.labels, #items)
      autosubmit = #(Pick.get_picker_items() or {}) == data.max_labels
    end

    show(buf_id, items, query, opts)
    ELP.clear_namespace(buf_id, ELP.ns_id.labels)
    if not (#query == 0 and first_item == items[1]) then return end

    local hl = autosubmit and "MiniPickMatchRanges" or "Comment"
    for i, label in ipairs(ELP.labels) do
      if i > data.max_labels then break end
      local virt_text = { { string.format("[%s]", label), hl } }
      local extmark_opts = { hl_mode = "combine", priority = 200, virt_text = virt_text }

      -- Add clue to start or end of line, or both:
      for _, virt_text_pos in ipairs({ "eol" }) do -- { "inline", "eol" }
        extmark_opts.virt_text_pos = virt_text_pos
        ELP.set_extmark(buf_id, ELP.ns_id.labels, i - 1, 0, extmark_opts)
      end
    end
  end
end

ELP.make_override_choose = function(choose, data)
  -- must override, in edge cases the item is not shown first in the list
  return function(item)
    if data.idx_selected then item = Pick.get_picker_items()[data.idx_selected] end
    return choose(item)
  end
end

ELP.on_pick_start = function()
  local opts = Pick.get_picker_opts()
  if not opts then return end

  local label = opts.label
  local src = opts.source
  if label == nil and src.name and string.sub(src.name, 1, #ELP.ui_select_marker) == ELP.ui_select_marker then
    src.name = string.sub(src.name, #ELP.ui_select_marker + 1)
    label = true -- vim.ui.select is set to labeled_ui_select
  end
  if not label then return end

  local data = {
    idx_selected = nil, -- set in match when label is detected
    max_labels = nil, -- set in show
  }
  src.match = ELP.make_override_match(src.match, data)
  src.show = ELP.make_override_show(src.show, data)
  src.choose = ELP.make_override_choose(src.choose, data)
  Pick.set_picker_opts(opts)
end

-- Public  ================================================================

-- Take opts.label into account and override opts.source.{match, show, choose}
Extra.pickers_enable_label_in_options = function()
  local group = vim.api.nvim_create_augroup("miniextra-labeled-pick", { clear = true })
  vim.api.nvim_create_autocmd("User", {
    pattern = "MiniPickStart",
    group = group,
    desc = "Augment pickers with labels",
    callback = ELP.on_pick_start,
  })
end

Extra.pickers.labeled_ui_select = function(items, opts, on_choice)
  if not opts.prompt then opts.prompt = "Select one of:" end -- explicitly set default
  opts.prompt = string.format("%s%s", ELP.ui_select_marker, opts.prompt)
  Pick.ui_select(items, opts, on_choice)
end

-- POC ================================================================

Extra.pickers_enable_label_in_options() -- take opts = { label = true } into account
vim.ui.select = Extra.pickers.labeled_ui_select
local map = vim.keymap.set

local labeled_buffers = function()
  local show_icons = true
  local source = { show = not show_icons and Pick.default_show or nil }
  local window = true and ELP.make_centered_window() or nil
  local opts = { label = true, source = source, window = window }

  Pick.builtin.buffers({}, opts)
end
map("n", "<leader>;", labeled_buffers, { desc = "Labeled buffers pick", silent = true })

local labeled_lsp = function() Extra.pickers.lsp({ scope = "document_symbol" }, { label = true }) end
map("n", "<leader>b", labeled_lsp, { desc = "Labeled buffer symbols", silent = true })

local labeled_oldfiles = function() Extra.pickers.oldfiles({ current_dir = true }, { label = true }) end
map("n", "<leader>r", labeled_oldfiles, { desc = "Labeled recent (rel)", silent = true })

local labeled_his = function() Extra.pickers.history({ scope = ":" }, { label = true }) end
map("n", "<leader>f:", labeled_his, { desc = "Labeled ':' history" })

local on_choice = function(choice)
  if not choice then return end
  vim.notify(choice)
end
local select_hello = function() vim.ui.select({ "Hello", "Helloooo", "Helloooooo" }, { prompt = "Say hi" }, on_choice) end
map("n", "<leader>fU", select_hello, { desc = "Labeled ui select", silent = true })

-- Pick.setup()

EDIT: 20240811, fixed special case:

mini_pick_labeled

local Pick = require("mini.pick")
local Extra = require("mini.extra")

-- Helper data ================================================================

-- ELP: "Extra Labeled Picker" feature. Has similar purpose as "H = {}" in mini.extra
-- Useful when: Picker has limited items (ie buffers, ui_select: hotkeys activated)
-- Useful when: Picker displays most valuable results on top(ie oldfiles, visits)
-- Less useful: Pick.files, top results have no extra meaning
local ELP = {}

ELP.labels = vim.split("abcdefghijklmnopqrstuvwxyz", "") -- configurable
ELP.virt_clues_pos = { "eol" } -- configurable { "inline" }, { "inline", "eol"}

ELP.invert = function(tbl_in)
  local tbl_out = {}
  -- stylua: ignore
  for idx, l in ipairs(tbl_in) do tbl_out[l] = idx end
  return tbl_out
end
ELP.labels_inv = ELP.invert(ELP.labels)
ELP.ns_id = { labels = vim.api.nvim_create_namespace("MiniExtraLabeledPick") } -- clues
ELP.ui_select_marker = "+ELP+"

-- Copied from mini.pick:
ELP.clear_namespace = function(buf_id, ns_id) pcall(vim.api.nvim_buf_clear_namespace, buf_id, ns_id, 0, -1) end
ELP.set_extmark = function(...) pcall(vim.api.nvim_buf_set_extmark, ...) end

ELP.make_override_match = function(match, picker_ctx)
  -- premisse: items and stritems are constant and related, having the same ordering and length.
  return function(stritems, inds, query, do_sync)
    -- Restore previously modified stritem if present
    if picker_ctx.labeled_ind then
      stritems[picker_ctx.labeled_ind] = string.sub(stritems[picker_ctx.labeled_ind], 2)
    end
    picker_ctx.labeled_ind = nil

    -- Query only holds a potential label when it contains 1 single char
    if #query ~= 1 then return match(stritems, inds, query, do_sync) end

    -- Find index of potential label
    local char = query[1]
    local labeled_ind = ELP.labels_inv[char]
    if not labeled_ind or labeled_ind > picker_ctx.max_labels then return match(stritems, inds, query, do_sync) end

    -- Valid label: Make sure the item is matched
    picker_ctx.labeled_ind = labeled_ind
    stritems[labeled_ind] = string.format("%s%s", char, stritems[labeled_ind])
    return match(stritems, inds, query, do_sync)
  end
end

ELP.autosubmit = function()
  local enter_key = vim.api.nvim_replace_termcodes("<cr>", true, true, true)

  vim.api.nvim_feedkeys(enter_key, "n", false)
  vim.api.nvim_feedkeys("<Ignore>", "n", false)
end

ELP.add_clues = function(buf_id, max_labels, autosubmit)
  local hl = autosubmit and "MiniPickMatchRanges" or "Comment"
  for i, label in ipairs(ELP.labels) do
    if i > max_labels then break end
    local virt_text = { { string.format("[%s]", label), hl } }
    local extmark_opts = { hl_mode = "combine", priority = 200, virt_text = virt_text }

    -- Add clue to start or end of line, or both:
    for _, virt_text_pos in ipairs(ELP.virt_clues_pos) do
      extmark_opts.virt_text_pos = virt_text_pos
      ELP.set_extmark(buf_id, ELP.ns_id.labels, i - 1, 0, extmark_opts)
    end
  end
end

ELP.make_initial_ctx = function(items, picker_ctx)
  if not picker_ctx.max_labels then picker_ctx.max_labels = math.min(#ELP.labels, #items) end
  local all_items = Pick.get_picker_items() or {}

  local ctx = {}
  ctx.first_item = items[1] or {}
  ctx.autosubmit = #all_items == picker_ctx.max_labels
  return ctx
end

ELP.set_labeled_as_first_item = function(all_inds, labeled_ind)
  local labeled_ind_pos
  for i, ind in ipairs(all_inds) do
    if ind == labeled_ind then
      labeled_ind_pos = i
      break
    end
  end
  table.remove(all_inds, labeled_ind_pos)
  table.insert(all_inds, 1, labeled_ind)
  Pick.set_picker_match_inds(all_inds)
end

ELP.make_override_show = function(show, picker_ctx)
  local ctx
  return function(buf_id, items, query, opts) -- items contain as many as displayed
    if not ctx then ctx = ELP.make_initial_ctx(items, picker_ctx) end
    ELP.clear_namespace(buf_id, ELP.ns_id.labels) -- remove clues

    -- Query does not contain a valid label
    if not picker_ctx.labeled_ind then
      show(buf_id, items, query, opts)

      -- Only add clues when query is empty and window is not scrolled
      if #query == 0 and ctx.first_item == items[1] then
        ELP.add_clues(buf_id, picker_ctx.max_labels, ctx.autosubmit)
      end
      return
    end

    -- Query contains valid label. Make sure item is first in the list
    local all_inds = (Pick.get_picker_matches() or {}).all_inds
    if picker_ctx.labeled_ind ~= all_inds[1] then
      ELP.set_labeled_as_first_item(all_inds, picker_ctx.labeled_ind)
      return
    end

    -- Either autosubmit labeled item or show items with item first in the list
    if ctx.autosubmit then
      ELP.autosubmit()
    else
      show(buf_id, items, query, opts)
    end
  end
end

ELP.on_pick_start_event = function()
  local opts = Pick.get_picker_opts()
  if not opts then return end

  local label = opts.label
  local src = opts.source
  if label == nil and string.sub(src.name, 1, #ELP.ui_select_marker) == ELP.ui_select_marker then
    src.name = string.sub(src.name, #ELP.ui_select_marker + 1)
    label = true -- vim.ui.select is set to Extra.pickers.labeled_ui_select
  end
  if not label then return end

  local picker_ctx = { labeled_ind = nil, max_labels = nil }
  src.match = ELP.make_override_match(src.match, picker_ctx)
  src.show = ELP.make_override_show(src.show, picker_ctx)
  Pick.set_picker_opts(opts)
end

-- Public  ================================================================

-- Take opts.label into account and override opts.source.{match, show, choose}
Extra.pickers_enable_label_in_options = function()
  local group = vim.api.nvim_create_augroup("miniextra-labeled-pick", { clear = true })
  vim.api.nvim_create_autocmd("User", {
    pattern = "MiniPickStart",
    group = group,
    desc = "Augment pickers with labels",
    callback = ELP.on_pick_start_event,
  })
end

Extra.pickers.labeled_ui_select = function(items, opts, on_choice)
  if not opts.prompt then opts.prompt = "Select one of:" end -- explicitly set default
  opts.prompt = string.format("%s%s", ELP.ui_select_marker, opts.prompt)
  Pick.ui_select(items, opts, on_choice)
end

-- POC ================================================================

local make_centered_window = function() -- copied from :h MiniPick
  return {
    config = function()
      local height = math.floor(0.618 * vim.o.lines)
      local width = math.floor(0.618 * vim.o.columns)
      return {
        anchor = "NW",
        height = height,
        width = width,
        row = math.floor(0.5 * (vim.o.lines - height)),
        col = math.floor(0.5 * (vim.o.columns - width)),
      }
    end,
  }
end

Extra.pickers_enable_label_in_options()
vim.ui.select = Extra.pickers.labeled_ui_select
local map = vim.keymap.set

local files = function() Pick.builtin.files() end
map("n", "<leader><leader>", files, { desc = "Files pick" })

local labeled_buffers = function()
  local show_icons = true
  local source = { show = not show_icons and Pick.default_show or nil }
  local window = true and make_centered_window() or nil
  local opts = { label = true, source = source, window = window }

  Pick.builtin.buffers({}, opts)
end
map("n", "<leader>;", labeled_buffers, { desc = "Labeled buffers pick", silent = true })

local labeled_lsp = function() Extra.pickers.lsp({ scope = "document_symbol" }, { label = true }) end
map("n", "<leader>b", labeled_lsp, { desc = "Labeled buffer symbols", silent = true })

local labeled_oldfiles = function() Extra.pickers.oldfiles({ current_dir = true }, { label = true }) end
map("n", "<leader>r", labeled_oldfiles, { desc = "Labeled recent (rel)", silent = true })

local labeled_his = function() Extra.pickers.history({ scope = ":" }, { label = true }) end
map("n", "<leader>f:", labeled_his, { desc = "Labeled ':' history" })

local on_choice = function(choice)
  if not choice then return end
  vim.notify(choice)
end
local select_hello = function() vim.ui.select({ "Hello", "Helloooo", "Helloooooo" }, { prompt = "Say hi" }, on_choice) end
map("n", "<leader>fy", select_hello, { desc = "Labeled ui select", silent = true })

-- Pick.setup()

EDIT 20240826, latest version(20260710):

I refactored the code into a separate internal module: akextra.pick_hinted

pick_hinted

---@diagnostic disable: undefined-global
-- "Picker with hints" feature. See https://github.com/echasnovski/mini.nvim/discussions/1109
-- Useful when:
-- 1. Picker has limited items (ie buffers, ui_select: hotkeys activated)
-- 2. Picker displays most valuable results on top(ie oldfiles, visits)
-- Less useful: Pick.files, top results have no extra meaning
--
-- Requirements: MiniPick active
--[[

  -- Example usage
  require('mini.extra').setup()
  require('mini.pick').setup()
  require('<this_file').setup()
  vim.ui.select = function(items, opts, on_choice)
    local start_opts = { hinted = { enable = true, use_autosubmit = true } }
    return MiniPick.ui_select(items, opts, on_choice, start_opts)
  end
  MiniPick.registry.oldfiles_hinted = function(local_opts)
    MiniExtra.pickers.oldfiles(local_opts, { hinted = { enable = true } })
  end
  -- ... etc

--]]

-- Config to merge into MiniPick.start(opts)
-- Override by providing (parts of) the config to opts:
-- 1. Pick.start(opts)
-- 2. SomePicker(local_opts, opts)
local config = {
  hinted = {
    enable = false, -- opt-in per picker
    chars = vim.split('adefhilmnorstu', ''),
    virt_clues_pos = { 'eol' }, -- or { "inline", "eol" }, { "eol "}
    use_autosubmit = false, -- opt-in to autosubmit per picker
  },
}
local ns_ids = { hinted = vim.api.nvim_create_namespace('PickHinted') }
local keys = {
  cr = vim.api.nvim_replace_termcodes('<CR>', true, true, true),
}

-- Copied from mini.pick:
local clear_namespace = function(buf_id, ns_id) pcall(vim.api.nvim_buf_clear_namespace, buf_id, ns_id, 0, -1) end
local set_extmark = function(...) pcall(vim.api.nvim_buf_set_extmark, ...) end
-- End copied from mini.pick

local invert = function(tbl_in)
  local tbl_out = {}
  -- stylua: ignore
  for idx, l in ipairs(tbl_in) do tbl_out[l] = idx end
  return tbl_out
end

local make_override_match = function(match, ctx, picker_opts)
  local hinted_chars_inv = invert(picker_opts.hinted.chars)

  -- premisse: items and stritems are constant and related, having the same ordering and length.
  return function(stritems, inds, query, opts)
    -- Restore previously modified stritem if present
    if ctx.hinted_index then stritems[ctx.hinted_index] = string.sub(stritems[ctx.hinted_index], 2) end
    ctx.hinted_index = nil

    -- No hint: Query only holds a potential hint when it contains 1 single char
    if #query ~= 1 then return match(stritems, inds, query, opts) end

    -- Find index of potential hint
    local char = query[1]
    local hinted_index = hinted_chars_inv[char]
    if not hinted_index or hinted_index > ctx.max_hints then return match(stritems, inds, query, opts) end

    -- Valid hint
    stritems[hinted_index] = string.format('%s%s', char, stritems[hinted_index]) -- ensure item is matched
    local result = match(stritems, inds, query, opts)
    local matches = MiniPick.get_picker_matches() or {} -- ensure item is current
    if hinted_index ~= matches.current_ind then MiniPick.set_picker_match_inds({ hinted_index }, 'current') end
    ctx.hinted_index = hinted_index
    return result
  end
end

local add_hints = function(buf_id, max_hints, do_autosubmit, picker_opts)
  local hl = do_autosubmit and 'MiniPickMatchRanges' or 'Comment'
  for i, hint in ipairs(picker_opts.hinted.chars) do
    if i > max_hints then break end
    local virt_text = { { string.format('[%s]', hint), hl } }
    local extmark_opts = { hl_mode = 'combine', priority = 200, virt_text = virt_text }

    -- Add hint to start or end of line, or both:
    for _, virt_text_pos in ipairs(picker_opts.hinted.virt_clues_pos) do
      extmark_opts.virt_text_pos = virt_text_pos
      set_extmark(buf_id, ns_ids.hinted, i - 1, 0, extmark_opts)
    end
  end
end

local init_show_ctx = function(items, ctx, picker_opts)
  if not ctx.max_hints then ctx.max_hints = math.min(#picker_opts.hinted.chars, #items) end
  local all_items = MiniPick.get_picker_items() or {}

  local result = {}
  result.first_item = items[1] or {}
  result.do_autosubmit = ctx.use_autosubmit and #all_items == ctx.max_hints
  result.did_autosubmit = false

  return result
end

local make_override_show = function(show, ctx, picker_opts)
  local show_ctx
  return function(buf_id, items, query, opts) -- items contain as many as displayed
    if not show_ctx then show_ctx = init_show_ctx(items, ctx, picker_opts) end
    clear_namespace(buf_id, ns_ids.hinted) -- remove hints

    -- No hint, create hints if applicable
    if ctx.hinted_index == nil then
      show(buf_id, items, query, opts)
      if #query == 0 and show_ctx.first_item == items[1] then
        -- Only add hints when query is empty and window is not scrolled
        add_hints(buf_id, ctx.max_hints, show_ctx.do_autosubmit, picker_opts)
      end
      return
    end

    -- Valid hint
    if show_ctx.do_autosubmit then -- autosubmit
      if not show_ctx.did_autosubmit then
        show_ctx.did_autosubmit = true
        vim.api.nvim_feedkeys(keys.cr, 'n', true)
      end
      return
    end
    show(buf_id, items, query, opts) -- no autosubmit
  end
end

local on_pick_start_event = function()
  local picker_opts = vim.tbl_deep_extend('force', config, MiniPick.get_picker_opts() or {})
  if not picker_opts.hinted.enable then return end -- opt-in per picker...

  local use_autosubmit = picker_opts.hinted.use_autosubmit
  local runtime_ctx = { hinted_index = nil, max_hints = nil, use_autosubmit = use_autosubmit }
  local src = picker_opts.source
  src.match = make_override_match(src.match, runtime_ctx, picker_opts)
  src.show = make_override_show(src.show, runtime_ctx, picker_opts)
  MiniPick.set_picker_opts(picker_opts)
end

-- Enable hints in pickers
-- Opt-in, add "hinted = { enable = true }" to opts:
-- 1. MiniPick.start(opts)
-- 2. SomePicker(local_opts, opts)
local PickHinted = {}
PickHinted.setup = function()
  _G.PickHinted = PickHinted
  local augroup = vim.api.nvim_create_augroup('PickHinted', {})
  local au = function(event, pattern, callback, desc)
    vim.api.nvim_create_autocmd(event, { group = augroup, pattern = pattern, callback = callback, desc = desc })
  end
  au('User', 'MiniPickStart', on_pick_start_event, 'Augment pickers with hints')
end
return PickHinted

[echasnovski]

That's a huge amount of tweaking and looks nice!

My initial hope was that implementing a more general "make picker labeled" function was going to be somehow cleaner. But indeed having to override MiniPick.set_picker_items() is not that clean. Oh, well :) An overall idea of "labeled pick" is indeed an interesting one and glad it works for you!

Couple of thoughts:

• I'd personally have H.labels = vim.split("abcdefghijklmnopqrstuvwxyz", "") and H.label_at_index(idx) then transforms into H.labels[idx] (and removes extra string.sub()).
• My initial idea was to not override MiniPick.start() but instead to (somehow) tweak picker's source data. However, with overall asynchronous stuff going on, overriding start() might indeed be a cleaner approach.

[wroyca]

Nice!

I'll ponder a bit, but it still seems like a bit too much to be included directly in 'mini.extra'. Sorry.

Perhaps now is a good time to figure out how we could share such mini snippet and modification in a way that doesnt get lost in github discussion? :D Perhaps some wiki where anyone can just contribute whatever without any kind of quality control ?

Or perhaps a mini.community module? ;)

[echasnovski]

Perhaps now is a good time to figure out how we could share such mini snippet and modification in a way that doesnt get lost in github discussion? :D Perhaps some wiki where anyone can just contribute whatever without any kind of quality control ?

Yes, creating a wiki with proper structure and non-trivial content is something I've meant to do for about 2 years now. However, it will have quality control, as it will be associated with 'mini.nvim' itself.

Having examples in "Show and tell" discussion category seems to be a reasonably good place for now.

[abeldekat]

@echasnovski No sorry needed. I enjoyed our interaction, and the corresponding improvements in the code. Do let me know if you have made your decision.

@wroyca A mini.community(akin Astrocommunity) is a very good idea! I do think quality control is important. This section already provides the opportunity to verify the validity of approach/code.

[abeldekat]

I fixed the special case:

1. Pick buffers, labeled, lots of buffers starting with "lua", autosubmit is not active
2. Press label 'l'(also first letter of "lua")
3. Note that the labeled item is -not- placed as first item in the list
4. Press enter
5. Note that the labeled item is opened correctly, because choose is overridden

In order to do so, I had to rethink the approach once more.

1. In match, if label is valid, add label to item, in order to ensure that item is matched and shown.
2. In show, if label is valid, make sure that item is first in the list. Use Pick.set_picker_match_inds(all_inds) if necessary.
3. No need to override choose

I tested the code trying many use-cases, covering the features mini.pick provides. It seems to work just fine.

I'll ponder a bit, but it still seems like a bit too much to be included directly in 'mini.extra'. Sorry.

I understand that the feature is a bit too much, and agree.

mini_pick_labeled, autocommand, without overriding choose

local Pick = require("mini.pick")
local Extra = require("mini.extra")

-- Helper data ================================================================

-- ELP: "Extra Labeled Picker" feature. Has similar purpose as "H = {}" in mini.extra
-- Useful when: Picker has limited items (ie buffers, ui_select: hotkeys activated)
-- Useful when: Picker displays most valuable results on top(ie oldfiles, visits)
-- Less useful: Pick.files, top results have no extra meaning
local ELP = {}

ELP.labels = vim.split("abcdefghijklmnopqrstuvwxyz", "") -- configurable
ELP.virt_clues_pos = { "eol" } -- configurable { "inline" }, { "inline", "eol"}

ELP.invert = function(tbl_in)
  local tbl_out = {}
  -- stylua: ignore
  for idx, l in ipairs(tbl_in) do tbl_out[l] = idx end
  return tbl_out
end
ELP.labels_inv = ELP.invert(ELP.labels)
ELP.ns_id = { labels = vim.api.nvim_create_namespace("MiniExtraLabeledPick") } -- clues
ELP.ui_select_marker = "+ELP+"

-- Copied from mini.pick:
ELP.clear_namespace = function(buf_id, ns_id) pcall(vim.api.nvim_buf_clear_namespace, buf_id, ns_id, 0, -1) end
ELP.set_extmark = function(...) pcall(vim.api.nvim_buf_set_extmark, ...) end

ELP.make_override_match = function(match, picker_ctx)
  -- premisse: items and stritems are constant and related, having the same ordering and length.
  return function(stritems, inds, query, do_sync)
    -- Restore previously modified stritem if present
    if picker_ctx.labeled_ind then
      stritems[picker_ctx.labeled_ind] = string.sub(stritems[picker_ctx.labeled_ind], 2)
    end
    picker_ctx.labeled_ind = nil

    -- Query only holds a potential label when it contains 1 single char
    if #query ~= 1 then return match(stritems, inds, query, do_sync) end

    -- Find index of potential label
    local char = query[1]
    local labeled_ind = ELP.labels_inv[char]
    if not labeled_ind or labeled_ind > picker_ctx.max_labels then return match(stritems, inds, query, do_sync) end

    -- Valid label: Make sure the item is matched
    picker_ctx.labeled_ind = labeled_ind
    stritems[labeled_ind] = string.format("%s%s", char, stritems[labeled_ind])
    return match(stritems, inds, query, do_sync)
  end
end

ELP.autosubmit = function()
  local enter_key = vim.api.nvim_replace_termcodes("<cr>", true, true, true)

  vim.api.nvim_feedkeys(enter_key, "n", false)
  vim.api.nvim_feedkeys("<Ignore>", "n", false)
end

ELP.add_clues = function(buf_id, max_labels, autosubmit)
  local hl = autosubmit and "MiniPickMatchRanges" or "Comment"
  for i, label in ipairs(ELP.labels) do
    if i > max_labels then break end
    local virt_text = { { string.format("[%s]", label), hl } }
    local extmark_opts = { hl_mode = "combine", priority = 200, virt_text = virt_text }

    -- Add clue to start or end of line, or both:
    for _, virt_text_pos in ipairs(ELP.virt_clues_pos) do
      extmark_opts.virt_text_pos = virt_text_pos
      ELP.set_extmark(buf_id, ELP.ns_id.labels, i - 1, 0, extmark_opts)
    end
  end
end

ELP.make_initial_ctx = function(items, picker_ctx)
  if not picker_ctx.max_labels then picker_ctx.max_labels = math.min(#ELP.labels, #items) end
  local all_items = Pick.get_picker_items() or {}

  local ctx = {}
  ctx.first_item = items[1] or {}
  ctx.autosubmit = #all_items == picker_ctx.max_labels
  return ctx
end

ELP.set_labeled_as_first_item = function(all_inds, labeled_ind)
  local labeled_ind_pos
  for i, ind in ipairs(all_inds) do
    if ind == labeled_ind then
      labeled_ind_pos = i
      break
    end
  end
  table.remove(all_inds, labeled_ind_pos)
  table.insert(all_inds, 1, labeled_ind)
  Pick.set_picker_match_inds(all_inds)
end

ELP.make_override_show = function(show, picker_ctx)
  local ctx
  return function(buf_id, items, query, opts) -- items contain as many as displayed
    if not ctx then ctx = ELP.make_initial_ctx(items, picker_ctx) end
    ELP.clear_namespace(buf_id, ELP.ns_id.labels) -- remove clues

    -- Query does not contain a valid label
    if not picker_ctx.labeled_ind then
      show(buf_id, items, query, opts)

      -- Only add clues when query is empty and window is not scrolled
      if #query == 0 and ctx.first_item == items[1] then
        ELP.add_clues(buf_id, picker_ctx.max_labels, ctx.autosubmit)
      end
      return
    end

    -- Query contains valid label. Make sure item is first in the list
    local all_inds = (Pick.get_picker_matches() or {}).all_inds
    if picker_ctx.labeled_ind ~= all_inds[1] then
      ELP.set_labeled_as_first_item(all_inds, picker_ctx.labeled_ind)
      return
    end

    -- Either autosubmit labeled item or show items with item first in the list
    if ctx.autosubmit then
      ELP.autosubmit()
    else
      show(buf_id, items, query, opts)
    end
  end
end

ELP.on_pick_start_event = function()
  local opts = Pick.get_picker_opts()
  if not opts then return end

  local label = opts.label
  local src = opts.source
  if label == nil and string.sub(src.name, 1, #ELP.ui_select_marker) == ELP.ui_select_marker then
    src.name = string.sub(src.name, #ELP.ui_select_marker + 1)
    label = true -- vim.ui.select is set to Extra.pickers.labeled_ui_select
  end
  if not label then return end

  local picker_ctx = { labeled_ind = nil, max_labels = nil }
  src.match = ELP.make_override_match(src.match, picker_ctx)
  src.show = ELP.make_override_show(src.show, picker_ctx)
  Pick.set_picker_opts(opts)
end

-- Public  ================================================================

-- Take opts.label into account and override opts.source.{match, show, choose}
Extra.pickers_enable_label_in_options = function()
  local group = vim.api.nvim_create_augroup("miniextra-labeled-pick", { clear = true })
  vim.api.nvim_create_autocmd("User", {
    pattern = "MiniPickStart",
    group = group,
    desc = "Augment pickers with labels",
    callback = ELP.on_pick_start_event,
  })
end

Extra.pickers.labeled_ui_select = function(items, opts, on_choice)
  if not opts.prompt then opts.prompt = "Select one of:" end -- explicitly set default
  opts.prompt = string.format("%s%s", ELP.ui_select_marker, opts.prompt)
  Pick.ui_select(items, opts, on_choice)
end

-- POC ================================================================

local make_centered_window = function() -- copied from :h MiniPick
  return {
    config = function()
      local height = math.floor(0.618 * vim.o.lines)
      local width = math.floor(0.618 * vim.o.columns)
      return {
        anchor = "NW",
        height = height,
        width = width,
        row = math.floor(0.5 * (vim.o.lines - height)),
        col = math.floor(0.5 * (vim.o.columns - width)),
      }
    end,
  }
end

Extra.pickers_enable_label_in_options()
vim.ui.select = Extra.pickers.labeled_ui_select
local map = vim.keymap.set

local files = function() Pick.builtin.files() end
map("n", "<leader><leader>", files, { desc = "Files pick" })

local labeled_buffers = function()
  local show_icons = true
  local source = { show = not show_icons and Pick.default_show or nil }
  local window = true and make_centered_window() or nil
  local opts = { label = true, source = source, window = window }

  Pick.builtin.buffers({}, opts)
end
map("n", "<leader>;", labeled_buffers, { desc = "Labeled buffers pick", silent = true })

local labeled_lsp = function() Extra.pickers.lsp({ scope = "document_symbol" }, { label = true }) end
map("n", "<leader>b", labeled_lsp, { desc = "Labeled buffer symbols", silent = true })

local labeled_oldfiles = function() Extra.pickers.oldfiles({ current_dir = true }, { label = true }) end
map("n", "<leader>r", labeled_oldfiles, { desc = "Labeled recent (rel)", silent = true })

local labeled_his = function() Extra.pickers.history({ scope = ":" }, { label = true }) end
map("n", "<leader>f:", labeled_his, { desc = "Labeled ':' history" })

local on_choice = function(choice)
  if not choice then return end
  vim.notify(choice)
end
local select_hello = function() vim.ui.select({ "Hello", "Helloooo", "Helloooooo" }, { prompt = "Say hi" }, on_choice) end
map("n", "<leader>fy", select_hello, { desc = "Labeled ui select", silent = true })

-- Pick.setup()

[badosu]

I like the idea of a mini.community repo :-)

[wroyca]

Quite lovely! thank for sharing, will try it out;

[abeldekat]

Curious about your thoughts! I just posted an update

[wroyca]

I'll be busy for a few day but will keep a reminder to do so as soon as possible :)

[abeldekat]

I refactored the code into a separate internal plugin: ak.mini.pick_hinted

[abeldekat]

Thanks for the commit allowing MiniPick.start() customization for vim.ui.select.

I was able to remove some redundant lines from "pick_hinted"

[echasnovski]

Yeah, suggesting to use one-off MiniPickStart to customize MiniPick.start() in vim.ui.select felt unnecessarily clumsy. As there already is a more or less established pattern of "extra optional opts argument to configure provided function inside a wrapper" (like various default_xxx functions), this felt okay to add.