fix detection bug when element ends in blank line

Author: jrop

lua/morph.lua

@@ -391,16 +391,24 @@ Pos00.__index = Pos00
 
 --- @param row integer 0-based row
 --- @param col integer 0-based column
+--- @return morph.Pos00
 function Pos00.new(row, col) return setmetatable({ row, col }, Pos00) end
 
-function Pos00:__eq(other) return self[1] == other[1] and self[2] == other[2] end
+--- @param other unknown
+function Pos00:__eq(other)
+  return type(other) == 'table' and self[1] == other[1] and self[2] == other[2]
+end
 
+--- @param other unknown
 function Pos00:__lt(other)
+  if type(other) ~= 'table' then return false end
   if self[1] ~= other[1] then return self[1] < other[1] end
   return self[2] < other[2]
 end
 
+--- @param other unknown
 function Pos00:__gt(other)
+  if type(other) ~= 'table' then return false end
   if self[1] ~= other[1] then return self[1] > other[1] end
   return self[2] > other[2]
 end
@@ -461,6 +469,12 @@ function Extmark.by_id(bufnr, ns, id)
 end
 
 --- @private
+--- @param bufnr integer
+--- @param ns integer
+--- @param id integer
+--- @param start_row0 integer
+--- @param start_col0 integer
+--- @param details vim.api.keyset.extmark_details
 --- Construct an Extmark from raw API data, normalizing bounds that extend past buffer end.
 function Extmark._from_raw(bufnr, ns, id, start_row0, start_col0, details)
   local start = Pos00.new(start_row0, start_col0)
@@ -488,6 +502,10 @@ end
 
 --- @private
 --- Find all extmarks that overlap with the given region.
+--- @param bufnr integer
+--- @param ns integer
+--- @param start morph.Pos00
+--- @param stop morph.Pos00
 --- @return morph.Extmark[]
 function Extmark._get_in_range(bufnr, ns, start, stop)
   local raw_extmarks = vim.api.nvim_buf_get_extmarks(
@@ -509,6 +527,7 @@ end
 
 --- @private
 --- Extract the text content covered by this extmark.
+--- @return string
 function Extmark:_text()
   local start, stop = self.start, self.stop
   if start == stop then return '' end
@@ -664,6 +683,7 @@ function Morph.markup_to_lines(opts)
   -- so we can cache it for on_change handlers later
   local text_accumulators = {} --- @type { text: string[] }[]
 
+  --- @param s string
   local function emit_text(s)
     lines[curr_line1] = (lines[curr_line1] or '') .. s
     curr_col1 = #lines[curr_line1] + 1
@@ -682,6 +702,7 @@ function Morph.markup_to_lines(opts)
     end
   end
 
+  --- @param node morph.Tree
   local function visit(node)
     local node_type = tree_type(node)
 
@@ -942,6 +963,7 @@ function Morph:mount(tree)
   -- Callbacks scheduled via ctx:do_after_render() - run after each render
   local after_render_callbacks = {} --- @type function[]
 
+  --- @param cb function
   local function schedule_after_render(cb) table.insert(after_render_callbacks, cb) end
 
   -- Forward declarations for mutual recursion
@@ -1029,7 +1051,11 @@ function Morph:mount(tree)
 
     -- Pre-compute "identity keys" for each node so we can match them up
     -- A key combines: type + component function (if any) + explicit key attribute
-    local old_keys, new_keys = {}, {}
+    --- @type table<integer, string>
+    local old_keys = {}
+    --- @type table<integer, string>
+    local new_keys = {}
+    --- @type table<morph.Tree, string>
     local node_key_cache = {}
 
     for i, node in ipairs(old_nodes) do
@@ -1092,7 +1118,7 @@ function Morph:mount(tree)
   end
 
   --- Reconcile a component node (mount, update, or reuse existing context).
-  --- @param old_tree morph.Node[]
+  --- @param old_tree morph.Tree
   --- @param new_tag morph.Tag
   reconcile_component = function(old_tree, new_tag)
     local Component = new_tag.name --[[@as morph.Component]]
@@ -1177,7 +1203,7 @@ function Morph:get_elements_at(pos, mode)
   local elements = {} --- @type morph.Element[]
   for _, extmark in ipairs(candidates) do
     local tag = self.text_content.curr.extmark_ids_to_tag[extmark.id]
-    if tag and self:_position_intersects_extmark(pos, extmark, mode) then
+    if tag and self._position_intersects_extmark(pos, extmark, mode) then
       table.insert(elements, vim.tbl_extend('force', {}, tag, { extmark = extmark }))
     end
   end
@@ -1194,8 +1220,10 @@ end
 
 --- @private
 --- Check if a position truly intersects an extmark (Neovim's API is over-inclusive).
---- @diagnostic disable-next-line: unused
-function Morph:_position_intersects_extmark(pos, extmark, mode)
+--- @param pos morph.Pos00
+--- @param extmark morph.Extmark
+--- @param mode? string
+function Morph._position_intersects_extmark(pos, extmark, mode)
   local start, stop = extmark.start, extmark.stop
 
   -- Zero-width extmarks at cursor position are considered intersecting
@@ -1209,6 +1237,15 @@ function Morph:_position_intersects_extmark(pos, extmark, mode)
 
   -- Check column bounds on stop row
   if pos[1] == stop[1] then
+    -- Special case: on an empty line where extmark ends at column 0,
+    -- the cursor at column 0 should be considered inside. This happens when
+    -- an element ends with a newline - the cursor on the resulting empty line
+    -- has nowhere else to be, so it should still trigger handlers.
+    if pos[2] == 0 and stop[2] == 0 then
+      local line = vim.api.nvim_buf_get_lines(extmark.bufnr, pos[1], pos[1] + 1, true)[1] or ''
+      if #line == 0 then return true end
+    end
+
     -- In insert mode the cursor is "thin" (between characters), so we include
     -- the position if it's <= stop (cursor can sit "on" the boundary)
     -- In normal mode the cursor is "wide" (occupies a character), so we only
@@ -1245,6 +1282,8 @@ end
 --- @private
 --- Handle a keypress by dispatching to element handlers (innermost first).
 --- Returns the key to execute, or '' to swallow the keypress.
+--- @param mode string
+--- @param lhs string
 function Morph:_dispatch_keypress(mode, lhs)
   local cursor = vim.api.nvim_win_get_cursor(0)
   --- @diagnostic disable-next-line: need-check-nil, assign-type-mismatch

spec/morph_spec.lua

@@ -1559,6 +1559,140 @@ describe('Morph', function()
         assert.are.same('z', result)
       end)
     end)
+
+    it('triggers handler on trailing empty line when element ends with newline', function()
+      with_buf({}, function()
+        local r = Morph.new(0)
+        local handler_called = false
+
+        -- Buffer has single element ending with newline:
+        --   Line 0: "hello"
+        --   Line 1: "" (empty, from trailing \n)
+        -- Extmark covers (0,0) to (1,0)
+        r:render {
+          h('text', {
+            id = 'with-newline',
+            nmap = {
+              ['<CR>'] = function()
+                handler_called = true
+                return ''
+              end,
+            },
+          }, 'hello\n'),
+        }
+
+        assert.are.same({ 'hello', '' }, get_lines())
+
+        -- Cursor on the trailing empty line should still trigger the handler
+        set_cursor { 2, 0 } -- 1-based: row 2, col 0 (the empty line)
+        local result = r:_dispatch_keypress('n', '<CR>')
+
+        assert.are.same('', result)
+        assert.is_true(handler_called, 'Handler should be called on trailing empty line')
+      end)
+    end)
+
+    it('triggers second element handler when first ends with newline and second follows', function()
+      with_buf({}, function()
+        local r = Morph.new(0)
+        local first_called = false
+        local second_called = false
+
+        -- Buffer:
+        --   Line 0: "hello"
+        --   Line 1: "world"
+        -- Element 'first': (0,0) to (1,0) - ends at start of line 1
+        -- Element 'second': (1,0) to (1,5) - covers "world"
+        r:render {
+          h('text', {
+            id = 'first',
+            nmap = {
+              ['<CR>'] = function()
+                first_called = true
+                return 'first'
+              end,
+            },
+          }, 'hello\n'),
+          h('text', {
+            id = 'second',
+            nmap = {
+              ['<CR>'] = function()
+                second_called = true
+                return 'second'
+              end,
+            },
+          }, 'world'),
+        }
+
+        assert.are.same({ 'hello', 'world' }, get_lines())
+
+        -- Cursor at start of "world" line - should be in second element only
+        set_cursor { 2, 0 } -- 1-based: row 2, col 0
+        local result = r:_dispatch_keypress('n', '<CR>')
+
+        assert.are.same('second', result)
+        assert.is_false(first_called, 'First handler should NOT be called')
+        assert.is_true(second_called, 'Second handler should be called')
+
+        -- Verify get_elements_at returns only second element in normal mode
+        local elems = r:get_elements_at { 1, 0 } -- 0-based
+        assert.are.same(1, #elems)
+        assert.are.same('second', elems[1].attributes.id)
+      end)
+    end)
+
+    it('returns both elements at boundary in insert mode', function()
+      with_buf({}, function()
+        local r = Morph.new(0)
+
+        -- Same setup: first element ends with newline, second follows
+        r:render {
+          h('text', { id = 'first' }, 'hello\n'),
+          h('text', { id = 'second' }, 'world'),
+        }
+
+        assert.are.same({ 'hello', 'world' }, get_lines())
+
+        -- In insert mode, cursor at boundary should see both elements
+        local elems = r:get_elements_at({ 1, 0 }, 'i') -- 0-based, insert mode
+        assert.are.same(2, #elems)
+        -- Second element is "innermost" (starts at cursor), first is "outer" (ends at cursor)
+        local ids = vim.tbl_map(function(e) return e.attributes.id end, elems)
+        assert.is_true(vim.tbl_contains(ids, 'first'))
+        assert.is_true(vim.tbl_contains(ids, 'second'))
+      end)
+    end)
+
+    it('does not trigger first element on non-empty line even if extmark ends there', function()
+      with_buf({}, function()
+        local r = Morph.new(0)
+        local first_called = false
+
+        -- Element 'first' ends at (1,0) but line 1 has content
+        r:render {
+          h('text', {
+            id = 'first',
+            nmap = {
+              ['x'] = function()
+                first_called = true
+                return ''
+              end,
+            },
+          }, 'hello\n'),
+          'world', -- plain text, no handler
+        }
+
+        assert.are.same({ 'hello', 'world' }, get_lines())
+
+        -- Cursor on "world" line - first element's handler should NOT fire
+        set_cursor { 2, 0 }
+        local result = r:_dispatch_keypress('n', 'x')
+
+        -- Should return original key (no handler matched)
+        assert.are.same('x', result)
+        assert.is_false(first_called)
+      end)
+    end)
   end)
 
   ------------------------------------------------------------------------------