typescript-to-lua 0.42.0 → 1.1.1

package/dist/lualib/lualib_bundle.lua

@@ -454,6 +454,106 @@ function __TS__ArraySetLength(arr, length)
     return length
 end
 
+____symbolMetatable = {
+    __tostring = function(self)
+        return ("Symbol(" .. (self.description or "")) .. ")"
+    end
+}
+function __TS__Symbol(description)
+    return setmetatable({description = description}, ____symbolMetatable)
+end
+Symbol = {
+    iterator = __TS__Symbol("Symbol.iterator"),
+    hasInstance = __TS__Symbol("Symbol.hasInstance"),
+    species = __TS__Symbol("Symbol.species"),
+    toStringTag = __TS__Symbol("Symbol.toStringTag")
+}
+
+function __TS__InstanceOf(obj, classTbl)
+    if type(classTbl) ~= "table" then
+        error("Right-hand side of 'instanceof' is not an object", 0)
+    end
+    if classTbl[Symbol.hasInstance] ~= nil then
+        return not (not classTbl[Symbol.hasInstance](classTbl, obj))
+    end
+    if type(obj) == "table" then
+        local luaClass = obj.constructor
+        while luaClass ~= nil do
+            if luaClass == classTbl then
+                return true
+            end
+            luaClass = luaClass.____super
+        end
+    end
+    return false
+end
+
+function __TS__New(target, ...)
+    local instance = setmetatable({}, target.prototype)
+    instance:____constructor(...)
+    return instance
+end
+
+function __TS__AsyncAwaiter(generator)
+    return __TS__New(
+        __TS__Promise,
+        function(____, resolve, reject)
+            local adopt, fulfilled, rejected, step, asyncCoroutine
+            function adopt(self, value)
+                return ((__TS__InstanceOf(value, __TS__Promise) and (function() return value end)) or (function() return __TS__Promise.resolve(value) end))()
+            end
+            function fulfilled(self, value)
+                local success, errorOrErrorHandler, resultOrError = coroutine.resume(asyncCoroutine, value)
+                if success then
+                    step(_G, resultOrError, errorOrErrorHandler)
+                else
+                    reject(_G, resultOrError)
+                end
+            end
+            function rejected(self, handler)
+                if handler then
+                    return function(____, value)
+                        local success, valueOrError = pcall(handler, value)
+                        if success then
+                            step(_G, valueOrError, handler)
+                        else
+                            reject(_G, valueOrError)
+                        end
+                    end
+                else
+                    return function(____, value)
+                        reject(_G, value)
+                    end
+                end
+            end
+            function step(self, result, errorHandler)
+                if coroutine.status(asyncCoroutine) == "dead" then
+                    resolve(_G, result)
+                else
+                    (function()
+                        local ____self = adopt(_G, result)
+                        return ____self["then"](
+                            ____self,
+                            fulfilled,
+                            rejected(_G, errorHandler)
+                        )
+                    end)()
+                end
+            end
+            asyncCoroutine = coroutine.create(generator)
+            local success, errorOrErrorHandler, resultOrError = coroutine.resume(asyncCoroutine)
+            if success then
+                step(_G, resultOrError, errorOrErrorHandler)
+            else
+                reject(_G, errorOrErrorHandler)
+            end
+        end
+    )
+end
+function __TS__Await(errorHandler, thing)
+    return coroutine.yield(errorHandler, thing)
+end
+
 function __TS__Class(self)
     local c = {prototype = {}}
     c.prototype.__index = c.prototype
@@ -722,12 +822,6 @@ function __TS__DelegatedYield(iterable)
     end
 end
 
-function __TS__New(target, ...)
-    local instance = setmetatable({}, target.prototype)
-    instance:____constructor(...)
-    return instance
-end
-
 function __TS__GetErrorStack(self, constructor)
     local level = 1
     while true do
@@ -824,21 +918,6 @@ function __TS__FunctionBind(fn, thisArg, ...)
     end
 end
 
-____symbolMetatable = {
-    __tostring = function(self)
-        return ("Symbol(" .. (self.description or "")) .. ")"
-    end
-}
-function __TS__Symbol(description)
-    return setmetatable({description = description}, ____symbolMetatable)
-end
-Symbol = {
-    iterator = __TS__Symbol("Symbol.iterator"),
-    hasInstance = __TS__Symbol("Symbol.hasInstance"),
-    species = __TS__Symbol("Symbol.species"),
-    toStringTag = __TS__Symbol("Symbol.toStringTag")
-}
-
 function __TS__GeneratorIterator(self)
     return self
 end
@@ -872,25 +951,6 @@ function __TS__Generator(fn)
     end
 end
 
-function __TS__InstanceOf(obj, classTbl)
-    if type(classTbl) ~= "table" then
-        error("Right-hand side of 'instanceof' is not an object", 0)
-    end
-    if classTbl[Symbol.hasInstance] ~= nil then
-        return not (not classTbl[Symbol.hasInstance](classTbl, obj))
-    end
-    if type(obj) == "table" then
-        local luaClass = obj.constructor
-        while luaClass ~= nil do
-            if luaClass == classTbl then
-                return true
-            end
-            luaClass = luaClass.____super
-        end
-    end
-    return false
-end
-
 function __TS__InstanceOfObject(value)
     local valueType = type(value)
     return (valueType == "table") or (valueType == "function")
@@ -1257,11 +1317,13 @@ function __TS__OptionalFunctionCall(f, ...)
     return nil
 end
 
-function __TS__OptionalMethodCall(____table, methodName, ...)
+function __TS__OptionalMethodCall(____table, methodName, isMethodOptional, ...)
     if ____table then
         local method = ____table[methodName]
         if method then
             return method(____table, ...)
+        elseif not isMethodOptional then
+            error(methodName .. " is not a function", 0)
         end
     end
     return nil
@@ -1341,6 +1403,344 @@ function __TS__ParseInt(numberString, base)
     end
 end
 
+__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
+
+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
+
+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
+
+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
+
+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
+
 Set = (function()
     local Set = __TS__Class()
     Set.name = "Set"
@@ -1570,23 +1970,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
@@ -1712,20 +2122,51 @@ function __TS__StringPadStart(self, maxLength, fillString)
 end
 
 function __TS__StringReplace(source, searchValue, replaceValue)
-    searchValue = string.gsub(searchValue, "[%%%(%)%.%+%-%*%?%[%^%$]", "%%%1")
+    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
+
+function __TS__StringReplaceAll(source, searchValue, replaceValue)
+    local replacer
     if type(replaceValue) == "string" then
-        replaceValue = string.gsub(replaceValue, "%%", "%%%%")
-        local result = string.gsub(source, searchValue, replaceValue, 1)
-        return result
+        replacer = function() return replaceValue end
     else
-        local result = string.gsub(
-            source,
-            searchValue,
-            function(match) return replaceValue(_G, match) end,
-            1
-        )
-        return result
+        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
 
 function __TS__StringSlice(self, start, ____end)