opts.keymaps seems to not working correctly

[mym0404]

Make sure you have done the following

• Updated to the latest version of blink.cmp
• Searched for existing issues and documentation (try <C-k> on https://cmp.saghen.dev)

Bug Description

I have tried to set keymap field based on documentation.
I'm using lazyvim and copied from it's default config with my tiny customization. I want't <C-p> and <C-n> work as scroll documentation if is any documentation showing.

Pressing <C-n> just moves to the below line.

I also tried function value config receiving cmp argument but no luck(it even wasn't called)

Weird things is require('blink-cmp').is_documentation_visible() like functions have disorders and don't work at all.

is_documentation_visible always returns false and other imperative API is not responsible. but pcall was returned true for them.

cmdline.keymap is working well but I have no idea about keymap options. Any suggestion or is there any misconfiguration in my plugin file?

Relevant configuration

blink-cmp.lua

return {
  "saghen/blink.cmp",
  -- version = not vim.g.lazyvim_blink_main and "*",
  -- build = vim.g.lazyvim_blink_main and "cargo build --release",
  opts_extend = {
    "sources.completion.enabled_providers",
    "sources.compat",
    "sources.default",
  },
  dependencies = {
    "rafamadriz/friendly-snippets",
    -- add blink.compat to dependencies
    {
      "saghen/blink.compat",
      optional = false, -- make optional so it's only enabled if any extras need it
      opts = {},
      -- version = not vim.g.lazyvim_blink_main and "*",
    },
  },
  event = "InsertEnter",

  ---@module 'blink.cmp'
  ---@type blink.cmp.Config
  opts = {
    keymap = {
      preset = "default",
      ["<tab>"] = { "select_next", "fallback" },
      ["<s-tab>"] = { "select_prev", "fallback" },
      ["<CR>"] = { "accept", "fallback" },
      -- ["<esc>"] = { "hide", "fallback" },
      ["<s-d>"] = { "show_documentation" },
      ["<C-p>"] = { "select_prev", "scroll_documentation_up", "fallback_to_mappings" },
      ["<C-n>"] = { "select_next", "scroll_documentation_down", "fallback_to_mappings" },
    },
    cmdline = {
      enabled = true,
      keymap = {
        ["<tab>"] = { "select_next", "fallback" },
        ["<s-tab>"] = { "select_prev", "fallback" },
        ["<CR>"] = { "accept_and_enter", "fallback" },
        -- ["<esc>"] = { "hide", "fallback" },
      },
      completion = { menu = { auto_show = true } },
    },
    snippets = {
      expand = function(snippet)
        return LazyVim.cmp.expand(snippet)
      end,
    },
    appearance = {
      -- sets the fallback highlight groups to nvim-cmp's highlight groups
      -- useful for when your theme doesn't support blink.cmp
      -- will be removed in a future release, assuming themes add support
      use_nvim_cmp_as_default = false,
      -- set to 'mono' for 'Nerd Font Mono' or 'normal' for 'Nerd Font'
      -- adjusts spacing to ensure icons are aligned
      nerd_font_variant = "mono",
    },
    completion = {
      keyword = { range = "prefix" },
      accept = {
        -- experimental auto-brackets support
        auto_brackets = {
          enabled = false,
        },
      },
      list = {
        selection = {
          preselect = true,
          auto_insert = false,
        },
      },
      menu = {
        draw = {
          treesitter = { "lsp" },
          columns = {
            { "kind_icon", gap = 1 },
            { "label", "label_description" },
          },
        },
      },

      documentation = {
        auto_show = true,
        auto_show_delay_ms = 500,
        window = { scrollbar = false },
      },
      ghost_text = {
        enabled = vim.g.ai_cmp,
        -- enabled = true,
      },
    },
    -- experimental signature help support
    signature = { enabled = true, window = { show_documentation = false } },

    sources = {
      -- adding any nvim-cmp sources here will enable them
      -- with blink.compat
      compat = {},
      default = { "lsp", "path", "snippets", "buffer" },
    },
  },

  ---@param opts blink.cmp.Config | { sources: { compat: string[] } }
  config = function(_, opts)
    -- setup compat sources
    local enabled = opts.sources.default
    for _, source in ipairs(opts.sources.compat or {}) do
      opts.sources.providers[source] = vim.tbl_deep_extend(
        "force",
        { name = source, module = "blink.compat.source" },
        opts.sources.providers[source] or {}
      )
      if type(enabled) == "table" and not vim.tbl_contains(enabled, source) then
        table.insert(enabled, source)
      end
    end

    -- add ai_accept to <Tab> key
    -- if not opts.keymap["<Tab>"] then
    --   if opts.keymap.preset == "super-tab" then -- super-tab
    --     opts.keymap["<Tab>"] = {
    --       require("blink.cmp.keymap.presets")["super-tab"]["<Tab>"][1],
    --       LazyVim.cmp.map({ "snippet_forward", "ai_accept" }),
    --       "fallback",
    --     }
    --   else -- other presets
    --     opts.keymap["<Tab>"] = {
    --       LazyVim.cmp.map({ "snippet_forward", "ai_accept" }),
    --       "fallback",
    --     }
    --   end
    -- end

    -- Unset custom prop to pass blink.cmp validation
    opts.sources.compat = nil

    -- check if we need to override symbol kinds
    for _, provider in pairs(opts.sources.providers or {}) do
      ---@cast provider blink.cmp.SourceProviderConfig|{kind?:string}
      if provider.kind then
        local CompletionItemKind = require("blink.cmp.types").CompletionItemKind
        local kind_idx = #CompletionItemKind + 1

        CompletionItemKind[kind_idx] = provider.kind
        ---@diagnostic disable-next-line: no-unknown
        CompletionItemKind[provider.kind] = kind_idx

        ---@type fun(ctx: blink.cmp.Context, items: blink.cmp.CompletionItem[]): blink.cmp.CompletionItem[]
        local transform_items = provider.transform_items
        ---@param ctx blink.cmp.Context
        ---@param items blink.cmp.CompletionItem[]
        provider.transform_items = function(ctx, items)
          items = transform_items and transform_items(ctx, items) or items
          for _, item in ipairs(items) do
            item.kind = kind_idx or item.kind
            item.kind_icon = LazyVim.config.icons.kinds[item.kind_name] or item.kind_icon or nil
          end
          return items
        end

        -- Unset custom prop to pass blink.cmp validation
        provider.kind = nil
      end
    end

    require("blink.cmp").setup(opts)
  end,
}

`keymaps.lua`

local utils = require("../utils/utils")

local function reset_keymaps()
  local reset_keys = {
    { "n", "gc" },
    { "n", "gco" },
    { "n", "gcO" },
    { "o", "gc" },
    { "x", "gc" },
    { "n", "gcc" },
  }
  for _, key in ipairs(reset_keys) do
    pcall(vim.keymap.del, key[1], key[2])
  end
end

local function setup_comments()
  local api = require("Comment.api")

  vim.keymap.set("n", "gc", api.toggle.linewise.current)

  local esc = vim.api.nvim_replace_termcodes("<ESC>", true, false, true)

  vim.keymap.set("x", "gc", function()
    vim.api.nvim_feedkeys(esc, "nx", false)
    api.toggle.linewise(vim.fn.visualmode())
  end)
end

local function customizeExitInsertMode()
  for _, key in ipairs({ "jj", "jk", "kj" }) do
    vim.keymap.set(
      { "i" },
      key,
      "<Esc>",
      { noremap = true, silent = true, desc = "Exit insert mode" }
    )
  end
end

local function manipulate_yank_paste_register_behavior()
  -- vim.keymap.set({ "n", "v" }, "y", '"zy', { desc = "Yank to register a" })
  -- vim.keymap.set({ "n", "v" }, "p", '"zp', { desc = "Paste from register a" })
  -- vim.keymap.set(
  --   { "n", "v" },
  --   "P",
  --   '"zP',
  --   { desc = "Paste before from register a" }
  -- )
  vim.keymap.set({ "n", "v" }, "x", '"_x', { desc = "Delete without register" })
  -- vim.keymap.set({ "n", "v" }, "d", '"zd', { desc = "Delete without register" })
end

local function map_close_visual()
  vim.keymap.set(
    "x",
    "q",
    "<Esc>",
    { noremap = true, silent = true, desc = "Exit visual mode with q" }
  )
end

local function map_move_vline()
  -- Move visual
  vim.keymap.set(
    "x",
    "<S-j>",
    ":move '>+1<CR>gv=gv",
    { noremap = true, silent = true, desc = "Move selection down" }
  )
  vim.keymap.set(
    "x",
    "<S-k>",
    ":move '<-2<CR>gv=gv",
    { noremap = true, silent = true, desc = "Move selection up" }
  )
end
local function configure_git_diff()
  vim.keymap.set(
    "n",
    "<leader>z",
    "<cmd>DiffviewOpen<cr>",
    { noremap = true, silent = true, desc = "Open Diff View" }
  )
  vim.keymap.set(
    "n",
    "<leader>h",
    "<cmd>DiffviewFileHistory %<cr>",
    { noremap = true, silent = true, desc = "Open Diff view file history" }
  )
end

local function map_close_tap_or_buffer()
  vim.keymap.set("n", "<C-w>", function()
    local tab_count = vim.fn.tabpagenr("$")
    if tab_count > 1 then
      vim.cmd("tabclose")
    else
      vim.cmd("bdelete")
    end
  end, {
    noremap = true,
    silent = true,
    desc = "Close tab if multiple tabs, else close buffer",
  })
end

vim.keymap.set("n", "<leader>gr", function()
  local filepath = vim.fn.expand("%")
  if filepath == "" then
    print("No file to restore")
    return
  end
  vim.cmd("silent !git restore " .. filepath)
  print("Discarded changes in " .. filepath)
  vim.cmd("edit!")
  -- vim.cmd("normal! <Esc>")
end, { noremap = true, silent = true, desc = "Git discard current file changes" })

vim.keymap.set("x", "<leader>gr", function()
  local start_line, end_line = utils.get_start_and_end_lines()
  local filepath = vim.fn.expand("%:p")

  if filepath == "" then
    print("No file to restore")
    return
  end

  utils.discard_changes_in_range(filepath, start_line, end_line)

  utils.go_to_normal_mode()
end, { noremap = true, silent = true, desc = "Git restore selected lines" })

local function map_rename()
  vim.keymap.set("n", "<F6>", function()
    utils.run_key(":IncRename ", "n")
  end, { desc = "Rename file" })
end

local function map_delete_file()
  vim.keymap.set("n", "<space>cd", function()
    local current_buffer_file_path = vim.api.nvim_buf_get_name(0)
    vim.cmd("bdelete")
    vim.cmd("!rm " .. current_buffer_file_path)
    vim.notify("Delete file " .. current_buffer_file_path)
  end, { desc = "Delete current file" })
end

local function map_enter()
  vim.keymap.set({ "n", "i" }, "<cr>", function()
    local prefix = vim.api.nvim_get_mode().mode == "n" and "i" or ""
    if utils.is_in_pairs() then
      return prefix .. "<cr><esc>O"
    end
    return prefix .. "<cr>"
  end, { expr = true })
end

local function map_recording()
  vim.keymap.set("n", "q", "qt", { desc = "start recording with register t" })
  vim.keymap.set("n", "@", "@t", { desc = "run recording with register t" })
end

local function map_smart_splits()
  local vertical_resize_amount = 3
  local horizontal_resize_amount = 5
  -- recommended mappings
  -- resizing splits
  -- these keymaps will also accept a range,
  -- for example `10<A-h>` will `resize_left` by `(10 * config.default_amount)`
  vim.keymap.set("n", "<A-h>", function()
    require("smart-splits").resize_left(horizontal_resize_amount)
  end)
  vim.keymap.set("n", "<A-j>", function()
    require("smart-splits").resize_down(vertical_resize_amount)
  end)
  vim.keymap.set("n", "<A-k>", function()
    require("smart-splits").resize_up(vertical_resize_amount)
  end)
  vim.keymap.set("n", "<A-l>", function()
    require("smart-splits").resize_right(horizontal_resize_amount)
  end)

  -- moving between splits
  vim.keymap.set("n", "<C-h>", function()
    require("smart-splits").move_cursor_left({ at_edge = "wrap" })
  end)
  vim.keymap.set("n", "<C-j>", function()
    require("smart-splits").move_cursor_down({ at_edge = "wrap" })
  end)
  vim.keymap.set("n", "<C-k>", function()
    require("smart-splits").move_cursor_up({ at_edge = "wrap" })
  end)
  vim.keymap.set("n", "<C-l>", function()
    require("smart-splits").move_cursor_right({ at_edge = "wrap" })
  end)

  -- split windows
  vim.keymap.set("n", "<C-l>", function()
    require("smart-splits").move_cursor_right({ at_edge = "wrap" })
  end)

  -- vim.keymap.set("n", "<C-\\>", require("smart-splits").move_cursor_previous)
  -- swapping buffers between windows
  -- vim.keymap.set("n", "<leader><leader>h", require("smart-splits").swap_buf_left)
  -- vim.keymap.set("n", "<leader><leader>j", require("smart-splits").swap_buf_down)
  -- vim.keymap.set("n", "<leader><leader>k", require("smart-splits").swap_buf_up)
  -- vim.keymap.set("n", "<leader><leader>l", require("smart-splits").swap_buf_right)
end

local function map_split()
  vim.keymap.set("n", "_", ":split<cr>", { desc = "split horizontal", nowait = true })
  vim.keymap.set("n", "|", ":vsplit<cr>", { desc = "split vertical", nowait = true })
end

local function map_select_all()
  vim.keymap.set("n", "<c-a>", "ggVG", { desc = "select all" })
end

reset_keymaps()
setup_comments()
manipulate_yank_paste_register_behavior()
customizeExitInsertMode()
configure_git_diff()
map_close_visual()
map_move_vline()
map_close_tap_or_buffer()
map_rename()
map_delete_file()
map_enter()
map_recording()
map_smart_splits()
map_split()
map_select_all()

neovim version

v0.11.2 (MACOS) LuaJIT 2.1.1748459687

blink.cmp version

v1.3.1(main)

[Saghen]

select_next and select_prev will always beat scroll_documentation_down/up because the menu must be showing for the documentation to be showing, and the first successful commands wins. Are you perhaps trying to scroll the K menu? That one is likely from nvim via vim.lsp.buf.hover() which isn't controlled by blink.cmp

[mym0404]

Yes, I tried scroll documentation from 'K'(hover). I didn't know that hovering isn't a concern of blink.cmp. Thank you for your explanation.