feat: bullet padding functions

## Details

Request: #349

This allows both `bullet.left_pad` & `bullet.right_pad` to be a `function`
that returns an `integer` in addition to the basic `integer` value.

The input is the same `ctx` object that is provided to the `icon`
`function` and currently contains the following fields:

- `level`: how deeply nested the current list item is
- `index`: the index of the list item within its bottom most list
- `value`: the text value of the marker node, useful for ordered lists

Unrelated change: `Base:padding_text()` -> `Base:pad()`

Author: MeanderingProgrammer

lua/render-markdown/health.lua

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

lua/render-markdown/init.lua

@@ -159,11 +159,15 @@ local M = {}
 ---| string[][]
 ---| fun(ctx: render.md.BulletContext): string?
 
+---@alias render.md.bullet.Padding
+---| integer
+---| fun(ctx: render.md.BulletContext): integer
+
 ---@class (exact) render.md.UserBullet: render.md.UserBaseComponent
 ---@field public icons? render.md.bullet.Icons
 ---@field public ordered_icons? render.md.bullet.Icons
----@field public left_pad? integer
----@field public right_pad? integer
+---@field public left_pad? render.md.bullet.Padding
+---@field public right_pad? render.md.bullet.Padding
 ---@field public highlight? string
 
 ---@class (exact) render.md.UserDash: render.md.UserBaseComponent

lua/render-markdown/render/base.lua

@@ -95,11 +95,11 @@ function Base:indent_line(virtual, level)
         local indent = self.config.indent
         local icon_width = Str.width(indent.icon)
         if icon_width == 0 then
-            table.insert(line, self:padding_text(indent.per_level * level))
+            table.insert(line, self:pad(indent.per_level * level))
         else
             for _ = 1, level do
                 table.insert(line, { indent.icon, indent.highlight })
-                table.insert(line, self:padding_text(indent.per_level - icon_width))
+                table.insert(line, self:pad(indent.per_level - icon_width))
             end
         end
     end
@@ -139,7 +139,7 @@ end
 ---@param width integer
 ---@param highlight? string
 ---@return render.md.line.Text
-function Base:padding_text(width, highlight)
+function Base:pad(width, highlight)
     return { Str.pad(width), highlight or self.config.padding.highlight }
 end
 

lua/render-markdown/render/code.lua

@@ -203,7 +203,7 @@ function Render:background(start_row, end_row)
     local win_col, padding = 0, {}
     if self.code.width == 'block' then
         win_col = self.data.margin + self.data.max_width + self.data.indent
-        table.insert(padding, self:padding_text(vim.o.columns * 2))
+        table.insert(padding, self:pad(vim.o.columns * 2))
     end
     for row = start_row, end_row do
         self.marks:add('code_background', row, self.data.col, {
@@ -233,9 +233,9 @@ function Render:left_pad(background)
     -- Use lowest priority (0) to include all other marks in padding when code block is at edge
     -- Use medium priority (1000) to include border marks while likely avoiding other plugin
     local priority = self.data.col == 0 and 0 or 1000
-    local fill_text = self:padding_text(self.data.col)
-    local margin_text = self:padding_text(margin)
-    local padding_text = self:padding_text(padding, background and self.code.highlight or nil)
+    local fill_text = self:pad(self.data.col)
+    local margin_text = self:pad(margin)
+    local padding_text = self:pad(padding, background and self.code.highlight or nil)
 
     local start_row, end_row = self.node.start_row, (self.node.end_row - 1)
     for row = start_row, end_row do

lua/render-markdown/render/code_inline.lua

@@ -33,7 +33,7 @@ function Render:side_padding(highlight, row, col)
     if padding > 0 then
         self.marks:add(true, row, col, {
             priority = 0,
-            virt_text = { self:padding_text(padding, highlight) },
+            virt_text = { self:pad(padding, highlight) },
             virt_text_pos = 'inline',
         })
     end

lua/render-markdown/render/dash.lua

@@ -21,7 +21,7 @@ function Render:render()
 
     local virt_text = {}
     if margin > 0 then
-        table.insert(virt_text, self:padding_text(margin))
+        table.insert(virt_text, self:pad(margin))
     end
     table.insert(virt_text, { self.dash.icon:rep(width), self.dash.highlight })
 

lua/render-markdown/render/heading.lua

@@ -207,7 +207,7 @@ function Render:background(width)
     local win_col, padding = 0, {}
     if self.data.width == 'block' then
         win_col = width.margin + width.content + self:indent_size(self.data.level)
-        table.insert(padding, self:padding_text(vim.o.columns * 2))
+        table.insert(padding, self:pad(vim.o.columns * 2))
     end
     for row = self.node.start_row, self.node.end_row - 1 do
         self.marks:add('head_background', row, 0, {
@@ -238,11 +238,11 @@ function Render:border(width, position, icon, row)
 
     local foreground = self.data.foreground
     local background = self.data.background and colors.bg_to_fg(self.data.background)
-    local total_width = self.data.width == 'block' and width.content or vim.o.columns
     local prefix = self.heading.border_prefix and self.data.level or 0
+    local total_width = self.data.width == 'block' and width.content or vim.o.columns
 
     local line = {
-        self:padding_text(width.margin),
+        self:pad(width.margin),
         { icon:rep(width.padding), background },
         { icon:rep(prefix), foreground },
         { icon:rep(total_width - width.padding - prefix), background },
@@ -271,10 +271,10 @@ end
 function Render:left_pad(width)
     local virt_text = {}
     if width.margin > 0 then
-        table.insert(virt_text, self:padding_text(width.margin))
+        table.insert(virt_text, self:pad(width.margin))
     end
     if width.padding > 0 then
-        table.insert(virt_text, self:padding_text(width.padding, self.data.background))
+        table.insert(virt_text, self:pad(width.padding, self.data.background))
     end
     if #virt_text == 0 then
         return

lua/render-markdown/render/list_item.lua

@@ -46,8 +46,17 @@ function Render:render()
             return
         end
         local level, root = self.node:level_in_section('list')
-        self:icon(level)
-        self:padding(root)
+        ---@type render.md.BulletContext
+        local ctx = {
+            level = level,
+            index = self.node:sibling_count('list_item'),
+            value = self.data.marker.text,
+        }
+        local icon = self:get_icon(ctx)
+        local left_pad = self:get_padding(ctx, self.bullet.left_pad)
+        local right_pad = self:get_padding(ctx, self.bullet.right_pad)
+        self:add_icon(icon)
+        self:add_padding(left_pad, right_pad, root)
     end
 end
 
@@ -83,46 +92,63 @@ function Render:highlight_scope()
 end
 
 ---@private
----@param level integer
-function Render:icon(level)
-    local node = self.data.marker
-    local index = self.node:sibling_count('list_item')
+---@param ctx render.md.BulletContext
+---@return string?
+function Render:get_icon(ctx)
     local icons = self.data.ordered and self.bullet.ordered_icons or self.bullet.icons
-    local icon = nil
     if type(icons) == 'function' then
-        icon = icons({ level = level, index = index, value = node.text })
+        return icons(ctx)
     else
-        icon = List.cycle(icons, level)
+        local icon = List.cycle(icons, ctx.level)
         if type(icon) == 'table' then
-            icon = List.clamp(icon, index)
+            return List.clamp(icon, ctx.index)
+        else
+            return icon
         end
     end
+end
+
+---@private
+---@param ctx render.md.BulletContext
+---@param pad render.md.bullet.Padding
+---@return integer
+function Render:get_padding(ctx, pad)
+    if type(pad) == 'function' then
+        return pad(ctx)
+    else
+        return pad
+    end
+end
+
+---@private
+---@param icon string?
+function Render:add_icon(icon)
     if icon == nil then
         return
     end
     local text = Str.pad(self.data.spaces) .. icon
-    local position, conceal = 'overlay', nil
-    if Str.width(text) > Str.width(node.text) then
-        position, conceal = 'inline', ''
-    end
-    self.marks:add_over('bullet', node, {
+    local overflow = Str.width(text) > Str.width(self.data.marker.text)
+    self.marks:add_over('bullet', self.data.marker, {
         virt_text = { { text, self.bullet.highlight } },
-        virt_text_pos = position,
-        conceal = conceal,
+        virt_text_pos = overflow and 'inline' or 'overlay',
+        conceal = overflow and '' or nil,
     })
 end
 
 ---@private
+---@param left_pad integer
+---@param right_pad integer
 ---@param root? render.md.Node
-function Render:padding(root)
-    if self.bullet.left_pad <= 0 and self.bullet.right_pad <= 0 then
+function Render:add_padding(left_pad, right_pad, root)
+    if left_pad <= 0 and right_pad <= 0 then
         return
     end
-    local left_col = root ~= nil and root.start_col or self.node.start_col
-    for row = self.node.start_row, self:end_row(root) - 1 do
-        local right_col = row == self.node.start_row and self.data.marker.end_col - 1 or left_col
-        self:padding_mark(row, left_col, self.bullet.left_pad)
-        self:padding_mark(row, right_col, self.bullet.right_pad)
+    local start_row, end_row = self.node.start_row, self:end_row(root)
+    for row = start_row, end_row - 1 do
+        local left_col = root ~= nil and root.start_col or self.node.start_col
+        local right_col = row == start_row and self.data.marker.end_col - 1 or left_col
+        self:side_padding(row, left_col, left_pad)
+        self:side_padding(row, right_col, right_pad)
     end
 end
 
@@ -133,26 +159,26 @@ function Render:end_row(root)
     local next_list = self.node:child('list')
     if next_list ~= nil then
         return next_list.start_row
-    end
-    local end_row = self.node.end_row
-    -- On the last item of the root list ignore the last line if it is empty
-    if root ~= nil and root.end_row == end_row then
-        if Str.width(self.node:line('last', 0)) == 0 then
-            return end_row - 1
+    else
+        local row = self.node.end_row
+        -- On the last item of the root list ignore the last line if it is empty
+        if root ~= nil and root.end_row == row and Str.width(root:line('last', 0)) == 0 then
+            return row - 1
+        else
+            return row
         end
     end
-    return end_row
 end
 
 ---@private
 ---@param row integer
 ---@param col integer
 ---@param amount integer
-function Render:padding_mark(row, col, amount)
+function Render:side_padding(row, col, amount)
     if amount > 0 then
         self.marks:add(false, row, col, {
             priority = 0,
-            virt_text = { self:padding_text(amount) },
+            virt_text = { self:pad(amount) },
             virt_text_pos = 'inline',
         })
     end

lua/render-markdown/render/paragraph.lua

@@ -27,7 +27,7 @@ function Render:render()
         return
     end
 
-    local virt_text = { self:padding_text(margin) }
+    local virt_text = { self:pad(margin) }
     for row = self.node.start_row, self.node.end_row - 1 do
         self.marks:add(false, row, 0, {
             priority = 0,

lua/render-markdown/render/table.lua

@@ -375,7 +375,7 @@ function Render:full()
     ---@param above boolean
     ---@param chars { [1]: string, [2]: string, [3]: string }
     local function table_border(node, above, chars)
-        local line = spaces > 0 and { self:padding_text(spaces) } or {}
+        local line = spaces > 0 and { self:pad(spaces) } or {}
         local highlight = above and self.table.head or self.table.row
         table.insert(line, { chars[1] .. table.concat(sections, chars[2]) .. chars[3], highlight })
         self.marks:add_start(false, node, {