feat: implement preview split

## Details

Add a new API `:RenderMarkdown preview` which shows a rendered buffer to
the side of the current buffer rather than in it. This allows editing to
happen in a buffer with no decorations and to have a rendered view to
the side, like many IDEs support.

When opened decorations will be removed from the "source" buffer until
the "preview" buffer is closed, at which point decorations will be shown
as usual. Only a single preview will be open at one time for a given
buffer. Calling `:RenderMarkdown preview` a second time will cause the
preview buffer to be closed, so it functions like a toggle.

Configurations for the "preview" buffer are generated from the "source"
buffer, so should all render the same. Custom values can be set for
"preview" buffers only using `overrides.preview`, by default this is
used to change `render_modes` to `true`, so rendering will happen while
the buffer is being edited.

Under the hood this is implemented by creating a new buffer and copying
text over to it on "TextChanged" events. To avoid overly jumpy behavior
we take advantage of `vim.diff` to modify as few lines between changes
as possible. Overall performance seems to be pretty good, with no major
catches that I noticed.

This feature will likely need to be improved as it is tested under
different circumstances, but as is I think it's in a good enough state
to release, enjoy :)

Author: MeanderingProgrammer

README.md

@@ -132,6 +132,7 @@ require('render-markdown').setup({}) -- only mandatory if you want to set custom
 | `:RenderMarkdown get`           | `require('render-markdown').get()`          | Return current state                              |
 | `:RenderMarkdown set bool?`     | `require('render-markdown').set(bool?)`     | Sets state, `nil` to toggle                       |
 | `:RenderMarkdown set_buf bool?` | `require('render-markdown').set_buf(bool?)` | Sets state for current buffer, `nil` to toggle    |
+| `:RenderMarkdown preview`       | `require('render-markdown').preview()`      | Show rendered buffer to the side                  |
 | `:RenderMarkdown log`           | `require('render-markdown').log()`          | Opens the log file for this plugin                |
 | `:RenderMarkdown expand`        | `require('render-markdown').expand()`       | Increase anti-conceal margin above and below by 1 |
 | `:RenderMarkdown contract`      | `require('render-markdown').contract()`     | Decrease anti-conceal margin above and below by 1 |
@@ -922,6 +923,10 @@ require('render-markdown').setup({
         },
         -- Override for different filetype values, @see :h 'filetype'.
         filetype = {},
+        -- Override for preview buffer
+        preview = {
+            render_modes = true,
+        },
     },
     custom_handlers = {
         -- Mapping from treesitter language to user defined handlers.

doc/render-markdown.txt

@@ -180,6 +180,9 @@ VIM.PACK                                    *render-markdown-install-vim.pack*
   :RenderMarkdown set_buf bool?   require('render-markdown').set_buf(bool?)   Sets state for current
                                                                               buffer, nil to toggle
 
+  :RenderMarkdown preview         require('render-markdown').preview()        Show rendered buffer to the
+                                                                              side
+
   :RenderMarkdown log             require('render-markdown').log()            Opens the log file for this
                                                                               plugin
 
@@ -986,6 +989,10 @@ Default Configuration ~
             },
             -- Override for different filetype values, @see :h 'filetype'.
             filetype = {},
+            -- Override for preview buffer
+            preview = {
+                render_modes = true,
+            },
         },
         custom_handlers = {
             -- Mapping from treesitter language to user defined handlers.

lua/render-markdown/api.lua

@@ -40,6 +40,10 @@ function M.buf_toggle()
     M.set_buf()
 end
 
+function M.preview()
+    require('render-markdown.core.preview').attach()
+end
+
 function M.log()
     require('render-markdown.core.log').open()
 end

lua/render-markdown/core/preview.lua

@@ -0,0 +1,135 @@
+local env = require('render-markdown.lib.env')
+local manager = require('render-markdown.core.manager')
+
+---@class render.md.Preview
+local M = {}
+
+---@private
+M.group = vim.api.nvim_create_augroup('RenderMarkdownPreview', {})
+
+---@private
+---@type table<integer, integer>
+M.buffers = {}
+
+---@param buf integer
+---@return integer?
+function M.get(buf)
+    for src, dst in pairs(M.buffers) do
+        if buf == dst then
+            return src
+        end
+    end
+    return nil
+end
+
+---@param src_buf? integer
+function M.attach(src_buf)
+    src_buf = src_buf or env.buf.current()
+    if not manager.attached(src_buf) then
+        return
+    end
+    if M.buffers[src_buf] then
+        vim.api.nvim_buf_delete(M.buffers[src_buf], {})
+        return
+    end
+
+    -- disable rendering for source buffer
+    manager.set_buf(src_buf, false)
+
+    local src_win = env.buf.win(src_buf)
+    local dst_buf = vim.api.nvim_create_buf(false, true)
+    local dst_win = vim.api.nvim_open_win(dst_buf, false, {
+        split = 'right',
+    })
+    M.buffers[src_buf] = dst_buf
+
+    env.buf.set(dst_buf, 'bufhidden', 'wipe')
+    env.buf.set(dst_buf, 'buftype', 'nofile')
+    env.buf.set(dst_buf, 'filetype', env.buf.get(src_buf, 'filetype'))
+    env.buf.set(dst_buf, 'modifiable', false)
+    env.buf.set(dst_buf, 'swapfile', false)
+
+    M.copy_cursor(src_win, dst_win)
+    vim.api.nvim_create_autocmd({ 'CursorMoved', 'CursorMovedI' }, {
+        group = M.group,
+        buffer = src_buf,
+        callback = function(args)
+            if env.valid(src_buf, src_win) and env.valid(dst_buf, dst_win) then
+                M.copy_cursor(src_win, dst_win)
+                M.copy_event(args, dst_buf)
+            end
+        end,
+    })
+
+    M.copy_lines(src_buf, dst_buf)
+    vim.api.nvim_create_autocmd({ 'TextChanged', 'TextChangedI' }, {
+        group = M.group,
+        buffer = src_buf,
+        callback = function(args)
+            if env.valid(src_buf, src_win) and env.valid(dst_buf, dst_win) then
+                -- also need to copy cursor due to event ordering
+                M.copy_lines(src_buf, dst_buf)
+                M.copy_cursor(src_win, dst_win)
+                M.copy_event(args, dst_buf)
+            end
+        end,
+    })
+
+    vim.api.nvim_create_autocmd('BufWipeout', {
+        group = M.group,
+        buffer = dst_buf,
+        once = true,
+        callback = function()
+            M.buffers[src_buf] = nil
+            vim.api.nvim_clear_autocmds({ group = M.group, buffer = src_buf })
+            -- enable rendering for source buffer
+            manager.set_buf(src_buf, true)
+        end,
+    })
+end
+
+---@private
+---@param src integer
+---@param dst integer
+function M.copy_lines(src, dst)
+    local src_lines = vim.api.nvim_buf_get_lines(src, 0, -1, false)
+    local dst_lines = vim.api.nvim_buf_get_lines(dst, 0, -1, false)
+
+    local src_text = table.concat(src_lines, '\n') .. '\n'
+    local dst_text = table.concat(dst_lines, '\n') .. '\n'
+    local diff = vim.diff(dst_text, src_text, { result_type = 'indices' })
+    assert(type(diff) == 'table', 'diff must provide indices')
+
+    env.buf.set(dst, 'modifiable', true)
+    for i = 1, #diff do
+        local hunk = diff[#diff - i + 1]
+        local start_a, count_a, start_b, count_b = unpack(hunk)
+        local line_start = start_a - 1
+        local line_end = start_a + count_a - 1
+        if count_a == 0 then
+            line_start = line_start + 1
+            line_end = line_end + 1
+        end
+        vim.api.nvim_buf_set_lines(dst, line_start, line_end, false, {
+            unpack(src_lines, start_b, start_b + count_b - 1),
+        })
+    end
+    env.buf.set(dst, 'modifiable', false)
+end
+
+---@private
+---@param src integer
+---@param dst integer
+function M.copy_cursor(src, dst)
+    local cursor = vim.api.nvim_win_get_cursor(src)
+    pcall(vim.api.nvim_win_set_cursor, dst, cursor)
+end
+
+---@private
+---@param args vim.api.keyset.create_autocmd.callback_args
+---@param buf integer
+function M.copy_event(args, buf)
+    vim.api.nvim_exec_autocmds(args.event, { buffer = buf })
+end
+
+return M

lua/render-markdown/health.lua

@@ -6,7 +6,7 @@ local state = require('render-markdown.state')
 local M = {}
 
 ---@private
-M.version = '8.9.7'
+M.version = '8.9.8'
 
 function M.check()
     M.start('versions')

lua/render-markdown/lib/config.lua

@@ -11,8 +11,9 @@ Config.__index = Config
 ---@param root render.md.Config
 ---@param enabled boolean
 ---@param buf integer
+---@param src? integer
 ---@return render.md.buf.Config
-function Config.new(root, enabled, buf)
+function Config.new(root, enabled, buf, src)
     ---@type render.md.partial.Config
     local config = {
         enabled = enabled,
@@ -42,12 +43,15 @@ function Config.new(root, enabled, buf)
     }
     config = vim.deepcopy(config)
     for _, name in ipairs({ 'buflisted', 'buftype', 'filetype' }) do
-        local value = env.buf.get(buf, name)
+        local value = env.buf.get(src or buf, name)
         local override = root.overrides[name][value] ---@type render.md.partial.UserConfig?
         if override then
             config = vim.tbl_deep_extend('force', config, override)
         end
     end
+    if src then
+        config = vim.tbl_deep_extend('force', config, root.overrides.preview)
+    end
     local self = setmetatable(config, Config)
     self.resolved = Resolved.new(config)
     ---@cast self -render.md.partial.Config

lua/render-markdown/settings.lua

@@ -1360,6 +1360,7 @@ M.overrides = {}
 ---@field buflisted table<boolean, render.md.partial.UserConfig>
 ---@field buftype table<string, render.md.partial.UserConfig>
 ---@field filetype table<string, render.md.partial.UserConfig>
+---@field preview render.md.partial.UserConfig
 
 ---@type render.md.overrides.Config
 M.overrides.default = {
@@ -1382,6 +1383,10 @@ M.overrides.default = {
     },
     -- Override for different filetype values, @see :h 'filetype'.
     filetype = {},
+    -- Override for preview buffer
+    preview = {
+        render_modes = true,
+    },
 }
 
 ---@return render.md.Schema
@@ -1393,6 +1398,7 @@ function M.overrides.schema()
             buflisted = { map = { { type = 'boolean' }, Config.schema({}) } },
             buftype = { map = { { type = 'string' }, Config.schema({}) } },
             filetype = { map = { { type = 'string' }, Config.schema({}) } },
+            preview = Config.schema({}),
         },
     }
 end

lua/render-markdown/state.lua

@@ -51,7 +51,8 @@ end
 function M.get(buf)
     local result = M.cache[buf]
     if not result then
-        result = Config.new(M.config, M.enabled, buf)
+        local src = require('render-markdown.core.preview').get(buf)
+        result = Config.new(M.config, M.enabled, buf, src)
         M.cache[buf] = result
     end
     return result

lua/render-markdown/types.lua

@@ -241,6 +241,7 @@
 ---@field buflisted? table<boolean, render.md.partial.UserConfig>
 ---@field buftype? table<string, render.md.partial.UserConfig>
 ---@field filetype? table<string, render.md.partial.UserConfig>
+---@field preview? render.md.partial.UserConfig
 
 ---@class (exact) render.md.padding.UserConfig
 ---@field highlight? string