typescript-to-lua 1.23.0 → 1.24.0

package/dist/lualib/universal/DescriptorSet.lua

@@ -0,0 +1,30 @@
+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")
+            if descriptors then
+                local descriptor = descriptors[key]
+                if descriptor ~= nil then
+                    if descriptor.set then
+                        descriptor.set(self, value)
+                    else
+                        if descriptor.writable == false then
+                            error(
+                                ((("Cannot assign to read only property '" .. key) .. "' of object '") .. tostring(self)) .. "'",
+                                0
+                            )
+                        end
+                        descriptor.value = value
+                    end
+                    return
+                end
+            end
+            metatable = getmetatable(metatable)
+        end
+        rawset(self, key, value)
+    end
+end

package/dist/lualib/universal/Promise.lua

@@ -1,20 +1,24 @@
 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 function isPromiseLike(self, thing)
-        return __TS__InstanceOf(thing, __TS__Promise)
+    local makeDeferredPromise = makeDeferredPromiseFactory()
+    local function isPromiseLike(value)
+        return __TS__InstanceOf(value, __TS__Promise)
     end
+    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)
@@ -22,155 +26,125 @@ 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[#____self_fulfilledCallbacks_1 + 1] = internalCallback
-            if isFulfilled then
-                internalCallback(nil, self.value)
-            end
-        else
-            local ____self_fulfilledCallbacks_2 = self.fulfilledCallbacks
-            ____self_fulfilledCallbacks_2[#____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[#____self_rejectedCallbacks_3 + 1] = internalCallback
-            if isRejected then
-                internalCallback(nil, self.rejectionReason)
-            end
-        else
-            local ____self_rejectedCallbacks_4 = self.rejectedCallbacks
-            ____self_rejectedCallbacks_4[#____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[#____self_fulfilledCallbacks_0 + 1] = fulfilledCallback
+        local ____self_rejectedCallbacks_1 = self.rejectedCallbacks
+        ____self_rejectedCallbacks_1[#____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[#____self_finallyCallbacks_5 + 1] = onFinally
+            local ____self_finallyCallbacks_2 = self.finallyCallbacks
+            ____self_finallyCallbacks_2[#____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 = #callbacks
+        local finallyCallbacks = self.finallyCallbacks
+        local finallyCallbacksLength = #finallyCallbacks
+        if callbacksLength ~= 0 then
+            for i = 1, callbacksLength - 1 do
+                callbacks[i](callbacks, value)
+            end
+            if finallyCallbacksLength == 0 then
+                return callbacks[callbacksLength](callbacks, value)
             end
-            for ____, callback in ipairs(self.finallyCallbacks) do
-                callback(nil)
+            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

package/dist/lualib/universal/SetDescriptor.lua

@@ -1,53 +1,20 @@
 local __TS__SetDescriptor
 do
+    local getmetatable = _G.getmetatable
     local function descriptorIndex(self, key)
-        local value = rawget(self, key)
-        if value ~= nil then
-            return value
-        end
-        local metatable = getmetatable(self)
-        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
+        return __TS__DescriptorGet(
+            self,
+            getmetatable(self),
+            key
+        )
     end
     local function descriptorNewIndex(self, key, value)
-        local metatable = getmetatable(self)
-        while metatable do
-            local descriptors = rawget(metatable, "_descriptors")
-            if descriptors then
-                local descriptor = descriptors[key]
-                if descriptor ~= nil then
-                    if descriptor.set then
-                        descriptor.set(self, value)
-                    else
-                        if descriptor.writable == false then
-                            error(
-                                ((("Cannot assign to read only property '" .. key) .. "' of object '") .. tostring(self)) .. "'",
-                                0
-                            )
-                        end
-                        descriptor.value = value
-                    end
-                    return
-                end
-            end
-            metatable = getmetatable(metatable)
-        end
-        rawset(self, key, value)
+        return __TS__DescriptorSet(
+            self,
+            getmetatable(self),
+            key,
+            value
+        )
     end
     function __TS__SetDescriptor(target, key, desc, isPrototype)
         if isPrototype == nil then