Lua Promise

local thread = require("thread")
local Promise
do
  local _class_0
  local _base_0 = {
    next = function(self, onResolve, onReject)
      table.insert(self.fulfilledHandlers, onResolve)
      if self.state == "fulfilled" then
        self:resolve(self.result)
      end
      if not onReject then
        onReject = function(e)
          return error(e)
        end
      end
      table.insert(self.rejectedHandlers, onReject)
      return self
    end,
    catch = function(self, onReject)
      table.insert(self.rejectedHandlers, onReject)
      if self.state == "rejected" then
        self:reject(self.result)
      end
      table.insert(self.fulfilledHandlers, function(a)
        return a
      end)
      return self
    end,
    await = function(self)
      thread.waitForAny({
        self.thread
      })
      return self.result
    end
  }
  _base_0.__index = _base_0
  _class_0 = setmetatable({
    __init = function(self, async)
      self.result = { }
      self.rejectedHandlers = { }
      self.fulfilledHandlers = { }
      self.state = "pending"
      local handlersCache = 0
      self.resolve = function(self, a)
        self.result = a
        local handlers = self.fulfilledHandlers
        for i = handlersCache + 1, #handlers do
          handlersCache = i
          if type(self.result) == "table" and self.result.__class == self.__class then
            local result = self.result:await()
            if self.result.state == "rejected" then
              self:reject(self.result)
              return
            end
            self.result = result
          end
          local res = {
            pcall(handlers[i], self.result)
          }
          local success = table.remove(res, 1)
          self.result = res[1]
          if not success then
            self:reject(self.result)
            return
          end
        end
        self.state = "fulfilled"
      end
      self.reject = function(self, a)
        self.result = a
        local handlers = self.rejectedHandlers
        for i = handlersCache + 1, #handlers do
          handlersCache = i
          local res = {
            pcall(handlers[i], self.result)
          }
          local success = table.remove(res, 1)
          self.result = res[1]
          if success then
            self:resolve(self.result)
            return
          end
        end
        self.state = "rejected"
      end
      self.thread = thread.create(function()
        local resolve
        resolve = function(...)
          if self.state == "pending" then
            return self:resolve(...)
          end
        end
        local reject
        reject = function(...)
          if self.state == "pending" then
            return self:reject(...)
          end
        end
        local success, reason = pcall(async, resolve, reject)
        if not success then
          return self:reject(reason)
        end
      end)
    end,
    __base = _base_0,
    __name = "Promise"
  }, {
    __index = _base_0,
    __call = function(cls, ...)
      local _self_0 = setmetatable({}, _base_0)
      cls.__init(_self_0, ...)
      return _self_0
    end
  })
  _base_0.__class = _class_0
  Promise = _class_0
end
Promise.all = function(list)
  return Promise(function(resolve, reject)
    local values = { }
    while true do
      os.sleep(0.1)
      local isFulfilled = true
      for i = 1, #list do
        local prom = list[i]
        if prom.state == "pending" then
          isFulfilled = false
        elseif prom.state == "rejected" then
          reject(prom.result)
        elseif prom.state == "fulfilled" then
          table.remove(list, i)
          local promResult = prom.result
          table.insert(values, promResult)
        end
      end
      if isFulfilled then
        resolve(values)
      end
    end
  end)
end
Promise.race = function(list)
  for i = 1, #list do
    if not (type(list[i]) == "table" and list[i].__class and list[i].__class.__name == "Promise") then
      list[i] = Promise.resolve(list[i])
    end
  end
  return Promise(function(resolve, reject)
    while true do
      os.sleep(0.1)
      for i = 1, #list do
        local prom = list[i]
        if prom.state ~= "pending" then
          if prom.state == "rejected" then
            reject(prom.result)
          elseif prom.state == "fulfilled" then
            resolve(prom.result)
          end
        end
      end
    end
  end)
end
Promise.resolve = function(value)
  return Promise(function(a, b)
    return a(value)
  end)
end
Promise.reject = function(reason)
  return Promise(function(a, b)
    return b(reason)
  end)
end
return Promise