[mini.notify] Support for both fidget-like and regular notification windows

[abeldekat]

mini_notify.mp4

I wanted to replace fidget.nvim with mini.notify. I already used mini.notify for regular messages.

Using two different window configs and some autocommands, mini.notify is now also displaying lsp_progress feedback in almost the same way as fidget.nvim.

Final version: See this comment

First attempt

The code:

--[[

Use a notification window like fidget.nvim for messages from the lsp,
and a regular window otherwise.

Do note that when the lsp emits messages, any regular message
from vim.notify will be displayed in the same lsp window.
This is acceptable.

--]]

local H = {}
local function setup()
  H.map("<leader>un", function() MiniNotify.clear() end, "Notify clear")
  H.map("<leader>on", function() MiniNotify.show_history() end, "Notify history")
  H.create_autocommmands()

  require("mini.notify").setup(H.config_default)
  vim.notify = MiniNotify.make_notify()
end

H.create_autocommmands = function()
  local gr = vim.api.nvim_create_augroup("ak_mini_notify", {})
  local au = function(event, pattern, callback)
    vim.api.nvim_create_autocmd(event, { group = gr, pattern = pattern, callback = callback })
  end

  -- Remember the id of the last mininotify buffer
  local notify_buffer

  -- MiniNotify created a new buffer:
  au("FileType", "mininotify", function(ev) notify_buffer = ev.buf end)

  -- Make sure that correct buffer config is set when lsp emits messages:
  au("LspProgress", "begin", function() vim.b.mininotify_config = H.config_on_lsp_progress end)

  --  When the notify buffer is no longer displayed, make sure the buffer config is the default:
  au("BufHidden", "*", function(ev)
    if ev.buf == notify_buffer then vim.b.mininotify_config = nil end
  end)
end

H.not_lua_diagnosing = function(notif) return not vim.startswith(notif.msg, "lua_ls: Diagnosing") end

H.filterout_lua_diagnosing = function(notif_arr)
  return MiniNotify.default_sort(vim.tbl_filter(H.not_lua_diagnosing, notif_arr))
end

H.format = function(notif) return notif.msg end -- skip the time and |

H.win_config = function()
  local has_statusline = vim.o.laststatus > 0
  local pad = vim.o.cmdheight + (has_statusline and 2 or 0) -- 2 instead of 1
  return { anchor = "SE", col = vim.o.columns, row = vim.o.lines - pad, border = "none" }
end

H.map = function(lhs, rhs, desc) vim.keymap.set("n", lhs, rhs, { desc = desc, silent = true }) end

H.config_default = { -- lsp_progress is enabled by default
  lsp_progress = { duration_last = 500 }, -- default 1000
  content = { sort = H.filterout_lua_diagnosing },
}

H.config_on_lsp_progress = {
  -- Add format, removes timestamp and bar(|):
  content = { format = H.format },
  -- Default blend is 25. Add window like fidget.nvim:
  window = { config = H.win_config(), winblend = 95 },
}

setup()

[echasnovski]

Thanks for sharing! Very nice idea!

The implementation itself looks a bit fragile as it depends on how 'mini.notify' creates/stores/updates buffers, which is subject to change without prior notice. My first attempt at this would have been writing own LSP handler for "$/progress", similarly to how 'mini.notify' does it (here is how it sets it, but not sure it needs to be this robust for personal config).

[abeldekat]

Anyway, modifying global config is better and #1602 (reply in thread) is even better.

Is this what you have in mind?

--[[
Use a notification window like fidget.nvim for messages from the lsp,
and a regular window otherwise.

Do note that when the lsp emits messages, any regular message
from vim.notify will be displayed in the same lsp window.
This is acceptable.
--]]

local H = {}
local function setup()
  local map = function(lhs, rhs, desc) vim.keymap.set("n", lhs, rhs, { desc = desc, silent = true }) end
  map("<leader>un", function() MiniNotify.clear() end, "Notify clear")
  map("<leader>on", function() MiniNotify.show_history() end, "Notify history")
  H.create_autocommmands()

  require("mini.notify").setup({
    lsp_progress = { duration_last = 500 }, -- default duration: 1000
    content = { format = H.format }, -- sort = H.filterout_lua_diagnosing
    window = H.make_window_config(),
  })
  vim.notify = H.make_notify()
end

--- Create the autocommands needed for H.show_lsp
H.create_autocommmands = function()
  local lsp_progress_plus = function() H.n_progress = H.n_progress + 1 end
  vim.api.nvim_create_autocmd("LspProgress", { pattern = "begin", callback = lsp_progress_plus })
  local lsp_progress_minus = function()
    vim.defer_fn(function() H.n_progress = H.n_progress - 1 end, MiniNotify.config.lsp_progress.duration_last + 1)
  end
  vim.api.nvim_create_autocmd("LspProgress", { pattern = "end", callback = lsp_progress_minus })
end

--- Make the notify override. And ensure the correct window config is in use
H.make_notify = function()
  local mini_notify_vim_notify = MiniNotify.make_notify()
  return function(...)
    vim.b.mininotify_config = { window = H.make_window_config() }
    mini_notify_vim_notify(...)
  end
end

--- Format. Ensure the correct window config is in use
H.format = function(notif)
  vim.b.mininotify_config = { window = H.make_window_config() }
  local use_progress = H.in_lsp_progress()

  if use_progress then notif.hl_group = "Comment" end
  return use_progress and MiniNotify.default_format(notif) or notif.msg
end

--- The window config differs between "vim.notify"  and "in lsp progress"
H.make_window_config = function()
  if not H.in_lsp_progress() then return end -- by default no override

  local has_statusline = vim.o.laststatus > 0
  local pad = vim.o.cmdheight + (has_statusline and 2 or 0) -- 2 looks better than 1
  return { --- customize window to be more "fidget" like
    winblend = 95,
    config = { anchor = "SE", col = vim.o.columns, row = vim.o.lines - pad, border = "none" },
  }
end

--- If there are any lsp notification that are still active, return true
H.in_lsp_progress = function() return H.n_progress > 0 end

-- H.not_lua_diagnosing = function(notif) return not vim.startswith(notif.msg, "lua_ls: Diagnosing") end
-- H.filterout_lua_diagnosing = function(notif_arr)
--   return MiniNotify.default_sort(vim.tbl_filter(H.not_lua_diagnosing, notif_arr))
-- end

--- The number of lsp notifications that are still active
H.n_progress = 0

setup()

[echasnovski]

Is this what you have in mind?

Not quite. The config.window.config can be callable which can take different code paths depending on whether there is a LSP progress in action. So something like this:

--[[
Use a notification window like fidget.nvim for messages from the lsp,
and a regular window otherwise.

Do note that when the lsp emits messages, any regular message
from vim.notify will be displayed in the same lsp window.
This is acceptable.
--]]

--- LSP
local n_progress = 0
local in_lsp_progress = function() return n_progress > 0 end

local lsp_progress_plus = function() n_progress = n_progress + 1 end
vim.api.nvim_create_autocmd('LspProgress', { pattern = 'begin', callback = lsp_progress_plus })
local lsp_progress_minus = function()
  vim.defer_fn(function() n_progress = n_progress - 1 end, MiniNotify.config.lsp_progress.duration_last + 1)
end
vim.api.nvim_create_autocmd('LspProgress', { pattern = 'end', callback = lsp_progress_minus })

--- Helpers for custom setup
local format = function(notif)
  if not in_lsp_progress() then return MiniNotify.default_format(notif) end
  -- Weird that this works, as this is not the right place to do it (not sure
  -- if there is the one better, though)
  notif.hl_group = 'Comment'
  return notif.msg
end

--- The window config differs between "vim.notify"  and "in lsp progress"
local window_config = function()
  if not in_lsp_progress() then return {} end -- by default no override

  -- Customize window to be more "fidget" like
  local pad = vim.o.cmdheight + (vim.o.laststatus > 0 and 2 or 0) -- 2 looks better than 1
  return { anchor = 'SE', col = vim.o.columns, row = vim.o.lines - pad, border = 'none' }
end

-- Setup 'mini.notify'
require('mini.notify').setup({
  lsp_progress = { duration_last = 500 }, -- default duration: 1000
  content = { format = format }, -- sort = H.filterout_lua_diagnosing
  window = { winblend = 95, config = window_config },
})
vim.notify = MiniNotify.make_notify()

-- Make mappings
local map = function(lhs, rhs, desc) vim.keymap.set('n', lhs, rhs, { desc = desc, silent = true }) end
map('<leader>un', function() MiniNotify.clear() end, 'Notify clear')
map('<leader>on', function() MiniNotify.show_history() end, 'Notify history')

[abeldekat]

The config.window.config can be callable

I missed that. This is perfect, thank you!

[echasnovski]

@abeldekat, with the recent improvements to 'mini.notify' (which were in half prompted by this "Show and tell"), the following implementation of content.format is now possible and is slightly cleaner:

local format = function(notif)
  return notif.data.source == 'lsp_progress' and notif.msg or MiniNotify.default_format(notif)
end
vim.api.nvim_set_hl(0, 'MiniNotifyLspProgress', { link = 'Comment' })

[abeldekat]

Much cleaner. Thank you!

[krovuxdev]

@abeldekat Another possible solution I could manage

notify.mp4

local win_config = function()
    local has_statusline = vim.o.laststatus > 0
    local pad = vim.o.cmdheight + (has_statusline and 1 or 0)
    local notify_lps = {
        anchor = "SE",
        title = "",
        footer = {
            {
                (vim.b.icon or "") .. (" %s"):format((vim.b.tool or "")),
                "WarningMsg",
            },
        },
        footer_pos = "right",
        border = "solid",
        col = vim.o.columns,
        row = vim.o.lines - pad,
    }
    --stylua: ignore
    return notify_lps
end

local content = {
    format = function(str)
        if vim.b.not_lsp_progress then
            return str.msg
        end
        local parts = vim.split(str.msg, ": ")
        local action = parts[2] and parts[2] or ""
        local tool = parts[1] or ""
        -- stylua: ignore
        local progress_match = action:match("(%d+/[%d]+)") or ""
        local percent_match = action:match("(%d+%%)") or ""
        -- stylua: ignore
        action = action:gsub("%s*%d+/%d+", ""):gsub("%s*%(%d+%%%)", ""):gsub("%s*%([^)]+%)", ""):gsub("%s+$", "")
        action = table.concat(vim.list_slice(vim.split(action, " "), 1, 2), " ")

        vim.b.tool = tool

        str.hl_group = "Comment"

        -- stylua: ignore
        return string.format(
            "%-5s %-4s %s",
            progress_match, percent_match, action
        )
    end,
}

MiniNotify.setup({
    winblend = 0,
    window = { config = win_config },
    content = content,
    lsp_progress = {
        enable = true,
        duration_last = 1000,
    },
})

vim.notify = MiniNotify.make_notify()
local notify = vim.notify
vim.notify = function(msg, level, opts)
    opts = opts or {}
    vim.b.tool = opts.title
    vim.b.not_lsp_progress = true
    vim.b.icon = opts.icon or ""
    vim.b.mininotify_config = {
        window = {
            config = function()
                local notify_lsp = {
                    anchor = "NE",
                    title = {
                        {
                            ((vim.b.tool or "") or ""),
                            "WarningMsg",
                        },
                    },
                    title_pos = "center",
                }
                return notify_lsp
            end,
        },
    }
    notify(msg, level, opts)
    vim.defer_fn(function()
        vim.b.mininotify_config = {
            window = {
                config = win_config,
            },
        }
        vim.b.not_lsp_progress = false
    end, 500)
end

(@echasnovski Opinions?)

[abeldekat]

Very nice output!

For me personally, the need to use chained gsub is a bit too much...)

Thanks for the alternative!

[echasnovski]

(@echasnovski Opinions?)

Too much nesting and panic :)

But I think I like the approach of having the same global config which inside of it decides which config to use based on some flag (cc @abeldekat). And the flag can be set up something like this:

local n_progress = 0
local lsp_progress_plus = function() n_progress = n_progress + 1 end
vim.api.nvim_create_autocmd('LspProgress', { pattern = 'begin', callback = lsp_progress_plus })

local lsp_progress_minus = function()
  vim.defer_fn(function() n_progress = n_progress - 1 end, MiniNotify.config.lsp_progress.duration_last + 1)
end
vim.api.nvim_create_autocmd('LspProgress', { pattern = 'end', callback = lsp_progress_minus })

-- The use `n_progress > 0` as a flag to use "LSP window config"