Throttle infoview updates on cursor movement

Rapid cursor movement (e.g. holding j/k) was sending an LSP request
for every CursorMoved event. Now the first event fires immediately
but subsequent ones during a 50ms cooldown are collapsed, with only
the latest position flushed once the cooldown expires.

Author: Julian

lua/lean/config.lua

@@ -47,6 +47,7 @@
 ---@class lean.infoview.Config
 ---@field mappings? { [string]: ElementEvent }
 ---@field orientation? "auto"|"vertical"|"horizontal" what orientation to use for opened infoviews
+---@field update_cooldown? integer milliseconds to throttle cursor-move updates (default 50, 0 to disable)
 ---@field view_options? InfoviewViewOptions
 ---@field severity_markers? table<lsp.DiagnosticSeverity, string> characters to use for denoting diagnostic severity
 

lua/lean/infoview.lua

@@ -8,6 +8,7 @@
 local Buffer = require 'std.nvim.buffer'
 local Window = require 'std.nvim.window'
 local async = require 'std.async'
+local throttle = require 'std.throttle'
 ---Convert a buffer position to a human-readable (1, 1)-indexed string.
 ---Takes the workspace into account in order to return a relative path.
 ---@param buffer Buffer
@@ -98,6 +99,7 @@ local options = {
 
   autoopen = true,
   autopause = false,
+  update_cooldown = 50,
   indicators = 'auto',
   show_processing = true,
   show_no_info_message = false,
@@ -203,6 +205,9 @@ function Infoview:new(obj)
   }, self)
   new_infoview.info = Info:new { infoview = new_infoview }
   new_infoview.info:render()
+  new_infoview.__throttled_pin_update = throttle(options.update_cooldown, function(pin)
+    pin:update()
+  end)
   return new_infoview
 end
 
@@ -720,7 +725,19 @@ function Infoview:__update()
   end
   info:update_last_window()
   local cursor = vim.api.nvim_win_get_cursor(0)
-  info:move_pin(Buffer:current(), { cursor[1] - 1, cursor[2] })
+  local buffer = Buffer:current()
+  local pos = { cursor[1] - 1, cursor[2] }
+
+  -- Update the diff pin first, while the extmark is still at the old
+  -- position (it reads the extmark to get the "previous" location).
+  if info.__auto_diff_pin then
+    info:__update_auto_diff_pin(buffer, pos)
+  end
+  -- Move the extmark immediately so the pin indicator stays responsive,
+  -- but throttle the LSP request + render so rapid cursor movement
+  -- doesn't flood the server.
+  info.pin:__update_extmark(buffer, pos)
+  self.__throttled_pin_update(info.pin)
 end
 
 ---Directly mark that the infoview has died. What a shame.

lua/std/throttle.lua

@@ -0,0 +1,40 @@
+---@mod std.throttle Throttle
+---@brief [[
+--- Leading-edge throttle with trailing flush.
+---@brief ]]
+
+--- Create a throttled function that fires immediately on the first call,
+--- then suppresses further calls during an `ms` millisecond cooldown.
+--- If calls were suppressed, the latest one fires after the cooldown expires.
+---@param ms integer cooldown in milliseconds
+---@param fn function the function to throttle
+---@return function throttled the throttled wrapper
+local function throttle(ms, fn)
+  if ms == 0 then
+    return fn
+  end
+
+  local timer = vim.uv.new_timer()
+  local pending = nil
+
+  return function(...)
+    if not timer:is_active() then
+      fn(...)
+    else
+      pending = { ... }
+    end
+    timer:start(
+      ms,
+      0,
+      vim.schedule_wrap(function()
+        if pending then
+          local args = pending
+          pending = nil
+          fn(unpack(args))
+        end
+      end)
+    )
+  end
+end
+
+return throttle

scripts/minimal_init.lua

@@ -32,6 +32,7 @@ vim.g.lean_config = {
       print('error: ' .. lines)
     end,
   },
+  infoview = { update_cooldown = 0 },
   mappings = true,
 }
 

spec/std/throttle_spec.lua

@@ -0,0 +1,66 @@
+local throttle = require 'std.throttle'
+
+describe('throttle', function()
+  it('fires immediately on the first call', function()
+    local calls = {}
+    local fn = throttle(50, function(x)
+      table.insert(calls, x)
+    end)
+
+    fn 'a'
+    assert.are.same({ 'a' }, calls)
+  end)
+
+  it('suppresses calls during the cooldown', function()
+    local calls = {}
+    local fn = throttle(50, function(x)
+      table.insert(calls, x)
+    end)
+
+    fn 'a'
+    fn 'b'
+    fn 'c'
+    assert.are.same({ 'a' }, calls)
+  end)
+
+  it('flushes the latest suppressed call after the cooldown', function()
+    local calls = {}
+    local fn = throttle(10, function(x)
+      table.insert(calls, x)
+    end)
+
+    fn 'a'
+    fn 'b'
+    fn 'c'
+    assert.are.same({ 'a' }, calls)
+
+    vim.wait(50, function()
+      return #calls > 1
+    end)
+    assert.are.same({ 'a', 'c' }, calls)
+  end)
+
+  it('fires immediately again after the cooldown expires with no pending call', function()
+    local calls = {}
+    local fn = throttle(10, function(x)
+      table.insert(calls, x)
+    end)
+
+    fn 'a'
+    vim.wait(50, function() end)
+    fn 'b'
+    assert.are.same({ 'a', 'b' }, calls)
+  end)
+
+  it('passes through directly when cooldown is 0', function()
+    local calls = {}
+    local fn = throttle(0, function(x)
+      table.insert(calls, x)
+    end)
+
+    fn 'a'
+    fn 'b'
+    fn 'c'
+    assert.are.same({ 'a', 'b', 'c' }, calls)
+  end)
+end)