typescript-to-lua 0.42.0 → 1.1.1

package/dist/lualib/Promise.lua

@@ -0,0 +1,172 @@
+__TS__PromiseState = __TS__PromiseState or ({})
+__TS__PromiseState.Pending = 0
+__TS__PromiseState[__TS__PromiseState.Pending] = "Pending"
+__TS__PromiseState.Fulfilled = 1
+__TS__PromiseState[__TS__PromiseState.Fulfilled] = "Fulfilled"
+__TS__PromiseState.Rejected = 2
+__TS__PromiseState[__TS__PromiseState.Rejected] = "Rejected"
+function __TS__PromiseDeferred(self)
+    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}
+end
+function __TS__IsPromiseLike(self, thing)
+    return __TS__InstanceOf(thing, __TS__Promise)
+end
+__TS__Promise = __TS__Class()
+__TS__Promise.name = "__TS__Promise"
+function __TS__Promise.prototype.____constructor(self, executor)
+    self.state = __TS__PromiseState.Pending
+    self.fulfilledCallbacks = {}
+    self.rejectedCallbacks = {}
+    self.finallyCallbacks = {}
+    do
+        local function ____catch(e)
+            self:reject(e)
+        end
+        local ____try, ____hasReturned = pcall(
+            function()
+                executor(
+                    _G,
+                    __TS__FunctionBind(self.resolve, self),
+                    __TS__FunctionBind(self.reject, self)
+                )
+            end
+        )
+        if not ____try then
+            ____hasReturned, ____returnValue = ____catch(____hasReturned)
+        end
+    end
+end
+function __TS__Promise.resolve(data)
+    local promise = __TS__New(
+        __TS__Promise,
+        function()
+        end
+    )
+    promise.state = __TS__PromiseState.Fulfilled
+    promise.value = data
+    return promise
+end
+function __TS__Promise.reject(reason)
+    local promise = __TS__New(
+        __TS__Promise,
+        function()
+        end
+    )
+    promise.state = __TS__PromiseState.Rejected
+    promise.rejectionReason = reason
+    return promise
+end
+__TS__Promise.prototype["then"] = function(self, onFulfilled, onRejected)
+    local ____ = __TS__PromiseDeferred(_G)
+    local promise = ____.promise
+    local resolve = ____.resolve
+    local reject = ____.reject
+    local isFulfilled = self.state == __TS__PromiseState.Fulfilled
+    local isRejected = self.state == __TS__PromiseState.Rejected
+    if onFulfilled then
+        local internalCallback = self:createPromiseResolvingCallback(onFulfilled, resolve, reject)
+        __TS__ArrayPush(self.fulfilledCallbacks, internalCallback)
+        if isFulfilled then
+            internalCallback(_G, self.value)
+        end
+    else
+        __TS__ArrayPush(
+            self.fulfilledCallbacks,
+            function() return resolve(_G, nil) end
+        )
+    end
+    if onRejected then
+        local internalCallback = self:createPromiseResolvingCallback(onRejected, resolve, reject)
+        __TS__ArrayPush(self.rejectedCallbacks, internalCallback)
+        if isRejected then
+            internalCallback(_G, self.rejectionReason)
+        end
+    end
+    if isFulfilled then
+        resolve(_G, self.value)
+    end
+    if isRejected then
+        reject(_G, self.rejectionReason)
+    end
+    return promise
+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
+        __TS__ArrayPush(self.finallyCallbacks, onFinally)
+        if self.state ~= __TS__PromiseState.Pending then
+            onFinally(_G)
+        end
+    end
+    return self
+end
+function __TS__Promise.prototype.resolve(self, data)
+    if self.state == __TS__PromiseState.Pending then
+        self.state = __TS__PromiseState.Fulfilled
+        self.value = data
+        for ____, callback in ipairs(self.fulfilledCallbacks) do
+            callback(_G, data)
+        end
+        for ____, callback in ipairs(self.finallyCallbacks) do
+            callback(_G)
+        end
+    end
+end
+function __TS__Promise.prototype.reject(self, reason)
+    if self.state == __TS__PromiseState.Pending then
+        self.state = __TS__PromiseState.Rejected
+        self.rejectionReason = reason
+        for ____, callback in ipairs(self.rejectedCallbacks) do
+            callback(_G, reason)
+        end
+        for ____, callback in ipairs(self.finallyCallbacks) do
+            callback(_G)
+        end
+    end
+end
+function __TS__Promise.prototype.createPromiseResolvingCallback(self, f, resolve, reject)
+    return function(____, value)
+        do
+            local function ____catch(e)
+                reject(_G, e)
+            end
+            local ____try, ____hasReturned = pcall(
+                function()
+                    self:handleCallbackData(
+                        f(_G, value),
+                        resolve,
+                        reject
+                    )
+                end
+            )
+            if not ____try then
+                ____hasReturned, ____returnValue = ____catch(____hasReturned)
+            end
+        end
+    end
+end
+function __TS__Promise.prototype.handleCallbackData(self, data, resolve, reject)
+    if __TS__IsPromiseLike(_G, data) then
+        local nextpromise = data
+        if nextpromise.state == __TS__PromiseState.Fulfilled then
+            resolve(_G, nextpromise.value)
+        elseif nextpromise.state == __TS__PromiseState.Rejected then
+            reject(_G, nextpromise.rejectionReason)
+        else
+            data["then"](data, resolve, reject)
+        end
+    else
+        resolve(_G, data)
+    end
+end

package/dist/lualib/PromiseAll.lua

@@ -0,0 +1,44 @@
+function __TS__PromiseAll(iterable)
+    local results = {}
+    local toResolve = {}
+    local numToResolve = 0
+    local i = 0
+    for ____, item in __TS__Iterator(iterable) do
+        if __TS__InstanceOf(item, __TS__Promise) then
+            if item.state == __TS__PromiseState.Fulfilled then
+                results[i + 1] = item.value
+            elseif item.state == __TS__PromiseState.Rejected then
+                return __TS__Promise.reject(item.rejectionReason)
+            else
+                numToResolve = numToResolve + 1
+                toResolve[i] = item
+            end
+        else
+            results[i + 1] = item
+        end
+        i = i + 1
+    end
+    if numToResolve == 0 then
+        return __TS__Promise.resolve(results)
+    end
+    return __TS__New(
+        __TS__Promise,
+        function(____, resolve, reject)
+            for index, promise in pairs(toResolve) do
+                promise["then"](
+                    promise,
+                    function(____, data)
+                        results[index + 1] = data
+                        numToResolve = numToResolve - 1
+                        if numToResolve == 0 then
+                            resolve(_G, results)
+                        end
+                    end,
+                    function(____, reason)
+                        reject(_G, reason)
+                    end
+                )
+            end
+        end
+    )
+end

package/dist/lualib/PromiseAllSettled.lua

@@ -0,0 +1,48 @@
+function __TS__PromiseAllSettled(iterable)
+    local results = {}
+    local toResolve = {}
+    local numToResolve = 0
+    local i = 0
+    for ____, item in __TS__Iterator(iterable) do
+        if __TS__InstanceOf(item, __TS__Promise) then
+            if item.state == __TS__PromiseState.Fulfilled then
+                results[i + 1] = {status = "fulfilled", value = item.value}
+            elseif item.state == __TS__PromiseState.Rejected then
+                results[i + 1] = {status = "rejected", reason = item.rejectionReason}
+            else
+                numToResolve = numToResolve + 1
+                toResolve[i] = item
+            end
+        else
+            results[i + 1] = {status = "fulfilled", value = item}
+        end
+        i = i + 1
+    end
+    if numToResolve == 0 then
+        return __TS__Promise.resolve(results)
+    end
+    return __TS__New(
+        __TS__Promise,
+        function(____, resolve)
+            for index, promise in pairs(toResolve) do
+                promise["then"](
+                    promise,
+                    function(____, data)
+                        results[index + 1] = {status = "fulfilled", value = data}
+                        numToResolve = numToResolve - 1
+                        if numToResolve == 0 then
+                            resolve(_G, results)
+                        end
+                    end,
+                    function(____, reason)
+                        results[index + 1] = {status = "rejected", reason = reason}
+                        numToResolve = numToResolve - 1
+                        if numToResolve == 0 then
+                            resolve(_G, results)
+                        end
+                    end
+                )
+            end
+        end
+    )
+end

package/dist/lualib/PromiseAny.lua

@@ -0,0 +1,41 @@
+function __TS__PromiseAny(iterable)
+    local rejections = {}
+    local pending = {}
+    for ____, item in __TS__Iterator(iterable) do
+        if __TS__InstanceOf(item, __TS__Promise) then
+            if item.state == __TS__PromiseState.Fulfilled then
+                return __TS__Promise.resolve(item.value)
+            elseif item.state == __TS__PromiseState.Rejected then
+                __TS__ArrayPush(rejections, item.rejectionReason)
+            else
+                __TS__ArrayPush(pending, item)
+            end
+        else
+            return __TS__Promise.resolve(item)
+        end
+    end
+    if #pending == 0 then
+        return __TS__Promise.reject("No promises to resolve with .any()")
+    end
+    local numResolved = 0
+    return __TS__New(
+        __TS__Promise,
+        function(____, resolve, reject)
+            for ____, promise in ipairs(pending) do
+                promise["then"](
+                    promise,
+                    function(____, data)
+                        resolve(_G, data)
+                    end,
+                    function(____, reason)
+                        __TS__ArrayPush(rejections, reason)
+                        numResolved = numResolved + 1
+                        if numResolved == #pending then
+                            reject(_G, {name = "AggregateError", message = "All Promises rejected", errors = rejections})
+                        end
+                    end
+                )
+            end
+        end
+    )
+end

package/dist/lualib/PromiseRace.lua

@@ -0,0 +1,28 @@
+function __TS__PromiseRace(iterable)
+    local pending = {}
+    for ____, item in __TS__Iterator(iterable) do
+        if __TS__InstanceOf(item, __TS__Promise) then
+            if item.state == __TS__PromiseState.Fulfilled then
+                return __TS__Promise.resolve(item.value)
+            elseif item.state == __TS__PromiseState.Rejected then
+                return __TS__Promise.reject(item.rejectionReason)
+            else
+                __TS__ArrayPush(pending, item)
+            end
+        else
+            return __TS__Promise.resolve(item)
+        end
+    end
+    return __TS__New(
+        __TS__Promise,
+        function(____, resolve, reject)
+            for ____, promise in ipairs(pending) do
+                promise["then"](
+                    promise,
+                    function(____, value) return resolve(_G, value) end,
+                    function(____, reason) return reject(_G, reason) end
+                )
+            end
+        end
+    )
+end

package/dist/lualib/SourceMapTraceBack.lua

@@ -6,23 +6,33 @@ function __TS__SourceMapTraceBack(fileName, sourceMap)
         debug.traceback = function(thread, message, level)
             local trace
             if ((thread == nil) and (message == nil)) and (level == nil) then
-                trace = _G:__TS__originalTraceback()
+                trace = _G.__TS__originalTraceback()
             else
-                trace = _G:__TS__originalTraceback(thread, message, level)
+                trace = _G.__TS__originalTraceback(thread, message, level)
             end
             if type(trace) ~= "string" then
                 return trace
             end
-            local result = string.gsub(
-                trace,
-                "(%S+).lua:(%d+)",
-                function(file, line)
-                    local fileSourceMap = _G.__TS__sourcemap[file .. ".lua"]
-                    if fileSourceMap and fileSourceMap[line] then
-                        return (file .. ".ts:") .. tostring(fileSourceMap[line])
+            local function replacer(____, file, srcFile, line)
+                local fileSourceMap = _G.__TS__sourcemap[file]
+                if fileSourceMap and fileSourceMap[line] then
+                    local data = fileSourceMap[line]
+                    if type(data) == "number" then
+                        return (srcFile .. ":") .. tostring(data)
                     end
-                    return (file .. ".lua:") .. line
+                    return (tostring(data.file) .. ":") .. tostring(data.line)
                 end
+                return (file .. ":") .. line
+            end
+            local result = string.gsub(
+                trace,
+                "(%S+)%.lua:(%d+)",
+                function(file, line) return replacer(_G, file .. ".lua", file .. ".ts", line) end
+            )
+            result = string.gsub(
+                result,
+                "(%[string \"[^\"]+\"%]):(%d+)",
+                function(file, line) return replacer(_G, file, "unknown", line) end
             )
             return result
         end

package/dist/lualib/StringReplace.lua

@@ -1,16 +1,11 @@
 function __TS__StringReplace(source, searchValue, replaceValue)
-    searchValue = string.gsub(searchValue, "[%%%(%)%.%+%-%*%?%[%^%$]", "%%%1")
-    if type(replaceValue) == "string" then
-        replaceValue = string.gsub(replaceValue, "%%", "%%%%")
-        local result = string.gsub(source, searchValue, replaceValue, 1)
-        return result
-    else
-        local result = string.gsub(
-            source,
-            searchValue,
-            function(match) return replaceValue(_G, match) end,
-            1
-        )
-        return result
+    local startPos, endPos = string.find(source, searchValue, nil, true)
+    if not startPos then
+        return source
     end
+    local sub = string.sub
+    local before = sub(source, 1, startPos - 1)
+    local replacement = (((type(replaceValue) == "string") and (function() return replaceValue end)) or (function() return replaceValue(_G, searchValue, startPos - 1, source) end))()
+    local after = sub(source, endPos + 1)
+    return (before .. replacement) .. after
 end

package/dist/lualib/StringReplaceAll.lua

@@ -0,0 +1,35 @@
+function __TS__StringReplaceAll(source, searchValue, replaceValue)
+    local replacer
+    if type(replaceValue) == "string" then
+        replacer = function() return replaceValue end
+    else
+        replacer = replaceValue
+    end
+    local parts = {}
+    local partsIndex = 1
+    local sub = string.sub
+    if #searchValue == 0 then
+        parts[1] = replacer(_G, "", 0, source)
+        partsIndex = 2
+        for i = 1, #source do
+            parts[partsIndex] = sub(source, i, i)
+            parts[partsIndex + 1] = replacer(_G, "", i, source)
+            partsIndex = partsIndex + 2
+        end
+    else
+        local find = string.find
+        local currentPos = 1
+        while true do
+            local startPos, endPos = find(source, searchValue, currentPos, true)
+            if not startPos then
+                break
+            end
+            parts[partsIndex] = sub(source, currentPos, startPos - 1)
+            parts[partsIndex + 1] = replacer(_G, searchValue, startPos - 1, source)
+            partsIndex = partsIndex + 2
+            currentPos = endPos + 1
+        end
+        parts[partsIndex] = sub(source, currentPos)
+    end
+    return table.concat(parts)
+end