Attach most auto commands at buffer level

## Details

This functions as a performance improvement by removing most of the
global auto commands setup by this plugin. Primarily common events
like TextChanged / ModeChanged.

Instead of having these at a global level and having internal logic
to avoid running on certain buffers keep only the FileType auto command
at a global level, use the input file types as a pattern directly.

From there attach the other auto commands to the buffer scope. Add
a manager module to keep track of buffers we've attached to. This is
to enable performing global actions on only buffers we care about. In
this case for WinResized events and for the toggle command.

Users should see no visible change from this other than improved
background performance of this plugin.

Author: MeanderingProgrammer

lua/render-markdown/init.lua

@@ -1,6 +1,5 @@
+local manager = require('render-markdown.manager')
 local state = require('render-markdown.state')
-local ui = require('render-markdown.ui')
-local util = require('render-markdown.util')
 
 local M = {}
 
@@ -240,52 +239,17 @@ function M.setup(opts)
     state.markdown_query = vim.treesitter.query.parse('markdown', state.config.markdown_query)
     state.inline_query = vim.treesitter.query.parse('markdown_inline', state.config.inline_query)
 
-    -- Call immediately to re-render on LazyReload
-    ui.schedule_refresh(vim.api.nvim_get_current_buf())
+    manager.setup()
 
-    local group = vim.api.nvim_create_augroup('RenderMarkdown', { clear = true })
-    vim.api.nvim_create_autocmd({ 'ModeChanged' }, {
-        group = group,
-        callback = function(event)
-            local render_modes = state.config.render_modes
-            local prev_rendered = vim.tbl_contains(render_modes, vim.v.event.old_mode)
-            local should_render = vim.tbl_contains(render_modes, vim.v.event.new_mode)
-            -- Only need to re-render if render state is changing. I.e. going from normal mode to
-            -- command mode with the default config, both are rendered, so no point re-rendering
-            if prev_rendered ~= should_render then
-                ui.schedule_refresh(event.buf)
-            end
-        end,
-    })
-    vim.api.nvim_create_autocmd({ 'WinResized' }, {
-        group = group,
-        callback = function()
-            for _, win in ipairs(vim.v.event.windows) do
-                local buf = util.win_to_buf(win)
-                ui.schedule_refresh(buf)
-            end
-        end,
-    })
-    vim.api.nvim_create_autocmd({ 'FileChangedShellPost', 'FileType', 'TextChanged' }, {
-        group = group,
-        callback = function(event)
-            ui.schedule_refresh(event.buf)
-        end,
-    })
-
-    local description = 'Switch between enabling & disabling render markdown plugin'
-    vim.api.nvim_create_user_command('RenderMarkdownToggle', M.toggle, { desc = description })
+    vim.api.nvim_create_user_command(
+        'RenderMarkdownToggle',
+        M.toggle,
+        { desc = 'Switch between enabling & disabling render markdown plugin' }
+    )
 end
 
 M.toggle = function()
-    state.enabled = not state.enabled
-    for _, buf in ipairs(vim.api.nvim_list_bufs()) do
-        if state.enabled then
-            ui.schedule_refresh(buf)
-        else
-            ui.schedule_clear(buf)
-        end
-    end
+    manager.toggle()
 end
 
 return M

lua/render-markdown/manager.lua

@@ -0,0 +1,77 @@
+local state = require('render-markdown.state')
+local ui = require('render-markdown.ui')
+local util = require('render-markdown.util')
+
+---@class render.md.manager.Data
+---@field buffers integer[]
+
+---@type render.md.manager.Data
+local data = {
+    buffers = {},
+}
+
+---@class render.md.Manager
+local M = {}
+
+function M.setup()
+    local group = vim.api.nvim_create_augroup('RenderMarkdown', { clear = true })
+    -- Attach to buffers based on matching filetype, this will add additional events
+    vim.api.nvim_create_autocmd({ 'FileType' }, {
+        group = group,
+        pattern = state.config.file_types,
+        callback = function(event)
+            M.attach(group, event.buf)
+        end,
+    })
+    -- Window resizing is not buffer specific so is managed more globablly
+    vim.api.nvim_create_autocmd({ 'WinResized' }, {
+        group = group,
+        callback = function()
+            for _, win in ipairs(vim.v.event.windows) do
+                local buf = util.win_to_buf(win)
+                if vim.tbl_contains(data.buffers, buf) then
+                    ui.schedule_refresh(buf)
+                end
+            end
+        end,
+    })
+end
+
+---@private
+---@param group integer
+---@param buf integer
+M.attach = function(group, buf)
+    if not vim.tbl_contains(data.buffers, buf) then
+        table.insert(data.buffers, buf)
+    end
+    vim.api.nvim_create_autocmd({ 'BufWinEnter', 'TextChanged' }, {
+        group = group,
+        buffer = buf,
+        callback = function()
+            ui.schedule_refresh(buf)
+        end,
+    })
+    vim.api.nvim_create_autocmd({ 'ModeChanged' }, {
+        group = group,
+        buffer = buf,
+        callback = function()
+            local render_modes = state.config.render_modes
+            local prev_rendered = vim.tbl_contains(render_modes, vim.v.event.old_mode)
+            local should_render = vim.tbl_contains(render_modes, vim.v.event.new_mode)
+            -- Only need to re-render if render state is changing. I.e. going from normal mode to
+            -- command mode with the default config, both are rendered, so no point re-rendering
+            if prev_rendered ~= should_render then
+                ui.schedule_refresh(buf)
+            end
+        end,
+    })
+end
+
+M.toggle = function()
+    state.enabled = not state.enabled
+    for _, buf in ipairs(data.buffers) do
+        ui.schedule_refresh(buf)
+    end
+end
+
+return M

lua/render-markdown/ui.lua

@@ -12,54 +12,73 @@ local builtin_handlers = {
 ---@class render.md.Ui
 local M = {}
 
+---@type integer
 M.namespace = vim.api.nvim_create_namespace('render-markdown.nvim')
 
 ---@param buf integer
 M.schedule_refresh = function(buf)
     local mode = vim.fn.mode(true)
     vim.schedule(function()
+        logger.start()
         M.refresh(buf, mode)
+        logger.flush()
     end)
 end
 
+---@private
 ---@param buf integer
-M.schedule_clear = function(buf)
-    vim.schedule(function()
-        M.clear_valid(buf)
-    end)
+---@param mode string
+M.refresh = function(buf, mode)
+    -- Remove any existing marks if buffer is valid
+    if not vim.api.nvim_buf_is_valid(buf) then
+        return
+    end
+    vim.api.nvim_buf_clear_namespace(buf, M.namespace, 0, -1)
+
+    -- Check that buffer is associated with a valid window before window operations
+    local win = util.buf_to_win(buf)
+    if not vim.api.nvim_win_is_valid(win) then
+        return
+    end
+
+    if not M.should_render(buf, win, mode) then
+        -- Set window options back to default
+        for name, value in pairs(state.config.win_options) do
+            util.set_win_option(win, name, value.default)
+        end
+    else
+        -- Set window options to rendered & perform render
+        for name, value in pairs(state.config.win_options) do
+            util.set_win_option(win, name, value.rendered)
+        end
+        -- Make sure injections are processed
+        local parser = vim.treesitter.get_parser(buf)
+        parser:parse(true)
+        parser:for_each_tree(function(tree, language_tree)
+            M.render(buf, language_tree:lang(), tree:root())
+        end)
+    end
 end
 
 ---@private
 ---@param buf integer
+---@param win integer
 ---@param mode string
-M.refresh = function(buf, mode)
+---@return boolean
+M.should_render = function(buf, win, mode)
     if not state.enabled then
-        return
+        return false
     end
-    if not M.clear_valid(buf) then
-        return
+    if not util.get_leftcol(win) == 0 then
+        return false
     end
     if not vim.tbl_contains(state.config.render_modes, mode) then
-        return
+        return false
     end
     if util.file_size_mb(buf) > state.config.max_file_size then
-        return
-    end
-
-    logger.start()
-    for name, value in pairs(state.config.win_options) do
-        util.set_win_option(buf, name, value.rendered)
+        return false
     end
-    -- Make sure injections are processed
-    local parser = vim.treesitter.get_parser(buf)
-    parser:parse(true)
-    parser:for_each_tree(function(tree, language_tree)
-        local language = language_tree:lang()
-        logger.debug('Language: ' .. language)
-        local executed = M.render(buf, language, tree:root())
-        logger.debug({ executed_handlers = executed })
-    end)
-    logger.flush()
+    return true
 end
 
 ---Run user & builtin handlers when available. User handler is always executed,
@@ -68,51 +87,21 @@ end
 ---@param buf integer
 ---@param language string
 ---@param root TSNode
----@return string[]
 M.render = function(buf, language, root)
-    local result = {}
+    logger.debug('Language: ' .. language)
     local user_handler = state.config.custom_handlers[language]
     if user_handler ~= nil then
+        logger.debug('Running user handler')
         user_handler.render(M.namespace, root, buf)
-        table.insert(result, 'user')
-        if user_handler.extends ~= true then
-            return result
+        if not user_handler.extends then
+            return
         end
     end
     local builtin_handler = builtin_handlers[language]
     if builtin_handler ~= nil then
+        logger.debug('Running builtin handler')
         builtin_handler.render(M.namespace, root, buf)
-        table.insert(result, 'builtin')
-    end
-    return result
-end
-
----Remove existing highlights / virtual text for valid buffers
----@private
----@param buf integer
----@return boolean
-M.clear_valid = function(buf)
-    if not vim.api.nvim_buf_is_valid(buf) then
-        return false
-    end
-    if not vim.tbl_contains(state.config.file_types, vim.bo[buf].filetype) then
-        return false
     end
-    vim.api.nvim_buf_clear_namespace(buf, M.namespace, 0, -1)
-    local win = util.buf_to_win(buf)
-    if not vim.api.nvim_win_is_valid(win) then
-        return false
-    end
-    for name, value in pairs(state.config.win_options) do
-        util.set_win_option(buf, name, value.default)
-    end
-    local leftcol = vim.api.nvim_win_call(win, function()
-        return vim.fn.winsaveview().leftcol
-    end)
-    if leftcol > 0 then
-        return false
-    end
-    return true
 end
 
 return M

lua/render-markdown/util.lua

@@ -14,16 +14,24 @@ M.buf_to_win = function(buf)
     return vim.fn.bufwinid(buf)
 end
 
----@param buf integer
+---@param win integer
 ---@param name string
 ---@param value any
-M.set_win_option = function(buf, name, value)
-    local opts = { scope = 'local', win = M.buf_to_win(buf) }
+M.set_win_option = function(win, name, value)
+    local opts = { scope = 'local', win = win }
     local before = vim.api.nvim_get_option_value(name, opts)
     vim.api.nvim_set_option_value(name, value, opts)
     logger.debug({ option = name, opts = opts, before = before, after = value })
 end
 
+---@param win integer
+---@return integer
+M.get_leftcol = function(win)
+    return vim.api.nvim_win_call(win, function()
+        return vim.fn.winsaveview().leftcol
+    end)
+end
+
 ---@param buf integer
 ---@return number
 M.file_size_mb = function(buf)