typescript-to-lua 1.22.0 → 1.24.0

package/dist/lualib/5.0/lualib_bundle.lua

@@ -592,6 +592,12 @@ local function __TS__ArrayWith(self, index, value)
     return copy
 end
 
+local function __TS__New(target, ...)
+    local instance = setmetatable({}, target.prototype)
+    instance:____constructor(unpack(arg))
+    return instance
+end
+
 local function __TS__InstanceOf(obj, classTbl)
     if type(classTbl) ~= "table" then
         error("Right-hand side of 'instanceof' is not an object", 0)
@@ -611,12 +617,6 @@ local function __TS__InstanceOf(obj, classTbl)
     return false
 end
 
-local function __TS__New(target, ...)
-    local instance = setmetatable({}, target.prototype)
-    instance:____constructor(unpack(arg))
-    return instance
-end
-
 local function __TS__Class(self)
     local c = {prototype = {}}
     c.prototype.__index = c.prototype
@@ -624,35 +624,27 @@ local function __TS__Class(self)
     return c
 end
 
-local function __TS__FunctionBind(fn, ...)
-    local boundArgs = arg
-    return function(____, ...)
-        local args = arg
-        __TS__ArrayUnshift(
-            args,
-            unpack(boundArgs)
-        )
-        return fn(unpack(args))
-    end
-end
-
 local __TS__Promise
 do
-    local function promiseDeferred(self)
+    local function makeDeferredPromiseFactory()
         local resolve
         local reject
-        local promise = __TS__New(
-            __TS__Promise,
-            function(____, res, rej)
-                resolve = res
-                reject = rej
-            end
-        )
-        return {promise = promise, resolve = resolve, reject = reject}
+        local function executor(____, res, rej)
+            resolve = res
+            reject = rej
+        end
+        return function()
+            local promise = __TS__New(__TS__Promise, executor)
+            return promise, resolve, reject
+        end
+    end
+    local makeDeferredPromise = makeDeferredPromiseFactory()
+    local function isPromiseLike(value)
+        return __TS__InstanceOf(value, __TS__Promise)
     end
-    local function isPromiseLike(self, thing)
-        return __TS__InstanceOf(thing, __TS__Promise)
+    local function doNothing(self)
     end
+    local ____pcall = _G.pcall
     __TS__Promise = __TS__Class()
     __TS__Promise.name = "__TS__Promise"
     function __TS__Promise.prototype.____constructor(self, executor)
@@ -660,206 +652,176 @@ do
         self.fulfilledCallbacks = {}
         self.rejectedCallbacks = {}
         self.finallyCallbacks = {}
-        do
-            local function ____catch(e)
-                self:reject(e)
-            end
-            local ____try, ____hasReturned = pcall(function()
-                executor(
-                    nil,
-                    __TS__FunctionBind(self.resolve, self),
-                    __TS__FunctionBind(self.reject, self)
-                )
-            end)
-            if not ____try then
-                ____catch(____hasReturned)
-            end
+        local success, ____error = ____pcall(
+            executor,
+            nil,
+            function(____, v) return self:resolve(v) end,
+            function(____, err) return self:reject(err) end
+        )
+        if not success then
+            self:reject(____error)
         end
     end
-    function __TS__Promise.resolve(data)
-        local promise = __TS__New(
-            __TS__Promise,
-            function()
-            end
-        )
+    function __TS__Promise.resolve(value)
+        if __TS__InstanceOf(value, __TS__Promise) then
+            return value
+        end
+        local promise = __TS__New(__TS__Promise, doNothing)
         promise.state = 1
-        promise.value = data
+        promise.value = value
         return promise
     end
     function __TS__Promise.reject(reason)
-        local promise = __TS__New(
-            __TS__Promise,
-            function()
-            end
-        )
+        local promise = __TS__New(__TS__Promise, doNothing)
         promise.state = 2
         promise.rejectionReason = reason
         return promise
     end
     __TS__Promise.prototype["then"] = function(self, onFulfilled, onRejected)
-        local ____promiseDeferred_result_0 = promiseDeferred(nil)
-        local promise = ____promiseDeferred_result_0.promise
-        local resolve = ____promiseDeferred_result_0.resolve
-        local reject = ____promiseDeferred_result_0.reject
-        local isFulfilled = self.state == 1
-        local isRejected = self.state == 2
-        if onFulfilled then
-            local internalCallback = self:createPromiseResolvingCallback(onFulfilled, resolve, reject)
-            local ____self_fulfilledCallbacks_1 = self.fulfilledCallbacks
-            ____self_fulfilledCallbacks_1[table.getn(____self_fulfilledCallbacks_1) + 1] = internalCallback
-            if isFulfilled then
-                internalCallback(nil, self.value)
-            end
-        else
-            local ____self_fulfilledCallbacks_2 = self.fulfilledCallbacks
-            ____self_fulfilledCallbacks_2[table.getn(____self_fulfilledCallbacks_2) + 1] = function(____, v) return resolve(nil, v) end
-        end
-        if onRejected then
-            local internalCallback = self:createPromiseResolvingCallback(onRejected, resolve, reject)
-            local ____self_rejectedCallbacks_3 = self.rejectedCallbacks
-            ____self_rejectedCallbacks_3[table.getn(____self_rejectedCallbacks_3) + 1] = internalCallback
-            if isRejected then
-                internalCallback(nil, self.rejectionReason)
-            end
-        else
-            local ____self_rejectedCallbacks_4 = self.rejectedCallbacks
-            ____self_rejectedCallbacks_4[table.getn(____self_rejectedCallbacks_4) + 1] = function(____, err) return reject(nil, err) end
-        end
-        if isFulfilled then
-            resolve(nil, self.value)
+        local promise, resolve, reject = makeDeferredPromise()
+        self:addCallbacks(
+            onFulfilled and self:createPromiseResolvingCallback(onFulfilled, resolve, reject) or resolve,
+            onRejected and self:createPromiseResolvingCallback(onRejected, resolve, reject) or reject
+        )
+        return promise
+    end
+    function __TS__Promise.prototype.addCallbacks(self, fulfilledCallback, rejectedCallback)
+        if self.state == 1 then
+            return fulfilledCallback(nil, self.value)
         end
-        if isRejected then
-            reject(nil, self.rejectionReason)
+        if self.state == 2 then
+            return rejectedCallback(nil, self.rejectionReason)
         end
-        return promise
+        local ____self_fulfilledCallbacks_0 = self.fulfilledCallbacks
+        ____self_fulfilledCallbacks_0[table.getn(____self_fulfilledCallbacks_0) + 1] = fulfilledCallback
+        local ____self_rejectedCallbacks_1 = self.rejectedCallbacks
+        ____self_rejectedCallbacks_1[table.getn(____self_rejectedCallbacks_1) + 1] = rejectedCallback
     end
     function __TS__Promise.prototype.catch(self, onRejected)
         return self["then"](self, nil, onRejected)
     end
     function __TS__Promise.prototype.finally(self, onFinally)
         if onFinally then
-            local ____self_finallyCallbacks_5 = self.finallyCallbacks
-            ____self_finallyCallbacks_5[table.getn(____self_finallyCallbacks_5) + 1] = onFinally
+            local ____self_finallyCallbacks_2 = self.finallyCallbacks
+            ____self_finallyCallbacks_2[table.getn(____self_finallyCallbacks_2) + 1] = onFinally
             if self.state ~= 0 then
                 onFinally(nil)
             end
         end
         return self
     end
-    function __TS__Promise.prototype.resolve(self, data)
-        if __TS__InstanceOf(data, __TS__Promise) then
-            data["then"](
-                data,
+    function __TS__Promise.prototype.resolve(self, value)
+        if isPromiseLike(value) then
+            return value:addCallbacks(
                 function(____, v) return self:resolve(v) end,
                 function(____, err) return self:reject(err) end
             )
-            return
         end
         if self.state == 0 then
             self.state = 1
-            self.value = data
-            for ____, callback in ipairs(self.fulfilledCallbacks) do
-                callback(nil, data)
-            end
-            for ____, callback in ipairs(self.finallyCallbacks) do
-                callback(nil)
-            end
+            self.value = value
+            return self:invokeCallbacks(self.fulfilledCallbacks, value)
         end
     end
     function __TS__Promise.prototype.reject(self, reason)
         if self.state == 0 then
             self.state = 2
             self.rejectionReason = reason
-            for ____, callback in ipairs(self.rejectedCallbacks) do
-                callback(nil, reason)
+            return self:invokeCallbacks(self.rejectedCallbacks, reason)
+        end
+    end
+    function __TS__Promise.prototype.invokeCallbacks(self, callbacks, value)
+        local callbacksLength = table.getn(callbacks)
+        local finallyCallbacks = self.finallyCallbacks
+        local finallyCallbacksLength = table.getn(finallyCallbacks)
+        if callbacksLength ~= 0 then
+            for i = 1, callbacksLength - 1 do
+                callbacks[i](callbacks, value)
             end
-            for ____, callback in ipairs(self.finallyCallbacks) do
-                callback(nil)
+            if finallyCallbacksLength == 0 then
+                return callbacks[callbacksLength](callbacks, value)
             end
+            callbacks[callbacksLength](callbacks, value)
+        end
+        if finallyCallbacksLength ~= 0 then
+            for i = 1, finallyCallbacksLength - 1 do
+                finallyCallbacks[i](finallyCallbacks)
+            end
+            return finallyCallbacks[finallyCallbacksLength](finallyCallbacks)
         end
     end
     function __TS__Promise.prototype.createPromiseResolvingCallback(self, f, resolve, reject)
         return function(____, value)
-            do
-                local function ____catch(e)
-                    reject(nil, e)
-                end
-                local ____try, ____hasReturned = pcall(function()
-                    self:handleCallbackData(
-                        f(nil, value),
-                        resolve,
-                        reject
-                    )
-                end)
-                if not ____try then
-                    ____catch(____hasReturned)
-                end
+            local success, resultOrError = ____pcall(f, nil, value)
+            if not success then
+                return reject(nil, resultOrError)
             end
+            return self:handleCallbackValue(resultOrError, resolve, reject)
         end
     end
-    function __TS__Promise.prototype.handleCallbackData(self, data, resolve, reject)
-        if isPromiseLike(nil, data) then
-            local nextpromise = data
+    function __TS__Promise.prototype.handleCallbackValue(self, value, resolve, reject)
+        if isPromiseLike(value) then
+            local nextpromise = value
             if nextpromise.state == 1 then
-                resolve(nil, nextpromise.value)
+                return resolve(nil, nextpromise.value)
             elseif nextpromise.state == 2 then
-                reject(nil, nextpromise.rejectionReason)
+                return reject(nil, nextpromise.rejectionReason)
             else
-                data["then"](data, resolve, reject)
+                return nextpromise:addCallbacks(resolve, reject)
             end
         else
-            resolve(nil, data)
+            return resolve(nil, value)
         end
     end
 end
 
-local function __TS__AsyncAwaiter(generator)
-    return __TS__New(
-        __TS__Promise,
-        function(____, resolve, reject)
-            local adopt, fulfilled, step, resolved, asyncCoroutine
-            function adopt(self, value)
-                return __TS__InstanceOf(value, __TS__Promise) and value or __TS__Promise.resolve(value)
-            end
-            function fulfilled(self, value)
-                local success, resultOrError = coroutine.resume(asyncCoroutine, value)
-                if success then
-                    step(nil, resultOrError)
-                else
-                    reject(nil, resultOrError)
+local __TS__AsyncAwaiter, __TS__Await
+do
+    local cocreate = coroutine.create
+    local coresume = coroutine.resume
+    local costatus = coroutine.status
+    local coyield = coroutine.yield
+    function __TS__AsyncAwaiter(generator)
+        return __TS__New(
+            __TS__Promise,
+            function(____, resolve, reject)
+                local fulfilled, step, resolved, asyncCoroutine
+                function fulfilled(self, value)
+                    local success, resultOrError = coresume(asyncCoroutine, value)
+                    if success then
+                        return step(resultOrError)
+                    end
+                    return reject(nil, resultOrError)
                 end
-            end
-            function step(self, result)
-                if resolved then
-                    return
+                function step(result)
+                    if resolved then
+                        return
+                    end
+                    if costatus(asyncCoroutine) == "dead" then
+                        return resolve(nil, result)
+                    end
+                    return __TS__Promise.resolve(result):addCallbacks(fulfilled, reject)
                 end
-                if coroutine.status(asyncCoroutine) == "dead" then
-                    resolve(nil, result)
+                resolved = false
+                asyncCoroutine = cocreate(generator)
+                local success, resultOrError = coresume(
+                    asyncCoroutine,
+                    function(____, v)
+                        resolved = true
+                        return __TS__Promise.resolve(v):addCallbacks(resolve, reject)
+                    end
+                )
+                if success then
+                    return step(resultOrError)
                 else
-                    local ____self_0 = adopt(nil, result)
-                    ____self_0["then"](____self_0, fulfilled, reject)
+                    return reject(nil, resultOrError)
                 end
             end
-            resolved = false
-            asyncCoroutine = coroutine.create(generator)
-            local success, resultOrError = coroutine.resume(
-                asyncCoroutine,
-                function(____, v)
-                    resolved = true
-                    local ____self_1 = adopt(nil, v)
-                    ____self_1["then"](____self_1, resolve, reject)
-                end
-            )
-            if success then
-                step(nil, resultOrError)
-            else
-                reject(nil, resultOrError)
-            end
-        end
-    )
-end
-local function __TS__Await(thing)
-    return coroutine.yield(thing)
+        )
+    end
+    function __TS__Await(thing)
+        return coyield(thing)
+    end
 end
 
 local function __TS__ClassExtends(target, base)
@@ -957,20 +919,17 @@ local function __TS__ObjectGetOwnPropertyDescriptor(object, key)
     return rawget(metatable, "_descriptors")[key]
 end
 
-local __TS__SetDescriptor
+local __TS__DescriptorGet
 do
-    local function descriptorIndex(self, key)
-        local value = rawget(self, key)
-        if value ~= nil then
-            return value
-        end
-        local metatable = getmetatable(self)
+    local getmetatable = _G.getmetatable
+    local ____rawget = _G.rawget
+    function __TS__DescriptorGet(self, metatable, key)
         while metatable do
-            local rawResult = rawget(metatable, key)
+            local rawResult = ____rawget(metatable, key)
             if rawResult ~= nil then
                 return rawResult
             end
-            local descriptors = rawget(metatable, "_descriptors")
+            local descriptors = ____rawget(metatable, "_descriptors")
             if descriptors then
                 local descriptor = descriptors[key]
                 if descriptor ~= nil then
@@ -983,10 +942,16 @@ do
             metatable = getmetatable(metatable)
         end
     end
-    local function descriptorNewIndex(self, key, value)
-        local metatable = getmetatable(self)
+end
+
+local __TS__DescriptorSet
+do
+    local getmetatable = _G.getmetatable
+    local ____rawget = _G.rawget
+    local rawset = _G.rawset
+    function __TS__DescriptorSet(self, metatable, key, value)
         while metatable do
-            local descriptors = rawget(metatable, "_descriptors")
+            local descriptors = ____rawget(metatable, "_descriptors")
             if descriptors then
                 local descriptor = descriptors[key]
                 if descriptor ~= nil then
@@ -1008,6 +973,26 @@ do
         end
         rawset(self, key, value)
     end
+end
+
+local __TS__SetDescriptor
+do
+    local getmetatable = _G.getmetatable
+    local function descriptorIndex(self, key)
+        return __TS__DescriptorGet(
+            self,
+            getmetatable(self),
+            key
+        )
+    end
+    local function descriptorNewIndex(self, key, value)
+        return __TS__DescriptorSet(
+            self,
+            getmetatable(self),
+            key,
+            value
+        )
+    end
     function __TS__SetDescriptor(target, key, desc, isPrototype)
         if isPrototype == nil then
             isPrototype = false
@@ -1239,6 +1224,18 @@ local function __TS__DelegatedYield(iterable)
     end
 end
 
+local function __TS__FunctionBind(fn, ...)
+    local boundArgs = arg
+    return function(____, ...)
+        local args = arg
+        __TS__ArrayUnshift(
+            args,
+            unpack(boundArgs)
+        )
+        return fn(unpack(args))
+    end
+end
+
 local function __TS__Unpack(list, i, j)
     if i == 1 and j == nil then
         return unpack(list)
@@ -2611,6 +2608,8 @@ return {
   __TS__DecorateParam = __TS__DecorateParam,
   __TS__Delete = __TS__Delete,
   __TS__DelegatedYield = __TS__DelegatedYield,
+  __TS__DescriptorGet = __TS__DescriptorGet,
+  __TS__DescriptorSet = __TS__DescriptorSet,
   Error = Error,
   RangeError = RangeError,
   ReferenceError = ReferenceError,

package/dist/lualib/5.0/lualib_module_info.json

@@ -204,7 +204,6 @@
       "__TS__Await"
     ],
     "dependencies": [
-      "InstanceOf",
       "Promise",
       "New"
     ]
@@ -271,6 +270,16 @@
       "Symbol"
     ]
   },
+  "DescriptorGet": {
+    "exports": [
+      "__TS__DescriptorGet"
+    ]
+  },
+  "DescriptorSet": {
+    "exports": [
+      "__TS__DescriptorSet"
+    ]
+  },
   "Error": {
     "exports": [
       "Error",
@@ -485,8 +494,7 @@
       "Promise",
       "New",
       "InstanceOf",
-      "Class",
-      "FunctionBind"
+      "Class"
     ]
   },
   "PromiseAll": {
@@ -548,7 +556,9 @@
       "__TS__SetDescriptor"
     ],
     "dependencies": [
-      "CloneDescriptor"
+      "CloneDescriptor",
+      "DescriptorGet",
+      "DescriptorSet"
     ]
   },
   "SparseArrayNew": {

package/dist/lualib/universal/Await.lua

@@ -1,48 +1,48 @@
-local function __TS__AsyncAwaiter(generator)
-    return __TS__New(
-        __TS__Promise,
-        function(____, resolve, reject)
-            local adopt, fulfilled, step, resolved, asyncCoroutine
-            function adopt(self, value)
-                return __TS__InstanceOf(value, __TS__Promise) and value or __TS__Promise.resolve(value)
-            end
-            function fulfilled(self, value)
-                local success, resultOrError = coroutine.resume(asyncCoroutine, value)
-                if success then
-                    step(nil, resultOrError)
-                else
-                    reject(nil, resultOrError)
+local __TS__AsyncAwaiter, __TS__Await
+do
+    local cocreate = coroutine.create
+    local coresume = coroutine.resume
+    local costatus = coroutine.status
+    local coyield = coroutine.yield
+    function __TS__AsyncAwaiter(generator)
+        return __TS__New(
+            __TS__Promise,
+            function(____, resolve, reject)
+                local fulfilled, step, resolved, asyncCoroutine
+                function fulfilled(self, value)
+                    local success, resultOrError = coresume(asyncCoroutine, value)
+                    if success then
+                        return step(resultOrError)
+                    end
+                    return reject(nil, resultOrError)
                 end
-            end
-            function step(self, result)
-                if resolved then
-                    return
+                function step(result)
+                    if resolved then
+                        return
+                    end
+                    if costatus(asyncCoroutine) == "dead" then
+                        return resolve(nil, result)
+                    end
+                    return __TS__Promise.resolve(result):addCallbacks(fulfilled, reject)
                 end
-                if coroutine.status(asyncCoroutine) == "dead" then
-                    resolve(nil, result)
+                resolved = false
+                asyncCoroutine = cocreate(generator)
+                local success, resultOrError = coresume(
+                    asyncCoroutine,
+                    function(____, v)
+                        resolved = true
+                        return __TS__Promise.resolve(v):addCallbacks(resolve, reject)
+                    end
+                )
+                if success then
+                    return step(resultOrError)
                 else
-                    local ____self_0 = adopt(nil, result)
-                    ____self_0["then"](____self_0, fulfilled, reject)
-                end
-            end
-            resolved = false
-            asyncCoroutine = coroutine.create(generator)
-            local success, resultOrError = coroutine.resume(
-                asyncCoroutine,
-                function(____, v)
-                    resolved = true
-                    local ____self_1 = adopt(nil, v)
-                    ____self_1["then"](____self_1, resolve, reject)
+                    return reject(nil, resultOrError)
                 end
-            )
-            if success then
-                step(nil, resultOrError)
-            else
-                reject(nil, resultOrError)
             end
-        end
-    )
-end
-local function __TS__Await(thing)
-    return coroutine.yield(thing)
+        )
+    end
+    function __TS__Await(thing)
+        return coyield(thing)
+    end
 end

package/dist/lualib/universal/DescriptorGet.lua

@@ -0,0 +1,24 @@
+local __TS__DescriptorGet
+do
+    local getmetatable = _G.getmetatable
+    local ____rawget = _G.rawget
+    function __TS__DescriptorGet(self, metatable, key)
+        while metatable do
+            local rawResult = ____rawget(metatable, key)
+            if rawResult ~= nil then
+                return rawResult
+            end
+            local descriptors = ____rawget(metatable, "_descriptors")
+            if descriptors then
+                local descriptor = descriptors[key]
+                if descriptor ~= nil then
+                    if descriptor.get then
+                        return descriptor.get(self)
+                    end
+                    return descriptor.value
+                end
+            end
+            metatable = getmetatable(metatable)
+        end
+    end
+end