chore: trim unused async utils

Author: yioneko

lua/nvim-tree/async.lua

@@ -51,20 +51,6 @@ function M.in_async()
   return async_threads[thread] ~= nil
 end
 
----Wrap an asynchronous function to be directly called in synchronous context
----@param func function
----@param argc number The number of arguments the wrapped function accepts. Pass it if you want the returned function to receive an additional callback as final argument, and the signature of callback is the same as that of `async.exec`.
----@return function
-function M.wrap(func, argc)
-  return function(...)
-    local args = { ... }
-    if argc == nil or #args == argc then
-      table.insert(args, function() end)
-    end
-    M.exec(func, unpack(args))
-  end
-end
-
 ---Asynchronously call a function, which has callback as the last parameter (like luv apis)
 ---@param func function
 ---@param ... any
@@ -77,104 +63,12 @@ function M.call(func, ...)
   end)
 end
 
----Execuate multiple asynchronous function simultaneously
----@param ... fun()
----@return table[] (err, ...result) tuples from every function
-function M.all(...)
-  local tasks = { ... }
-  if #tasks == 0 then
-    return {}
-  end
-
-  local results = {}
-  local finished = 0
-  return co.yield(function(cb)
-    for i, task in ipairs(tasks) do
-      M.exec(task, function(...)
-        finished = finished + 1
-        results[i] = { ... }
-        if finished == #tasks then
-          cb(results)
-        end
-      end)
-    end
-  end)
-end
-
 ---Asynchronous `vim.schedule`
+---See `:h lua-loop-callbacks` and `:h api-fast`. Usually this should be used before `vim.api.*` and `vim.fn.*` calls.
 function M.schedule()
   return co.yield(function(cb)
     vim.schedule(cb)
   end)
 end
 
----@class Interrupter
----@field yield fun()
----@field interval number
----@field last number
-local Interrupter = {}
-
----@return Interrupter
-function Interrupter.new(ms, yield)
-  local obj = {
-    interval = ms or 12,
-    last = vim.loop.hrtime(),
-    yield = yield or M.schedule,
-  }
-  setmetatable(obj, { __index = Interrupter })
-  return obj
-end
-
-function Interrupter:check()
-  local cur = vim.loop.hrtime()
-  if cur - self.last >= self.interval * 1000000 then
-    self:yield()
-    self.last = cur
-  end
-end
-
-M.Interrupter = Interrupter
-
----This is useful for cancelling execution async function
----@class AbortSignal
----@field aborted boolean
----@field reason any
----@field private abort_cbs function[]
-local AbortSignal = {}
-
----@return AbortSignal
-function AbortSignal.new()
-  local obj = {
-    aborted = false,
-    reason = nil,
-    abort_cbs = {},
-  }
-
-  setmetatable(obj, { __index = AbortSignal })
-  return obj
-end
-
-function AbortSignal:abort(reason)
-  if not self.aborted then
-    self.aborted = true
-    self.reason = reason
-    for _, cb in pairs(self.abort_cbs) do
-      cb(reason)
-    end
-  end
-end
-
----@param cb function
-function AbortSignal:on_abort(cb)
-  table.insert(self.abort_cbs, cb)
-end
-
-function AbortSignal:throw_if_aborted()
-  if self.aborted then
-    error(self.reason)
-  end
-end
-
-M.AbortSignal = AbortSignal
-
 return M