1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
|
--- Allows chaining of async operations without callback hell
---
--- @class blink.cmp.Task
--- @field status blink.cmp.TaskStatus
--- @field result any | nil
--- @field error any | nil
--- @field new fun(fn: fun(resolve: fun(result: any), reject: fun(err: any))): blink.cmp.Task
---
--- @field cancel fun(self: blink.cmp.Task)
--- @field map fun(self: blink.cmp.Task, fn: fun(result: any): blink.cmp.Task | any): blink.cmp.Task
--- @field catch fun(self: blink.cmp.Task, fn: fun(err: any): blink.cmp.Task | any): blink.cmp.Task
---
--- @field on_completion fun(self: blink.cmp.Task, cb: fun(result: any))
--- @field on_failure fun(self: blink.cmp.Task, cb: fun(err: any))
--- @field on_cancel fun(self: blink.cmp.Task, cb: fun())
--- @field _completion_cbs function[]
--- @field _failure_cbs function[]
--- @field _cancel_cbs function[]
--- @field _cancel? fun()
local task = {
__task = true,
}
---@enum blink.cmp.TaskStatus
local STATUS = {
RUNNING = 1,
COMPLETED = 2,
FAILED = 3,
CANCELLED = 4,
}
function task.new(fn)
local self = setmetatable({}, { __index = task })
self.status = STATUS.RUNNING
self._completion_cbs = {}
self._failure_cbs = {}
self._cancel_cbs = {}
self.result = nil
self.error = nil
local resolve = function(result)
if self.status ~= STATUS.RUNNING then return end
self.status = STATUS.COMPLETED
self.result = result
for _, cb in ipairs(self._completion_cbs) do
cb(result)
end
end
local reject = function(err)
if self.status ~= STATUS.RUNNING then return end
self.status = STATUS.FAILED
self.error = err
for _, cb in ipairs(self._failure_cbs) do
cb(err)
end
end
local success, cancel_fn_or_err = pcall(function() return fn(resolve, reject) end)
if not success then
reject(cancel_fn_or_err)
elseif type(cancel_fn_or_err) == 'function' then
self._cancel = cancel_fn_or_err
end
return self
end
function task:cancel()
if self.status ~= STATUS.RUNNING then return end
self.status = STATUS.CANCELLED
if self._cancel ~= nil then self._cancel() end
for _, cb in ipairs(self._cancel_cbs) do
cb()
end
end
--- mappings
function task:map(fn)
local chained_task
chained_task = task.new(function(resolve, reject)
self:on_completion(function(result)
local success, mapped_result = pcall(fn, result)
if not success then
reject(mapped_result)
return
end
if type(mapped_result) == 'table' and mapped_result.__task then
mapped_result:on_completion(resolve)
mapped_result:on_failure(reject)
mapped_result:on_cancel(function() chained_task:cancel() end)
return
end
resolve(mapped_result)
end)
self:on_failure(reject)
self:on_cancel(function() chained_task:cancel() end)
return function() chained_task:cancel() end
end)
return chained_task
end
function task:catch(fn)
local chained_task
chained_task = task.new(function(resolve, reject)
self:on_completion(resolve)
self:on_failure(function(err)
local success, mapped_err = pcall(fn, err)
if not success then
reject(mapped_err)
return
end
if type(mapped_err) == 'table' and mapped_err.__task then
mapped_err:on_completion(resolve)
mapped_err:on_failure(reject)
mapped_err:on_cancel(function() chained_task:cancel() end)
return
end
resolve(mapped_err)
end)
self:on_cancel(function() chained_task:cancel() end)
return function() chained_task:cancel() end
end)
return chained_task
end
--- events
function task:on_completion(cb)
if self.status == STATUS.COMPLETED then
cb(self.result)
elseif self.status == STATUS.RUNNING then
table.insert(self._completion_cbs, cb)
end
return self
end
function task:on_failure(cb)
if self.status == STATUS.FAILED then
cb(self.error)
elseif self.status == STATUS.RUNNING then
table.insert(self._failure_cbs, cb)
end
return self
end
function task:on_cancel(cb)
if self.status == STATUS.CANCELLED then
cb()
elseif self.status == STATUS.RUNNING then
table.insert(self._cancel_cbs, cb)
end
return self
end
--- utils
function task.await_all(tasks)
if #tasks == 0 then
return task.new(function(resolve) resolve({}) end)
end
local all_task
all_task = task.new(function(resolve, reject)
local results = {}
local has_resolved = {}
local function resolve_if_completed()
-- we can't check #results directly because a table like
-- { [2] = { ... } } has a length of 2
for i = 1, #tasks do
if has_resolved[i] == nil then return end
end
resolve(results)
end
for idx, task in ipairs(tasks) do
task:on_completion(function(result)
results[idx] = result
has_resolved[idx] = true
resolve_if_completed()
end)
task:on_failure(function(err)
reject(err)
for _, task in ipairs(tasks) do
task:cancel()
end
end)
task:on_cancel(function()
for _, sub_task in ipairs(tasks) do
sub_task:cancel()
end
if all_task == nil then
vim.schedule(function() all_task:cancel() end)
else
all_task:cancel()
end
end)
end
end)
return all_task
end
function task.empty()
return task.new(function(resolve) resolve() end)
end
return { task = task, STATUS = STATUS }
|
