feat(0.11): process conceal_lines metadata from highlights

## Details

This is some of the work needed to better handle the recent
conceal_lines change added to neovim:
#352

In order to better render code blocks, or at least have the ability to,
we first need to figure out which lines are impacted by the change. To
do this update the `conceal` module to process this additional metadata
and store it. Expose this information again through the `context` module.

This change does not include using this information to actually improve
the rendering, but having it ready to go is useful, and the code block
implementation to get around this is going to be pretty tedious.

Some minor refactoring along the way to make these changes a little easier.

Author: MeanderingProgrammer

doc/render-markdown.txt

@@ -1,4 +1,4 @@
-*render-markdown.txt*         For 0.10.0         Last change: 2025 February 27
+*render-markdown.txt*         For 0.10.0         Last change: 2025 February 28
 
 ==============================================================================
 Table of Contents                          *render-markdown-table-of-contents*

lua/render-markdown/core/conceal.lua

@@ -1,10 +1,21 @@
 local Str = require('render-markdown.lib.str')
+local util = require('render-markdown.core.util')
+
+---@class render.md.conceal.Section
+---@field start_col integer
+---@field end_col integer
+---@field width integer
+---@field character? string
+
+---@class render.md.conceal.Line
+---@field hidden boolean
+---@field sections render.md.conceal.Section[]
 
 ---@class render.md.Conceal
 ---@field private buf integer
 ---@field private level integer
 ---@field private computed boolean
----@field private rows table<integer, [integer, integer, integer][]>
+---@field private lines table<integer, render.md.conceal.Line>
 local Conceal = {}
 Conceal.__index = Conceal
 
@@ -16,7 +27,7 @@ function Conceal.new(buf, level)
     self.buf = buf
     self.level = level
     self.computed = false
-    self.rows = {}
+    self.lines = {}
     return self
 end
 
@@ -26,59 +37,83 @@ function Conceal:enabled()
 end
 
 ---@param row integer
----@param start_col integer
----@param end_col integer
----@param amount integer
----@param character? string
-function Conceal:add(row, start_col, end_col, amount, character)
-    if not self:enabled() or amount == 0 then
+---@param entry boolean|render.md.conceal.Section
+function Conceal:add(row, entry)
+    if not self:enabled() then
         return
     end
-    if self.rows[row] == nil then
-        self.rows[row] = {}
+    if self.lines[row] == nil then
+        self.lines[row] = { hidden = false, sections = {} }
     end
-    -- If the range is already concealed by another don't add it
-    for _, range in ipairs(self.rows[row]) do
-        if range[1] <= start_col and range[2] >= end_col then
+    local line = self.lines[row]
+    if type(entry) == 'boolean' then
+        line.hidden = entry
+    else
+        if entry.width <= 0 then
             return
         end
+        -- If the section is covered by an existing one don't add it
+        for _, section in ipairs(line.sections) do
+            if section.start_col <= entry.start_col and section.end_col >= entry.end_col then
+                return
+            end
+        end
+        table.insert(line.sections, entry)
     end
-    table.insert(self.rows[row], { start_col, end_col, self:adjust(amount, character) })
 end
 
----@param amount integer
+---@param width integer
 ---@param character? string
 ---@return integer
-function Conceal:adjust(amount, character)
+function Conceal:adjust(width, character)
     if self.level == 1 then
-        -- Level 1: each block is replaced with one character
-        amount = amount - 1
+        -- each block is replaced with one character
+        return width - 1
     elseif self.level == 2 then
-        -- Level 2: replacement character width is used
-        amount = amount - Str.width(character)
+        -- replacement character width is used
+        return width - Str.width(character)
+    else
+        return width
     end
-    return amount
+end
+
+---@param context render.md.Context
+---@param node render.md.Node
+---@return boolean
+function Conceal:hidden(context, node)
+    -- conceal lines metadata require neovim >= 0.11.0 to function
+    return util.has_11 and self:line(context, node).hidden
 end
 
 ---@param context render.md.Context
 ---@param node render.md.Node
 ---@return integer
 function Conceal:get(context, node)
-    if not self.computed then
-        self.computed = true
-        self:compute(context)
-    end
-
     local result = 0
-    local ranges = self.rows[node.start_row] or {}
-    for _, range in ipairs(ranges) do
-        if node.start_col < range[2] and node.end_col > range[1] then
-            result = result + range[3]
+    for _, section in ipairs(self:line(context, node).sections) do
+        if node.start_col < section.end_col and node.end_col > section.start_col then
+            local amount = self:adjust(section.width, section.character)
+            result = result + amount
         end
     end
     return result
 end
 
+---@private
+---@param context render.md.Context
+---@param node render.md.Node
+function Conceal:line(context, node)
+    if not self.computed then
+        self:compute(context)
+        self.computed = true
+    end
+    local line = self.lines[node.start_row]
+    if line == nil then
+        line = { hidden = false, sections = {} }
+    end
+    return line
+end
+
 ---Cached row level implementation of vim.treesitter.get_captures_at_pos
 ---@private
 ---@param context render.md.Context
@@ -116,21 +151,40 @@ function Conceal:compute_tree(context, language, root)
     end
     context:for_each(function(range)
         for id, node, metadata in query:iter_captures(root, self.buf, range.top, range.bottom) do
+            if metadata.conceal_lines ~= nil then
+                local node_range = self:node_range(id, node, metadata)
+                local row = unpack(node_range)
+                self:add(row, true)
+            end
             if metadata.conceal ~= nil then
-                local node_range = metadata.range
-                if node_range == nil and metadata[id] ~= nil then
-                    node_range = metadata[id].range
-                end
-                if node_range == nil then
-                    ---@diagnostic disable-next-line: missing-fields
-                    node_range = { node:range() }
-                end
+                local node_range = self:node_range(id, node, metadata)
                 local row, start_col, _, end_col = unpack(node_range)
-                local amount = Str.width(vim.treesitter.get_node_text(node, self.buf))
-                self:add(row, start_col, end_col, amount, metadata.conceal)
+                self:add(row, {
+                    start_col = start_col,
+                    end_col = end_col,
+                    width = Str.width(vim.treesitter.get_node_text(node, self.buf)),
+                    character = metadata.conceal,
+                })
             end
         end
     end)
 end
 
+---@private
+---@param id integer
+---@param node TSNode
+---@param metadata vim.treesitter.query.TSMetadata
+---@return Range
+function Conceal:node_range(id, node, metadata)
+    local range = metadata.range
+    if range ~= nil then
+        return range
+    end
+    range = metadata[id] ~= nil and metadata[id].range or nil
+    if range ~= nil then
+        return range
+    end
+    return { node:range() }
+end
+
 return Conceal

lua/render-markdown/core/context.lua

@@ -123,6 +123,15 @@ function Context:tab_size()
     return util.get('buf', self.buf, 'tabstop')
 end
 
+---@param node? render.md.Node
+---@return boolean
+function Context:hidden(node)
+    if node == nil then
+        return false
+    end
+    return self.conceal:hidden(self, node)
+end
+
 ---@param node? render.md.Node
 ---@return integer
 function Context:width(node)

lua/render-markdown/core/util.lua

@@ -2,6 +2,7 @@
 local M = {}
 
 M.has_10 = vim.fn.has('nvim-0.10') == 1
+M.has_11 = vim.fn.has('nvim-0.11') == 1
 
 ---@param key 'ft'|'cmd'
 ---@return string[]

lua/render-markdown/health.lua

@@ -5,7 +5,7 @@ local state = require('render-markdown.state')
 local M = {}
 
 ---@private
-M.version = '8.0.13'
+M.version = '8.0.14'
 
 function M.check()
     M.start('version')

lua/render-markdown/lib/list.lua

@@ -99,7 +99,12 @@ function Marks:update_context(mark)
     local row, start_col = mark.start_row, mark.start_col
     local end_col = mark.opts.end_col or start_col
     if mark.opts.conceal ~= nil then
-        self.context.conceal:add(row, start_col, end_col, end_col - start_col)
+        self.context.conceal:add(row, {
+            start_col = start_col,
+            end_col = end_col,
+            width = end_col - start_col,
+            character = mark.opts.conceal,
+        })
     end
     if mark.opts.virt_text_pos == 'inline' then
         local amount = 0

lua/render-markdown/render/code.lua

@@ -96,9 +96,11 @@ function Render:render()
     local background = vim.tbl_contains({ 'normal', 'full' }, self.code.style) and not disabled_language
 
     local icon = self:language()
-    self:border(icon)
+    local start_row, end_row = self.node.start_row, self.node.end_row - 1
+    self:border(start_row, self.code.above, not icon and self:hidden(self.data.code_node))
+    self:border(end_row, self.code.below, true)
     if background then
-        self:background(self.node.start_row + 1, self.node.end_row - 2)
+        self:background(start_row + 1, end_row - 1)
     end
     self:left_pad(background)
 end
@@ -127,7 +129,7 @@ function Render:language()
         self:sign(icon, icon_highlight)
     end
 
-    local icon_text = icon .. ' '
+    local text = icon .. ' '
     local highlight = { icon_highlight }
     if self.code.border ~= 'none' then
         table.insert(highlight, self.code.highlight)
@@ -136,25 +138,25 @@ function Render:language()
     if self.code.position == 'left' then
         if self.code.language_name and self:hidden(node) then
             -- Code blocks pick up varying amounts of leading white space depending
-            -- on the context they are in. This is lumped into the delimiter node and
-            -- as a result, after concealing, the extmark would be shifted.
+            -- on the context they are in. This is lumped into the delimiter node
+            -- and as a result, after concealing, the extmark would be shifted.
             local padding = Str.spaces('start', self.node.text) + self.data.language_padding
-            icon_text = Str.pad(padding) .. icon_text .. node.text
+            text = Str.pad(padding) .. text .. node.text
         end
         return self.marks:add_start('code_language', node, {
-            virt_text = { { icon_text, highlight } },
+            virt_text = { { text, highlight } },
             virt_text_pos = 'inline',
         })
     elseif self.code.position == 'right' then
         if self.code.language_name then
-            icon_text = icon_text .. node.text
+            text = text .. node.text
         end
         local win_col = self.data.max_width - self.data.language_padding
         if self.code.width == 'block' then
-            win_col = win_col - Str.width(icon_text) + self.data.indent
+            win_col = win_col - Str.width(text) + self.data.indent
         end
         return self.marks:add('code_language', node.start_row, 0, {
-            virt_text = { { icon_text, highlight } },
+            virt_text = { { text, highlight } },
             virt_text_win_col = win_col,
         })
     else
@@ -163,36 +165,45 @@ function Render:language()
 end
 
 ---@private
----@param icon boolean
-function Render:border(icon)
+---@param row integer
+---@param border string
+---@param context_hidden boolean
+function Render:border(row, border, context_hidden)
     if self.code.border == 'none' then
         return
     end
-
-    ---@param row integer
-    ---@param border string
-    ---@param context_hidden boolean
-    local function add_border(row, border, context_hidden)
-        local delim_node = self.node:child('fenced_code_block_delimiter', row)
-        if self.code.border == 'thin' and context_hidden and self:hidden(delim_node) then
-            local width = self.code.width == 'block' and self.data.max_width or vim.o.columns
-            self.marks:add('code_border', row, self.data.col, {
-                virt_text = { { border:rep(width - self.data.col), colors.bg_to_fg(self.code.highlight) } },
-                virt_text_pos = 'overlay',
-            })
-        else
-            self:background(row, row)
-        end
+    local delim_node = self.node:child('fenced_code_block_delimiter', row)
+    if self.code.border == 'thin' and context_hidden and self:hidden(delim_node) then
+        local width = self.code.width == 'block' and self.data.max_width or vim.o.columns
+        local line = { { border:rep(width - self.data.col), colors.bg_to_fg(self.code.highlight) } }
+        self.marks:add('code_border', row, self.data.col, {
+            virt_text = line,
+            virt_text_pos = 'overlay',
+        })
+    else
+        self:background(row, row)
     end
-
-    add_border(self.node.start_row, self.code.above, not icon and self:hidden(self.data.code_node))
-    add_border(self.node.end_row - 1, self.code.below, true)
 end
 
 ---@private
 ---@param node? render.md.Node
 ---@return boolean
 function Render:hidden(node)
+    -- TODO(0.11): handle conceal_lines
+    -- - Use self.context:hidden(node) to determine if a node is hidden
+    -- - Default highlights remove the fenced code block delimiter lines along with
+    --   any extmarks we add there.
+    -- - To account for this we'll need add back the lines, likely using virt_lines.
+    -- - For top delimiter
+    --   - Add extmark above the top row with virt_lines_above = false
+    --   - By doing this we'll add a line just above the fenced code block
+    --   - We likely need to handle the sign column here as well
+    -- - For bottom delimiter
+    --   - Add extmark below the bottom row with virt_lines_above = true
+    --   - By doing this we'll add a line just below the fenced code block
+    -- - For both of these we'll need to do something that does anti_conceal via an
+    --   offset such that the cursor going over the concealed line naturally shows
+    --   the raw text and the virtual line disappears
     return self.context:width(node) == 0
 end
 

lua/render-markdown/render/heading.lua

@@ -36,6 +36,9 @@ function Render:setup()
     if self.context:skip(self.heading) then
         return false
     end
+    if self.context:hidden(self.node) then
+        return false
+    end
 
     local atx = nil
     local marker = nil

lua/render-markdown/render/table.lua

@@ -168,7 +168,7 @@ function Render:parse_row(row, num_columns)
     local columns = {}
     for i, cell in ipairs(cells) do
         local start_col, end_col = pipes[i].end_col, pipes[i + 1].start_col
-        -- Account for double width glyphs by replacing cell range with width
+        -- Account for double width glyphs by replacing cell range with its width
         local width = end_col - start_col
         width = width - (cell.end_col - cell.start_col) + self.context:width(cell)
         if width < 0 then
@@ -315,7 +315,7 @@ function Render:shift(column, side, amount)
             virt_text_pos = 'inline',
         })
     elseif amount < 0 then
-        amount = self.context.conceal:adjust(amount, nil)
+        amount = self.context.conceal:adjust(amount, '')
         self.marks:add(true, column.row, col + amount, {
             priority = 0,
             end_col = col,