mini.nvim/lua/mini/notify.lua at main · daniel-samson/mini.nvim

Repository navigation

--- *mini.notify* Show notifications
--- *MiniNotify*
--- MIT License Copyright (c) 2024 Evgeni Chasnovski
--- ==============================================================================
--- Features:
--- - Show one or more highlighted notifications in a single floating window.
--- - Manage notifications (add, update, remove, clear).
--- - |vim.notify()| wrapper generator (see |MiniNotify.make_notify()|).
--- - Automated show of LSP progress report.
--- - Track history which can be accessed with |MiniNotify.get_all()|
---   and shown with |MiniNotify.show_history()|.
--- # Setup ~
--- This module needs a setup with `require('mini.notify').setup({})` (replace
--- `{}` with your `config` table). It will create global Lua table `MiniNotify`
--- which you can use for scripting or manually (with `:lua MiniNotify.*`).
--- See |MiniNotify.config| for `config` structure and default values.
--- You can override runtime config settings locally to buffer inside
--- `vim.b.mininotify_config` which should have same structure as
--- `MiniNotify.config`. See |mini.nvim-buffer-local-config| for more details.
--- # Comparisons ~
--- - 'j-hui/fidget.nvim':
---     - Basic goals of providing interface for notifications are similar.
---     - Has more configuration options and visual effects, while this module
---       does not (by design).
--- - 'rcarriga/nvim-notify':
---     - Similar to 'j-hui/fidget.nvim'.
--- # Highlight groups ~
--- * `MiniNotifyBorder` - window border.
--- * `MiniNotifyNormal` - basic foreground/background highlighting.
--- * `MiniNotifyTitle` - window title.
--- To change any highlight group, modify it directly with |:highlight|.
--- # Disabling ~
--- To disable showing notifications, set `vim.g.mininotify_disable` (globally) or
--- `vim.b.mininotify_disable` (for a buffer) to `true`. Considering high number
--- of different scenarios and customization intent
10000
ions, writing exact rules
--- for disabling module's functionality is left to user. See
--- |mini.nvim-disabling-recipes| for common recipes.
--- # Notification specification ~
--- Notification is a table with the following keys:
--- - <msg> `(string)` - single string with notification message.
---   Use `\n` to delimit several lines.
--- - <level> `(string)` - notification level as key of |vim.log.levels|.
---   Like "ERROR", "WARN", "INFO", etc.
--- - <hl_group> `(string)` - highlight group with which notification is shown.
--- - <ts_add> `(number)` - timestamp of when notification is added.
--- - <ts_update> `(number)` - timestamp of the latest notification update.
--- - <ts_remove> `(number|nil)` - timestamp of when notification is removed.
---   It is `nil` if notification was never removed and thus considered "active".
--- - Timestamps are compatible with |strftime()| and have fractional part.
---@tag MiniNotify-specification
---@diagnostic disable:undefined-field
---@diagnostic disable:discard-returns
---@diagnostic disable:unused-local
---@diagnostic disable:cast-local-type
---@diagnostic disable:undefined-doc-name
---@diagnostic disable:luadoc-miss-type-name
-- Module definition ==========================================================
local MiniNotify = {}
local H = {}
--- Module setup
---@param config table|nil Module config table. See |MiniNotify.config|.
---@usage `require('mini.notify').setup({})` (replace `{}` with your `config` table).
MiniNotify.setup = function(config)
  -- Export module
  _G.MiniNotify = MiniNotify
  -- Setup config
  config = H.setup_config(config)
  -- Apply config
  H.apply_config(config)
  -- Define behavior
  H.create_autocommands(config)
  -- Create default highlighting
  H.create_default_hl()
--- Module config
--- Default values:
---@eval return MiniDoc.afterlines_to_code(MiniDoc.current.eval_section)
---@text # Content ~
--- `config.content` defines how notifications are shown.
--- `content.format` is a function which takes single notification object
--- (see |MiniNotify-specification|) and returns a string to be used directly
--- when showing notification.
--- Default: `nil` for |MiniNotify.default_format()|.
--- `content.sort` is a function which takes array of notification objects
--- (see |MiniNotify-specification|) and returns an array of such objects.
--- It can be used to define custom order and/or filter for notifications which
--- are shown simultaneously.
--- Note: Input contains notifications before applying `content.format`.
--- Default: `nil` for |MiniNotify.default_sort()|.
--- Example:
---   require('mini.notify').setup({
---     content = {
---       -- Use notification message as is
---       format = function(notif) return notif.msg end,
---       -- Show more recent notifications first
---       sort = function(notif_arr)
---         table.sort(
---           notif_arr,
---           function(a, b) return a.ts_update > b.ts_update end
---         )
---         return notif_arr
---       end,
--- # LSP progress ~
--- `config.lsp_progress` defines automated notifications for LSP progress.
--- It is implemented as a single updating notification with all information
--- about the progress.
--- Setting up is done inside |MiniNotify.setup()| via |vim.schedule()|'ed setting
--- of |lsp-handler| for "$/progress" method.
--- `lsp_progress.enable` is a boolean indicating whether LSP progress should
--- be shown in notifications. Can be disabled in current session.
--- Default: `true`. Note: Should be `true` during |MiniNotify.setup()| call to be able
--- to enable it in current session.
--- `lsp_progress.duration_last` is a number of milliseconds for the last progress
--- report to be shown on screen before removing it.
--- Default: 1000.
--- - This respects previously set handler by saving and calling it.
--- - Overrding "$/progress" method of `vim.lsp.handlers` disables notifications.
--- # Window ~
--- `config.window` defines behavior of notification window.
--- `window.config` is a table defining floating window characteristics
--- or a callable returning such table (will be called with identifier of
--- window's buffer already showing notifications). It should have the same
--- structure as in |nvim_open_win()|. It has the following default values
--- which show notifications in the upper right corner with upper limit on width:
--- - `width` is chosen to fit buffer content but at most `window.max_width_share`
---   share of 'columns'.
---   To have higher maximum width, use function in `config.window` which computes
---   dimensions inside of it (based on buffer content).
--- - `height` is chosen to fit buffer content with enabled 'wrap' (assuming
---   default value of `width`).
--- - `anchor`, `col`, and `row` are "NE", 'columns', and 0 or 1 (depending on tabline).
--- - `border` is "single".
--- - `zindex` is 999 to be as much on top as reasonably possible.
--- `window.max_width_share` defines maximum window width as a share of 'columns'.
--- Should be a number between 0 (not included) and 1.
--- Default: 0.382.
--- `window.winblend` defines 'winblend' value for notification window.
--- Default: 25.
MiniNotify.config = {
  -- Content management
  content = {
    -- Function which formats the notification message
    -- By default prepends message with notification time
    format = nil,
    -- Function which orders notification array from most to least important
    -- By default orders first by level and then by update timestamp
    sort = nil,
  -- Notifications about LSP progress
  lsp_progress = {
    -- Whether to enable showing
    enable = true,
    -- Duration (in ms) of how long last message should be shown
    duration_last = 1000,
  -- Window options
  window = {
    -- Floating window config
    config = {},
    -- Maximum window width as share (between 0 and 1) of available columns
    max_width_share = 0.382,
    -- Value of 'winblend' option
    winblend = 25,
--minidoc_afterlines_end
--- Make vim.notify wrapper
--- Calling this function creates an implementation of |vim.notify()| powered
--- by this module. General idea is that notification is shown immediately and
--- removed after a configurable amount of time.
--- Examples:
---   -- Defaults
---   vim.notify = require('mini.notify').make_notify()
---   -- Change duration for errors to show them longer
---   local opts = { ERROR = { duration = 10000 } }
---   vim.notify = require('mini.notify').make_notify(opts)
---@param opts table|nil Options to configure behavior of notification `level`
---   (as in |MiniNotfiy.add()|). Fields are the same as names of `vim.log.levels`
---   with values being tables with possible fields:
---     - <duration> `(number)` - duration (in ms) of how much a notification
---       should be shown. If 0 or negative, notification is not shown at all.
---     - <hl_group> `(string)` - highlight group of notification.
---   Only data different to default can be supplied.
---   Default: >
---       ERROR = { duration = 5000, hl_group = 'DiagnosticError'  },
---       WARN  = { duration = 5000, hl_group = 'DiagnosticWarn'   },
---       INFO  = { duration = 5000, hl_group = 'DiagnosticInfo'   },
---       DEBUG = { duration = 0,    hl_group = 'DiagnosticHint'   },
---       TRACE = { duration = 0,    hl_group = 'DiagnosticOk'     },
---       OFF   = { duration = 0,    hl_group = 'MiniNotifyNormal' },
MiniNotify.make_notify = function(opts)
  local level_names = {}
  for k, v in pairs(vim.log.levels) do
    level_names[v] = k
  --stylua: ignore
  local default_opts = {
    ERROR = { duration = 5000, hl_group = 'DiagnosticError'  },
    WARN  = { duration = 5000, hl_group = 'DiagnosticWarn'   },
    INFO  = { duration = 5000, hl_group = 'DiagnosticInfo'   },
    DEBUG = { duration = 0,    hl_group = 'DiagnosticHint'   },
    TRACE = { duration = 0,    hl_group = 'DiagnosticOk'     },
    OFF   = { duration = 0,    hl_group = 'MiniNotifyNormal' },
  opts = vim.tbl_deep_extend('force', default_opts, opts or {})
  for key, val in pairs(opts) do
    if default_opts[key] == nil then H.error('Keys should be log level names.') end
    if type(val) ~= 'table' then H.error('Level data should be table.') end
    if type(val.duration) ~= 'number' then H.error('`duration` in level data should be number.') end
    if type(val.hl_group) ~= 'string' then H.error('`hl_group` in level data should be string.') end
  return function(msg, level)
    level = level or vim.log.levels.INFO
    local level_name = level_names[level]
    if level_name == nil then H.error('Only valid values of `vim.log.levels` are supported.') end
    local level_data = opts[level_name]
    if level_data.duration <= 0 then return end
    local id = MiniNotify.add(msg, level_name, level_data.hl_group)
    vim.defer_fn(function() MiniNotify.remove(id) end, level_data.duration)
--- Add notification
--- Add notification to history. It is considered "active" and is shown.
--- To hide, call |MiniNotfiy.remove()| with identifier this function returns.
--- Example:
---   local id = MiniNotify.add('Hello', 'WARN', 'Comment')
--
10000
-   vim.defer_fn(function() MiniNotify.remove(id) end, 1000)
---@param msg string Notification message.
---@param level string|nil Notification level as key of |vim.log.levels|.
---   Default: `'INFO'`.
---@param hl_group string|nil Notification highlight group.
---   Default: `'MiniNotifyNormal'`.
---@return number Notification identifier.
MiniNotify.add = function(msg, level, hl_group)
  H.validate_msg(msg)
  level = level or 'INFO'
  H.validate_level(level)
  hl_group = hl_group or 'MiniNotifyNormal'
  H.validate_hl_group(hl_group)
  local cur_ts = H.get_timestamp()
  local new_notif = { msg = msg, level = level, hl_group = hl_group, ts_add = cur_ts, ts_update = cur_ts }
  local new_id = #H.history + 1
  -- NOTE: Crucial to use the same table here and later only update values
  -- inside of it in place. This makes sure that history entries are in sync.
  H.history[new_id], H.active[new_id] = new_notif, new_notif
  -- Refresh active notifications
  MiniNotify.refresh()
  return new_id
--- Update active notification
--- Modify data of active notification.
---@param id number Identifier of currently active notification as returned
---   by |MiniNotify.add()|.
---@param new_data table Table with data to update. Keys should be as non-timestamp
---   fields of |MiniNotify-specification| and values - new notification values.
MiniNotify.update = function(id, new_data)
  local notif = H.active[id]
  if notif == nil then H.error('`id` is not an identifier of active notification.') end
  if type(new_data) ~= 'table' then H.error('`new_data` should be table.') end
  if new_data.msg ~= nil then H.validate_msg(new_data.msg) end
  if new_data.level ~= nil then H.validate_level(new_data.level) end
  if new_data.hl_group ~= nil then H.validate_hl_group(new_data.hl_group) end
  notif.msg = new_data.msg or notif.msg
  notif.level = new_data.level or notif.level
  notif.hl_group = new_data.hl_group or notif.hl_group
  notif.ts_update = H.get_timestamp()
  MiniNotify.refresh()
--- Remove notification
--- If notification is active, make it not active (by setting `ts_remove` field).
--- If not active, do nothing.
---@param id number|nil Identifier of previously added notification.
---   If it is not, nothing is done (silently).
MiniNotify.remove = function(id)
  local notif = H.active[id]
  if notif == nil then return end
  notif.ts_remove = H.get_timestamp()
  H.active[id] = nil
  MiniNotify.refresh()
--- Remove all active notifications
--- Hide all active notifications and stop showing window (if shown).
MiniNotify.clear = function()
  local cur_ts = H.get_timestamp()
  for id, _ in pairs(H.active) do
    H.active[id].ts_remove = cur_ts
  H.active = {}
  MiniNotify.refresh()
--- Refresh notification window
--- Make notification window show relevant data:
--- - Create an array of active notifications (see |MiniNotify-specification|).
--- - Apply `config.content.sort` to an array. If output has zero notifications,
---   make notification window to not show.
--- - Apply `config.content.format` to each element of notification array and
---   update its message.
--- - Construct content from notifications and show them in a window.
MiniNotify.refresh = function()
  if H.is_disabled() or type(vim.v.exiting) == 'number' then return H.window_close() end
  -- Prepare array of active notifications
  local notif_arr = vim.deepcopy(vim.tbl_values(H.active))
  local config_content = H.get_config().content
  local sort = vim.is_callable(config_content.sort) and config_content.sort or MiniNotify.default_sort
  notif_arr = sort(notif_arr)
  if not H.is_notification_array(notif_arr) then H.error('Output of `content.sort` should be notification array.') end
  if #notif_arr == 0 then return H.window_close() end
  local format = vim.is_callable(config_content.format) and config_content.format or MiniNotify.default_format
  notif_arr = H.notif_apply_format(notif_arr, format)
  -- Refresh buffer
  local buf_id = H.cache.buf_id
  if not H.is_valid_buf(buf_id) then buf_id = H.buffer_create() end
  H.buffer_refresh(buf_id, notif_arr)
  -- Refresh window
  local win_id = H.cache.win_id
  if not (H.is_valid_win(win_id) and H.is_win_in_tabpage(win_id)) then
    H.window_close()
    win_id = H.window_open(buf_id)
    local new_config = H.window_compute_config(buf_id)
    vim.api.nvim_win_set_config(win_id, new_config)
  -- Redraw
  vim.cmd('redraw')
  -- Update cache
  H.cache.buf_id, H.cache.win_id = buf_id, win_id
--- Get previously added notification by id
---@param id number Identifier of notification.
---@return table Notification object (see |MiniNotify-specification|).
MiniNotify.get = function(id) return vim.deepcopy(H.history[id]) end
--- Get all previously added notifications
--- Get map of used notifications with keys being notification identifiers.
--- Can be used to get only active notification objects. Example: >
---   -- Get active notifications
---   vim.tbl_filter(
---     function(notif) return notif.ts_remove == nil end,
---     MiniNotify.get_all()
---@return table Map with notification object values (see |MiniNotify-specification|).
---   Note: messages are taken from last valid update.
MiniNotify.get_all = function() return vim.deepcopy(H.history) end
--- Show history
--- Open or reuse a scratch buffer with all previously shown notifications.
--- - Content is ordered from oldest to newest based on latest update time.
--- - Message is formatted with `config.content.format`.
MiniNotify.show_history = function()
  -- Prepare content
  local config_content = H.get_config().content
  local notif_arr = MiniNotify.get_all()
  table.sort(notif_arr, function(a, b) return a.ts_update < b.ts_update end)
  local format = vim.is_callable(config_content.format) and config_content.format or MiniNotify.default_format
  notif_arr = H.notif_apply_format(notif_arr, format)
  -- Show content in a reusable buffer
  local buf_id
  for _, id in ipairs(vim.api.nvim_list_bufs()) do
    if vim.bo[id].filetype == 'mininotify-history' then buf_id = id end
  if buf_id == nil then
    buf_id = vim.api.nvim_create_buf(true, true)
    vim.bo[buf_id].filetype = 'mininotify-history'
  H.buffer_refresh(buf_id, notif_arr)
  vim.api.nvim_win_set_buf(0, buf_id)
--- Default content format
--- Used by default as `config.content.format`. Prepends notification message
--- with the human readable update time and a separator.
---@param notif table Notification object (see |MiniNotify-specification|).
---@return string Formatted notification message.
MiniNotify.default_format = function(notif)
  local time = vim.fn.strftime('%H:%M:%S', math.floor(notif.ts_update))
  return string.format('%s │ %s', time, notif.msg)
--- Default content sort
--- Used by default as `config.content.sort`. First sorts by notification's `level`
--- ("ERROR" > "WARN" > "INFO" > "DEBUG" > "TRACE" > "OFF"; the bigger the more
--- important); if draw - by latest update time (the later the more important).
---@param notif_arr table Array of notifications (see |MiniNotify-specification|).
---@return table Sorted array of notifications.
MiniNotify.default_sort = function(notif_arr)
  local res = vim.deepcopy(notif_arr)
  table.sort(res, H.notif_compare)
  return res
-- Helper data ================================================================
-- Module default config
H.default_config = MiniNotify.config
-- Map of currently active notifications with their id as key
H.active = {}
-- History of all notifications in order they are created
H.history = {}
-- Map of LSP progress process id to notification data
H.lsp_progress = {}
-- Priorities of levels
H.level_priority = { ERROR = 6, WARN = 5, INFO = 4, DEBUG = 3, TRACE = 2, OFF = 1 }
-- Namespaces
H.ns_id = {
  highlight = vim.api.nvim_create_namespace('MiniNotifyHighlight'),
-- Various cache
H.cache = {
  -- Notification buffer and window
  buf_id = nil,
  win_id = nil,
-- Helper functionality =======================================================
-- Settings -------------------------------------------------------------------
H.setup_config = function(config)
  -- General idea: if some table elements are not present in user-supplied
  -- `config`, take them from default config
  vim.validate({ config = { config, 'table', true } })
  config = vim.tbl_deep_extend('force', vim.deepcopy(H.default_config), config or {})
  vim.validate({
    content = { config.content, 'table' },
    lsp_progress = { config.lsp_progress, 'table' },
    window = { config.window, 'table' },
  local is_table_or_callable = function(x) return type(x) == 'table' or vim.is_callable(x) end
  vim.validate({
    ['content.format'] = { config.content.format, 'function', true },
    ['content.sort'] = { config.content.sort, 'function', true },
    ['lsp_progress.enable'] = { config.lsp_progress.enable, 'boolean' },
    ['lsp_progress.duration_last'] = { config.lsp_progress.duration_last, 'number' },
    ['window.config'] = { config.window.config, is_table_or_callable, 'table or callable' },
    ['window.max_width_share'] = { config.window.max_width_share, 'number' },
    ['window.winblend'] = { config.window.winblend, 'number' },
  return config
H.apply_config = function(config)
  MiniNotify.config = config
  if config.lsp_progress.enable then
    -- Use `vim.schedule` to reduce startup time (sourcing `vim.lsp` is costly)
    vim.schedule(function()
      -- Cache original handler only once (to avoid infinite loop)
      if vim.lsp.handlers['$/progress before mini.notify'] == nil then
        vim.lsp.handlers['$/progress before mini.notify'] = vim.lsp.handlers['$/progress']
      vim.lsp.handlers['$/progress'] = H.lsp_progress_handler
H.create_autocommands = function(config)
  local augroup = vim.api.nvim_create_augroup('MiniNotify', {})
  local au = function(event, pattern, callback, desc)
    vim.api.nvim_create_autocmd(event, { group = augroup, pattern = pattern, callback = callback, desc = desc })
  au({ 'TabEnter', 'VimResized' }, '*', function() MiniNotify.refresh() end, 'Refresh notifications')
--stylua: ignore
H.create_default_hl = function()
  local hi = function(name, opts)
    opts.default = true
    vim.api.nvim_set_hl(0, name, opts)
  hi('MiniNotifyBorder', { link = 'FloatBorder' })
  hi('MiniNotifyNormal', { link = 'NormalFloat' })
  hi('MiniNotifyTitle',  { link = 'FloatTitle'  })
H.is_disabled = function() return vim.g.mininotify_disable == true or vim.b.mininotify_disable == true end
H.get_config = function(config)
  return vim.tbl_deep_extend('force', MiniNotify.config, vim.b.mininotify_config or {}, config or {})
-- LSP progress ---------------------------------------------------------------
H.lsp_progress_handler = function(err, result, ctx, config)
  -- Make basic response processing. First call original LSP handler.
  -- On Neovim>=0.10 this is crucial to not override `LspProgress` event.
  if vim.is_callable(vim.lsp.handlers['$/progress before mini.notify']) then
    vim.lsp.handlers['$/progress before mini.notify'](err, result, ctx, config)
  local lsp_progress_config = H.get_config().lsp_progress
  if not lsp_progress_config.enable then return end
  if err ~= nil then return vim.notify(vim.inspect(err), vim.log.levels.ERROR) end
  if not (type(result) == 'table' and type(result.value) == 'table') then return end
  local value = result.value
  -- Construct LSP progress id
  local client_name = vim.lsp.get_client_by_id(ctx.client_id).name
  if type(client_name) ~= 'string' then client_name = string.format('LSP[id=%s]', ctx.client_id) end
  local buf_id = ctx.bufnr or 'nil'
  local lsp_progress_id = buf_id .. client_name .. (result.token or '')
  local progress_data = H.lsp_progress[lsp_progress_id] or {}
  -- Store percentage to be used if no new one was sent
  progress_data.percentage = value.percentage or progress_data.percentage or 0
  -- Stop notifications without update on progress end.
  -- This usually results into a cleaner and more informative history.
  -- Delay removal to not cause flicker.
  if value.kind == 'end' then
    H.lsp_progress[lsp_progress_id] = nil
    local delay = math.max(lsp_progress_config.duration_last, 0)
    vim.defer_fn(function() MiniNotify.remove(progress_data.notif_id) end, delay)
  -- Cache title because it is only supplied on 'begin'
  if value.kind == 'begin' then progress_data.title = value.title end
  -- Make notification
  --stylua: ignore
  local msg = string.format(
    '%s: %s %s (%s%%)',
    client_name, progress_data.title or '', value.message or '', progress_data.percentage
  if progress_data.notif_id == nil then
    progress_data.notif_id = MiniNotify.add(msg)
    MiniNotify.update(progress_data.notif_id, { msg = msg })
  -- Cache progress data
  H.lsp_progress[lsp_progress_id] = progress_data
-- Buffer ---------------------------------------------------------------------
H.buffer_create = function()
  local buf_id = vim.api.nvim_create_buf(false, true)
  vim.bo[buf_id].filetype = 'mininotify'
  return buf_id
H.buffer_refresh = function(buf_id, notif_arr)
  local ns_id = H.ns_id.highlight
  -- Ensure clear buffer
  vim.api.nvim_buf_clear_namespace(buf_id, ns_id, 0, -1)
  vim.api.nvim_buf_set_lines(buf_id, 0, -1, true, {})
  -- Compute lines and highlight regions
  local lines, highlights = {}, {}
  for _, notif in ipairs(notif_arr) do
    local notif_lines = vim.split(notif.msg, '\n')
    for _, l in ipairs(notif_lines) do
      table.insert(lines, l)
    table.insert(highlights, { group = notif.hl_group, from_line = #lines - #notif_lines + 1, to_line = #lines })
  -- Set lines and highlighting
  vim.api.nvim_buf_set_lines(buf_id, 0, -1, true, lines)
  local extmark_opts = { end_col = 0, hl_eol = true, hl_mode = 'combine' }
  for _, hi_data in ipairs(highlights) do
    extmark_opts.end_row, extmark_opts.hl_group = hi_data.to_line, hi_data.group
    vim.api.nvim_buf_set_extmark(buf_id, ns_id, hi_data.from_line - 1, 0, extmark_opts)
H.buffer_default_dimensions = function(buf_id, max_width_share)
  local line_widths = vim.tbl_map(vim.fn.strdisplaywidth, vim.api.nvim_buf_get_lines(buf_id, 0, -1, true))
  -- Compute width so as to fit all lines
  local width = 1
  for _, l_w in ipairs(line_widths) do
    width = math.max(width, l_w)
  -- - Limit from above for better visuals
  max_width_share = math.min(math.max(max_width_share, 0), 1)
  local max_width = math.max(math.floor(max_width_share * vim.o.columns), 1)
  width = math.min(width, max_width)
  -- Compute height based on the width so as to fit all lines with 'wrap' on
  local height = 0
  for _, l_w in ipairs(line_widths) do
    height = height + math.floor(math.max(l_w - 1, 0) / width) + 1
  return width, height
-- Window ---------------------------------------------------------------------
H.window_open = function(buf_id)
  local config = H.window_compute_config(buf_id, true)
  local win_id = vim.api.nvim_open_win(buf_id, false, config)
  vim.wo[win_id].foldenable = false
  vim.wo[win_id].wrap = true
  vim.wo[win_id].winblend = H.get_config().window.winblend
  -- Neovim=0.7 doesn't support invalid highlight groups in 'winhighlight'
  vim.wo[win_id].winhighlight = 'NormalFloat:MiniNotifyNormal,FloatBorder:MiniNotifyBorder'
    .. (vim.fn.has('nvim-0.8') == 1 and ',FloatTitle:MiniNotifyTitle' or '')
  return win_id
H.window_compute_config = function(buf_id, is_for_open)
  local has_tabline = vim.o.showtabline == 2 or (vim.o.showtabline == 1 and #vim.api.nvim_list_tabpages() > 1)
  local has_statusline = vim.o.laststatus > 0
  local max_height = vim.o.lines - vim.o.cmdheight - (has_tabline and 1 or 0) - (has_statusline and 1 or 0)
  local max_width = vim.o.columns
  local config_win = H.get_config().window
  local default_config = { relative = 'editor', style = 'minimal', noautocmd = is_for_open, zindex = 999 }
  default_config.anchor, default_config.col, default_config.row = 'NE', vim.o.columns, has_tabline and 1 or 0
  default_config.width, default_config.height = H.buffer_default_dimensions(buf_id, config_win.max_width_share)
  default_config.border = 'single'
  -- Don't allow focus to not disrupt window navigation
  default_config.focusable = false
  local win_config = config_win.config
  if vim.is_callable(win_config) then win_config = win_config(buf_id) end
  local config = vim.tbl_deep_extend('force', default_config, win_config or {})
  -- Tweak config values to ensure they are proper, accounting for border
  local offset = config.border == 'none' and 0 or 2
  config.height = math.min(config.height, max_height - offset)
  config.width = math.min(config.width, max_width - offset)
  return config
H.window_close = function()
  if H.is_valid_win(H.cache.win_id) then vim.api.nvim_win_close(H.cache.win_id, true) end
  H.cache.win_id = nil
-- Notifications --------------------------------------------------------------
H.validate_msg = function(x)
  if type(x) ~= 'string' then H.error('`msg` should be string.') end
H.validate_level = function(x)
  if vim.log.levels[x] == nil then H.error('`level` should be key of `vim.log.levels`.') end
H.validate_hl_group = function(x)
  if type(x) ~= 'string' then H.error('`hl_group` should be string.') end
H.is_notification = function(x)
  return type(x) == 'table'
    and type(x.msg) == 'string'
    and vim.log.levels[x.level] ~= nil
    and type(x.hl_group) == 'string'
    and type(x.ts_add) == 'number'
    and type(x.ts_update) == 'number'
    and (x.ts_remove == nil or type(x.ts_remove) == 'number')
H.is_notification_array = function(x)
  if not vim.tbl_islist(x) then return false end
  for _, y in ipairs(x) do
    if not H.is_notification(y) then return false end
  return true
H.notif_apply_format = function(notif_arr, format)
  for _, notif in ipairs(notif_arr) do
    local res = format(notif)
    if type(res) ~= 'string' then H.error('Output of `content.format` should be string.') end
    notif.msg = res
  return notif_arr
H.notif_compare = function(a, b)
  local a_priority, b_priority = H.level_priority[a.level], H.level_priority[b.level]
  return a_priority > b_priority or (a_priority == b_priority and a.ts_update > b.ts_update)
-- Utilities ------------------------------------------------------------------
H.error = function(msg) error(string.format('(mini.notify) %s', msg), 0) end
H.is_valid_buf = function(buf_id) return type(buf_id) == 'number' and vim.api.nvim_buf_is_valid(buf_id) end
H.is_valid_win = function(win_id) return type(win_id) == 'number' and vim.api.nvim_win_is_valid(win_id) end
H.is_win_in_tabpage = function(win_id) return vim.api.nvim_win_get_tabpage(win_id) == vim.api.nvim_get_current_tabpage() end
H.get_timestamp = function()
  -- This is more acceptable for `vim.fn.strftime()` than `vim.loop.hrtime()`
  local seconds, microseconds = vim.loop.gettimeofday()
  return seconds + 0.000001 * microseconds
return MiniNotify

FilesExpand file tree

notify.lua

Latest commit

History

notify.lua

File metadata and controls