typescript-to-lua 1.17.0 → 1.19.0

package/dist/LuaLib.d.ts

@@ -29,6 +29,10 @@ export declare enum LuaLibFeature {
     ArrayFlat = "ArrayFlat",
     ArrayFlatMap = "ArrayFlatMap",
     ArraySetLength = "ArraySetLength",
+    ArrayToReversed = "ArrayToReversed",
+    ArrayToSorted = "ArrayToSorted",
+    ArrayToSpliced = "ArrayToSpliced",
+    ArrayWith = "ArrayWith",
     Await = "Await",
     Class = "Class",
     ClassExtends = "ClassExtends",
@@ -102,7 +106,9 @@ export declare enum LuaLibFeature {
     Symbol = "Symbol",
     SymbolRegistry = "SymbolRegistry",
     TypeOf = "TypeOf",
-    Unpack = "Unpack"
+    Unpack = "Unpack",
+    Using = "Using",
+    UsingAsync = "UsingAsync"
 }
 export interface LuaLibFeatureInfo {
     dependencies?: LuaLibFeature[];

package/dist/LuaLib.js

@@ -34,6 +34,10 @@ var LuaLibFeature;
     LuaLibFeature["ArrayFlat"] = "ArrayFlat";
     LuaLibFeature["ArrayFlatMap"] = "ArrayFlatMap";
     LuaLibFeature["ArraySetLength"] = "ArraySetLength";
+    LuaLibFeature["ArrayToReversed"] = "ArrayToReversed";
+    LuaLibFeature["ArrayToSorted"] = "ArrayToSorted";
+    LuaLibFeature["ArrayToSpliced"] = "ArrayToSpliced";
+    LuaLibFeature["ArrayWith"] = "ArrayWith";
     LuaLibFeature["Await"] = "Await";
     LuaLibFeature["Class"] = "Class";
     LuaLibFeature["ClassExtends"] = "ClassExtends";
@@ -108,6 +112,8 @@ var LuaLibFeature;
     LuaLibFeature["SymbolRegistry"] = "SymbolRegistry";
     LuaLibFeature["TypeOf"] = "TypeOf";
     LuaLibFeature["Unpack"] = "Unpack";
+    LuaLibFeature["Using"] = "Using";
+    LuaLibFeature["UsingAsync"] = "UsingAsync";
 })(LuaLibFeature || (exports.LuaLibFeature = LuaLibFeature = {}));
 function resolveLuaLibDir(luaTarget) {
     const luaLibDir = luaTarget === CompilerOptions_1.LuaTarget.Lua50 ? "5.0" : "universal";

package/dist/lualib/5.0/ArrayToReversed.lua

@@ -0,0 +1,5 @@
+local function __TS__ArrayToReversed(self)
+    local copy = {unpack(self)}
+    __TS__ArrayReverse(copy)
+    return copy
+end

package/dist/lualib/5.0/ArrayToSorted.lua

@@ -0,0 +1,5 @@
+local function __TS__ArrayToSorted(self, compareFn)
+    local copy = {unpack(self)}
+    __TS__ArraySort(copy, compareFn)
+    return copy
+end

package/dist/lualib/5.0/ArrayToSpliced.lua

@@ -0,0 +1,10 @@
+local function __TS__ArrayToSpliced(self, start, deleteCount, ...)
+    local copy = {unpack(self)}
+    __TS__ArraySplice(
+        copy,
+        start,
+        deleteCount,
+        unpack(arg)
+    )
+    return copy
+end

package/dist/lualib/5.0/ArrayWith.lua

@@ -0,0 +1,5 @@
+local function __TS__ArrayWith(self, index, value)
+    local copy = {unpack(self)}
+    copy[index + 1] = value
+    return copy
+end

package/dist/lualib/5.0/Symbol.lua

@@ -7,6 +7,8 @@ do
         return setmetatable({description = description}, symbolMetatable)
     end
     Symbol = {
+        asyncDispose = __TS__Symbol("Symbol.asyncDispose"),
+        dispose = __TS__Symbol("Symbol.dispose"),
         iterator = __TS__Symbol("Symbol.iterator"),
         hasInstance = __TS__Symbol("Symbol.hasInstance"),
         species = __TS__Symbol("Symbol.species"),

package/dist/lualib/5.0/Using.lua

@@ -0,0 +1,27 @@
+local function __TS__Using(self, cb, ...)
+    local args = arg
+    local thrownError
+    local ok, result = xpcall(
+        function() return cb(
+            nil,
+            unpack(args)
+        ) end,
+        function(err)
+            thrownError = err
+            return thrownError
+        end
+    )
+    local argArray = {unpack(args)}
+    do
+        local i = table.getn(argArray) - 1
+        while i >= 0 do
+            local ____self_0 = argArray[i + 1]
+            ____self_0[Symbol.dispose](____self_0)
+            i = i - 1
+        end
+    end
+    if not ok then
+        error(thrownError, 0)
+    end
+    return result
+end

package/dist/lualib/5.0/UsingAsync.lua

@@ -0,0 +1,35 @@
+local function __TS__UsingAsync(self, cb, ...)
+    local args = arg
+    return __TS__AsyncAwaiter(function(____awaiter_resolve)
+        local thrownError
+        local ok, result = xpcall(
+            function() return cb(
+                nil,
+                unpack(args)
+            ) end,
+            function(err)
+                thrownError = err
+                return thrownError
+            end
+        )
+        local argArray = {unpack(args)}
+        do
+            local i = table.getn(argArray) - 1
+            while i >= 0 do
+                if argArray[i + 1][Symbol.dispose] ~= nil then
+                    local ____self_0 = argArray[i + 1]
+                    ____self_0[Symbol.dispose](____self_0)
+                end
+                if argArray[i + 1][Symbol.asyncDispose] ~= nil then
+                    local ____self_1 = argArray[i + 1]
+                    __TS__Await(____self_1[Symbol.asyncDispose](____self_1))
+                end
+                i = i - 1
+            end
+        end
+        if not ok then
+            error(thrownError, 0)
+        end
+        return ____awaiter_resolve(nil, result)
+    end)
+end

package/dist/lualib/5.0/lualib_bundle.lua

@@ -34,6 +34,8 @@ do
         return setmetatable({description = description}, symbolMetatable)
     end
     Symbol = {
+        asyncDispose = __TS__Symbol("Symbol.asyncDispose"),
+        dispose = __TS__Symbol("Symbol.dispose"),
         iterator = __TS__Symbol("Symbol.iterator"),
         hasInstance = __TS__Symbol("Symbol.hasInstance"),
         species = __TS__Symbol("Symbol.species"),
@@ -534,6 +536,35 @@ local function __TS__ArraySetLength(self, length)
     return length
 end
 
+local function __TS__ArrayToReversed(self)
+    local copy = {unpack(self)}
+    __TS__ArrayReverse(copy)
+    return copy
+end
+
+local function __TS__ArrayToSorted(self, compareFn)
+    local copy = {unpack(self)}
+    __TS__ArraySort(copy, compareFn)
+    return copy
+end
+
+local function __TS__ArrayToSpliced(self, start, deleteCount, ...)
+    local copy = {unpack(self)}
+    __TS__ArraySplice(
+        copy,
+        start,
+        deleteCount,
+        unpack(arg)
+    )
+    return copy
+end
+
+local function __TS__ArrayWith(self, index, value)
+    local copy = {unpack(self)}
+    copy[index + 1] = value
+    return copy
+end
+
 local function __TS__InstanceOf(obj, classTbl)
     if type(classTbl) ~= "table" then
         error("Right-hand side of 'instanceof' is not an object", 0)
@@ -2437,6 +2468,70 @@ local function __TS__TypeOf(value)
     end
 end
 
+local function __TS__Using(self, cb, ...)
+    local args = arg
+    local thrownError
+    local ok, result = xpcall(
+        function() return cb(
+            nil,
+            unpack(args)
+        ) end,
+        function(err)
+            thrownError = err
+            return thrownError
+        end
+    )
+    local argArray = {unpack(args)}
+    do
+        local i = table.getn(argArray) - 1
+        while i >= 0 do
+            local ____self_0 = argArray[i + 1]
+            ____self_0[Symbol.dispose](____self_0)
+            i = i - 1
+        end
+    end
+    if not ok then
+        error(thrownError, 0)
+    end
+    return result
+end
+
+local function __TS__UsingAsync(self, cb, ...)
+    local args = arg
+    return __TS__AsyncAwaiter(function(____awaiter_resolve)
+        local thrownError
+        local ok, result = xpcall(
+            function() return cb(
+                nil,
+                unpack(args)
+            ) end,
+            function(err)
+                thrownError = err
+                return thrownError
+            end
+        )
+        local argArray = {unpack(args)}
+        do
+            local i = table.getn(argArray) - 1
+            while i >= 0 do
+                if argArray[i + 1][Symbol.dispose] ~= nil then
+                    local ____self_0 = argArray[i + 1]
+                    ____self_0[Symbol.dispose](____self_0)
+                end
+                if argArray[i + 1][Symbol.asyncDispose] ~= nil then
+                    local ____self_1 = argArray[i + 1]
+                    __TS__Await(____self_1[Symbol.asyncDispose](____self_1))
+                end
+                i = i - 1
+            end
+        end
+        if not ok then
+            error(thrownError, 0)
+        end
+        return ____awaiter_resolve(nil, result)
+    end)
+end
+
 return {
   __TS__ArrayConcat = __TS__ArrayConcat,
   __TS__ArrayEntries = __TS__ArrayEntries,
@@ -2465,6 +2560,10 @@ return {
   __TS__ArrayFlat = __TS__ArrayFlat,
   __TS__ArrayFlatMap = __TS__ArrayFlatMap,
   __TS__ArraySetLength = __TS__ArraySetLength,
+  __TS__ArrayToReversed = __TS__ArrayToReversed,
+  __TS__ArrayToSorted = __TS__ArrayToSorted,
+  __TS__ArrayToSpliced = __TS__ArrayToSpliced,
+  __TS__ArrayWith = __TS__ArrayWith,
   __TS__AsyncAwaiter = __TS__AsyncAwaiter,
   __TS__Await = __TS__Await,
   __TS__Class = __TS__Class,
@@ -2546,5 +2645,7 @@ return {
   __TS__SymbolRegistryFor = __TS__SymbolRegistryFor,
   __TS__SymbolRegistryKeyFor = __TS__SymbolRegistryKeyFor,
   __TS__TypeOf = __TS__TypeOf,
-  __TS__Unpack = __TS__Unpack
+  __TS__Unpack = __TS__Unpack,
+  __TS__Using = __TS__Using,
+  __TS__UsingAsync = __TS__UsingAsync
 }

package/dist/lualib/5.0/lualib_module_info.json

@@ -159,6 +159,35 @@
       "__TS__ArraySetLength"
     ]
   },
+  "ArrayToReversed": {
+    "exports": [
+      "__TS__ArrayToReversed"
+    ],
+    "dependencies": [
+      "ArrayReverse"
+    ]
+  },
+  "ArrayToSorted": {
+    "exports": [
+      "__TS__ArrayToSorted"
+    ],
+    "dependencies": [
+      "ArraySort"
+    ]
+  },
+  "ArrayToSpliced": {
+    "exports": [
+      "__TS__ArrayToSpliced"
+    ],
+    "dependencies": [
+      "ArraySplice"
+    ]
+  },
+  "ArrayWith": {
+    "exports": [
+      "__TS__ArrayWith"
+    ]
+  },
   "Await": {
     "exports": [
       "__TS__AsyncAwaiter",
@@ -676,5 +705,22 @@
     "exports": [
       "__TS__Unpack"
     ]
+  },
+  "Using": {
+    "exports": [
+      "__TS__Using"
+    ],
+    "dependencies": [
+      "Symbol"
+    ]
+  },
+  "UsingAsync": {
+    "exports": [
+      "__TS__UsingAsync"
+    ],
+    "dependencies": [
+      "Symbol",
+      "Await"
+    ]
   }
 }

package/dist/lualib/universal/ArrayToReversed.lua

@@ -0,0 +1,5 @@
+local function __TS__ArrayToReversed(self)
+    local copy = {__TS__Unpack(self)}
+    __TS__ArrayReverse(copy)
+    return copy
+end

package/dist/lualib/universal/ArrayToSorted.lua

@@ -0,0 +1,5 @@
+local function __TS__ArrayToSorted(self, compareFn)
+    local copy = {__TS__Unpack(self)}
+    __TS__ArraySort(copy, compareFn)
+    return copy
+end

package/dist/lualib/universal/ArrayToSpliced.lua

@@ -0,0 +1,5 @@
+local function __TS__ArrayToSpliced(self, start, deleteCount, ...)
+    local copy = {__TS__Unpack(self)}
+    __TS__ArraySplice(copy, start, deleteCount, ...)
+    return copy
+end

package/dist/lualib/universal/ArrayWith.lua

@@ -0,0 +1,5 @@
+local function __TS__ArrayWith(self, index, value)
+    local copy = {__TS__Unpack(self)}
+    copy[index + 1] = value
+    return copy
+end

package/dist/lualib/universal/Symbol.lua

@@ -7,6 +7,8 @@ do
         return setmetatable({description = description}, symbolMetatable)
     end
     Symbol = {
+        asyncDispose = __TS__Symbol("Symbol.asyncDispose"),
+        dispose = __TS__Symbol("Symbol.dispose"),
         iterator = __TS__Symbol("Symbol.iterator"),
         hasInstance = __TS__Symbol("Symbol.hasInstance"),
         species = __TS__Symbol("Symbol.species"),

package/dist/lualib/universal/Using.lua

@@ -0,0 +1,27 @@
+local function __TS__Using(self, cb, ...)
+    local args = {...}
+    local thrownError
+    local ok, result = xpcall(
+        function() return cb(
+            nil,
+            __TS__Unpack(args)
+        ) end,
+        function(err)
+            thrownError = err
+            return thrownError
+        end
+    )
+    local argArray = {__TS__Unpack(args)}
+    do
+        local i = #argArray - 1
+        while i >= 0 do
+            local ____self_0 = argArray[i + 1]
+            ____self_0[Symbol.dispose](____self_0)
+            i = i - 1
+        end
+    end
+    if not ok then
+        error(thrownError, 0)
+    end
+    return result
+end

package/dist/lualib/universal/UsingAsync.lua

@@ -0,0 +1,35 @@
+local function __TS__UsingAsync(self, cb, ...)
+    local args = {...}
+    return __TS__AsyncAwaiter(function(____awaiter_resolve)
+        local thrownError
+        local ok, result = xpcall(
+            function() return cb(
+                nil,
+                __TS__Unpack(args)
+            ) end,
+            function(err)
+                thrownError = err
+                return thrownError
+            end
+        )
+        local argArray = {__TS__Unpack(args)}
+        do
+            local i = #argArray - 1
+            while i >= 0 do
+                if argArray[i + 1][Symbol.dispose] ~= nil then
+                    local ____self_0 = argArray[i + 1]
+                    ____self_0[Symbol.dispose](____self_0)
+                end
+                if argArray[i + 1][Symbol.asyncDispose] ~= nil then
+                    local ____self_1 = argArray[i + 1]
+                    __TS__Await(____self_1[Symbol.asyncDispose](____self_1))
+                end
+                i = i - 1
+            end
+        end
+        if not ok then
+            error(thrownError, 0)
+        end
+        return ____awaiter_resolve(nil, result)
+    end)
+end

package/dist/lualib/universal/lualib_bundle.lua

@@ -34,6 +34,8 @@ do
         return setmetatable({description = description}, symbolMetatable)
     end
     Symbol = {
+        asyncDispose = __TS__Symbol("Symbol.asyncDispose"),
+        dispose = __TS__Symbol("Symbol.dispose"),
         iterator = __TS__Symbol("Symbol.iterator"),
         hasInstance = __TS__Symbol("Symbol.hasInstance"),
         species = __TS__Symbol("Symbol.species"),
@@ -533,6 +535,32 @@ local function __TS__ArraySetLength(self, length)
     return length
 end
 
+local __TS__Unpack = table.unpack or unpack
+
+local function __TS__ArrayToReversed(self)
+    local copy = {__TS__Unpack(self)}
+    __TS__ArrayReverse(copy)
+    return copy
+end
+
+local function __TS__ArrayToSorted(self, compareFn)
+    local copy = {__TS__Unpack(self)}
+    __TS__ArraySort(copy, compareFn)
+    return copy
+end
+
+local function __TS__ArrayToSpliced(self, start, deleteCount, ...)
+    local copy = {__TS__Unpack(self)}
+    __TS__ArraySplice(copy, start, deleteCount, ...)
+    return copy
+end
+
+local function __TS__ArrayWith(self, index, value)
+    local copy = {__TS__Unpack(self)}
+    copy[index + 1] = value
+    return copy
+end
+
 local function __TS__InstanceOf(obj, classTbl)
     if type(classTbl) ~= "table" then
         error("Right-hand side of 'instanceof' is not an object", 0)
@@ -565,8 +593,6 @@ local function __TS__Class(self)
     return c
 end
 
-local __TS__Unpack = table.unpack or unpack
-
 local function __TS__FunctionBind(fn, ...)
     local boundArgs = {...}
     return function(____, ...)
@@ -2382,6 +2408,70 @@ local function __TS__TypeOf(value)
     end
 end
 
+local function __TS__Using(self, cb, ...)
+    local args = {...}
+    local thrownError
+    local ok, result = xpcall(
+        function() return cb(
+            nil,
+            __TS__Unpack(args)
+        ) end,
+        function(err)
+            thrownError = err
+            return thrownError
+        end
+    )
+    local argArray = {__TS__Unpack(args)}
+    do
+        local i = #argArray - 1
+        while i >= 0 do
+            local ____self_0 = argArray[i + 1]
+            ____self_0[Symbol.dispose](____self_0)
+            i = i - 1
+        end
+    end
+    if not ok then
+        error(thrownError, 0)
+    end
+    return result
+end
+
+local function __TS__UsingAsync(self, cb, ...)
+    local args = {...}
+    return __TS__AsyncAwaiter(function(____awaiter_resolve)
+        local thrownError
+        local ok, result = xpcall(
+            function() return cb(
+                nil,
+                __TS__Unpack(args)
+            ) end,
+            function(err)
+                thrownError = err
+                return thrownError
+            end
+        )
+        local argArray = {__TS__Unpack(args)}
+        do
+            local i = #argArray - 1
+            while i >= 0 do
+                if argArray[i + 1][Symbol.dispose] ~= nil then
+                    local ____self_0 = argArray[i + 1]
+                    ____self_0[Symbol.dispose](____self_0)
+                end
+                if argArray[i + 1][Symbol.asyncDispose] ~= nil then
+                    local ____self_1 = argArray[i + 1]
+                    __TS__Await(____self_1[Symbol.asyncDispose](____self_1))
+                end
+                i = i - 1
+            end
+        end
+        if not ok then
+            error(thrownError, 0)
+        end
+        return ____awaiter_resolve(nil, result)
+    end)
+end
+
 return {
   __TS__ArrayConcat = __TS__ArrayConcat,
   __TS__ArrayEntries = __TS__ArrayEntries,
@@ -2410,6 +2500,10 @@ return {
   __TS__ArrayFlat = __TS__ArrayFlat,
   __TS__ArrayFlatMap = __TS__ArrayFlatMap,
   __TS__ArraySetLength = __TS__ArraySetLength,
+  __TS__ArrayToReversed = __TS__ArrayToReversed,
+  __TS__ArrayToSorted = __TS__ArrayToSorted,
+  __TS__ArrayToSpliced = __TS__ArrayToSpliced,
+  __TS__ArrayWith = __TS__ArrayWith,
   __TS__AsyncAwaiter = __TS__AsyncAwaiter,
   __TS__Await = __TS__Await,
   __TS__Class = __TS__Class,
@@ -2491,5 +2585,7 @@ return {
   __TS__SymbolRegistryFor = __TS__SymbolRegistryFor,
   __TS__SymbolRegistryKeyFor = __TS__SymbolRegistryKeyFor,
   __TS__TypeOf = __TS__TypeOf,
-  __TS__Unpack = __TS__Unpack
+  __TS__Unpack = __TS__Unpack,
+  __TS__Using = __TS__Using,
+  __TS__UsingAsync = __TS__UsingAsync
 }

package/dist/lualib/universal/lualib_module_info.json

@@ -159,6 +159,41 @@
       "__TS__ArraySetLength"
     ]
   },
+  "ArrayToReversed": {
+    "exports": [
+      "__TS__ArrayToReversed"
+    ],
+    "dependencies": [
+      "Unpack",
+      "ArrayReverse"
+    ]
+  },
+  "ArrayToSorted": {
+    "exports": [
+      "__TS__ArrayToSorted"
+    ],
+    "dependencies": [
+      "Unpack",
+      "ArraySort"
+    ]
+  },
+  "ArrayToSpliced": {
+    "exports": [
+      "__TS__ArrayToSpliced"
+    ],
+    "dependencies": [
+      "Unpack",
+      "ArraySplice"
+    ]
+  },
+  "ArrayWith": {
+    "exports": [
+      "__TS__ArrayWith"
+    ],
+    "dependencies": [
+      "Unpack"
+    ]
+  },
   "Await": {
     "exports": [
       "__TS__AsyncAwaiter",
@@ -674,5 +709,24 @@
     "exports": [
       "__TS__Unpack"
     ]
+  },
+  "Using": {
+    "exports": [
+      "__TS__Using"
+    ],
+    "dependencies": [
+      "Unpack",
+      "Symbol"
+    ]
+  },
+  "UsingAsync": {
+    "exports": [
+      "__TS__UsingAsync"
+    ],
+    "dependencies": [
+      "Unpack",
+      "Symbol",
+      "Await"
+    ]
   }
 }

package/dist/lualib-build/plugin.d.ts

@@ -7,7 +7,7 @@ export declare const lualibDiagnostic: ((message: string, file?: ts.SourceFile |
 };
 declare class LuaLibPlugin implements tstl.Plugin {
     visitors: {
-        311: (file: ts.SourceFile, context: tstl.TransformationContext) => tstl.File;
+        312: (file: ts.SourceFile, context: tstl.TransformationContext) => tstl.File;
     };
     printer: tstl.Printer;
     afterPrint(program: ts.Program, options: tstl.CompilerOptions, emitHost: EmitHost, result: ProcessedFile[]): ts.Diagnostic[];

package/dist/transformation/builtins/array.js

@@ -133,6 +133,14 @@ function transformArrayPrototypeCall(context, node, calledMethod) {
             return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayFlat, node, caller, ...params);
         case "flatMap":
             return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayFlatMap, node, caller, ...params);
+        case "toReversed":
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayToReversed, node, caller, ...params);
+        case "toSorted":
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayToSorted, node, caller, ...params);
+        case "toSpliced":
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayToSpliced, node, caller, ...params);
+        case "with":
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayWith, node, caller, ...params);
         default:
             context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(calledMethod.name, "array", expressionName));
     }

package/dist/transformation/index.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformSourceFile = exports.createVisitorMap = void 0;
+const ts = require("typescript");
 const utils_1 = require("../utils");
 const context_1 = require("./context");
 const visitors_1 = require("./visitors");
+const using_transformer_1 = require("./pre-transformers/using-transformer");
 function createVisitorMap(customVisitors) {
     const objectVisitorMap = new Map();
     for (const visitors of [visitors_1.standardVisitors, ...customVisitors]) {
@@ -26,7 +28,11 @@ function createVisitorMap(customVisitors) {
 exports.createVisitorMap = createVisitorMap;
 function transformSourceFile(program, sourceFile, visitorMap) {
     const context = new context_1.TransformationContext(program, sourceFile, visitorMap);
-    const [file] = context.transformNode(sourceFile);
+    // TS -> TS pre-transformation
+    const preTransformers = [(0, using_transformer_1.usingTransformer)(context)];
+    const result = ts.transform(sourceFile, preTransformers);
+    // TS -> Lua transformation
+    const [file] = context.transformNode(result.transformed[0]);
     return { file, diagnostics: context.diagnostics };
 }
 exports.transformSourceFile = transformSourceFile;

package/dist/transformation/pre-transformers/using-transformer.d.ts

@@ -0,0 +1,3 @@
+import * as ts from "typescript";
+import { TransformationContext } from "../context";
+export declare function usingTransformer(context: TransformationContext): ts.TransformerFactory<ts.SourceFile>;

package/dist/transformation/pre-transformers/using-transformer.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usingTransformer = void 0;
+const ts = require("typescript");
+const lualib_1 = require("../utils/lualib");
+function usingTransformer(context) {
+    return ctx => sourceFile => {
+        function visit(node) {
+            if (ts.isBlock(node)) {
+                const [hasUsings, newStatements] = transformBlockWithUsing(context, node.statements, node);
+                if (hasUsings) {
+                    // Recurse visitor into updated block to find further usings
+                    const updatedBlock = ts.factory.updateBlock(node, newStatements);
+                    const result = ts.visitEachChild(updatedBlock, visit, ctx);
+                    // Set all the synthetic node parents to something that makes sense
+                    const parent = [updatedBlock];
+                    function setParent(node2) {
+                        ts.setParent(node2, parent[parent.length - 1]);
+                        parent.push(node2);
+                        ts.visitEachChild(node2, setParent, ctx);
+                        parent.push();
+                        return node2;
+                    }
+                    ts.visitEachChild(updatedBlock, setParent, ctx);
+                    ts.setParent(updatedBlock, node.parent);
+                    return result;
+                }
+            }
+            return ts.visitEachChild(node, visit, ctx);
+        }
+        return ts.visitEachChild(sourceFile, visit, ctx);
+    };
+}
+exports.usingTransformer = usingTransformer;
+function isUsingDeclarationList(node) {
+    return ts.isVariableStatement(node) && (node.declarationList.flags & ts.NodeFlags.Using) !== 0;
+}
+function transformBlockWithUsing(context, statements, block) {
+    const newStatements = [];
+    for (let i = 0; i < statements.length; i++) {
+        const statement = statements[i];
+        if (isUsingDeclarationList(statement)) {
+            const isAwaitUsing = (statement.declarationList.flags & ts.NodeFlags.AwaitContext) !== 0;
+            if (isAwaitUsing) {
+                (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.UsingAsync);
+            }
+            else {
+                (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Using);
+            }
+            // Make declared using variables callback function parameters
+            const variableNames = statement.declarationList.declarations.map(d => ts.factory.createParameterDeclaration(undefined, undefined, d.name));
+            // Add this: void as first parameter
+            variableNames.unshift(createThisVoidParameter(context.checker));
+            // Put all following statements in the callback body
+            const followingStatements = statements.slice(i + 1);
+            const [followingHasUsings, replacedFollowingStatements] = transformBlockWithUsing(context, followingStatements, block);
+            const callbackBody = ts.factory.createBlock(followingHasUsings ? replacedFollowingStatements : followingStatements);
+            const callback = ts.factory.createFunctionExpression(undefined, undefined, undefined, undefined, variableNames, undefined, callbackBody);
+            // Replace using variable list with call to lualib function with callback and followed by all variable initializers
+            const functionIdentifier = ts.factory.createIdentifier(isAwaitUsing ? "__TS__UsingAsync" : "__TS__Using");
+            let call = ts.factory.createCallExpression(functionIdentifier, [], [
+                callback,
+                ...statement.declarationList.declarations.map(d => { var _a; return (_a = d.initializer) !== null && _a !== void 0 ? _a : ts.factory.createIdentifier("unidentified"); }),
+            ]);
+            // If this is an 'await using ...', add an await statement here
+            if (isAwaitUsing) {
+                call = ts.factory.createAwaitExpression(call);
+            }
+            if (ts.isBlock(block.parent) && block.parent.statements[block.parent.statements.length - 1] !== block) {
+                // If this is a free-standing block in a function (not the last statement), dont return the value
+                newStatements.push(ts.factory.createExpressionStatement(call));
+            }
+            else {
+                newStatements.push(ts.factory.createReturnStatement(call));
+            }
+            return [true, newStatements];
+        }
+        else {
+            newStatements.push(statement);
+        }
+    }
+    return [false];
+}
+function createThisVoidParameter(checker) {
+    const voidType = checker.typeToTypeNode(checker.getVoidType(), undefined, undefined);
+    return ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier("this"), undefined, voidType);
+}
+//# sourceMappingURL=using-transformer.js.map

package/dist/transformation/visitors/function.js

@@ -161,10 +161,16 @@ function transformParameters(context, parameters, functionContext) {
 }
 exports.transformParameters = transformParameters;
 function transformFunctionToExpression(context, node) {
+    var _a;
     (0, utils_1.assert)(node.body);
     const type = context.checker.getTypeAtLocation(node);
     let functionContext;
-    if ((0, function_context_1.getFunctionContextType)(context, type) !== function_context_1.ContextType.Void) {
+    const firstParam = node.parameters[0];
+    const hasThisVoidParameter = firstParam &&
+        ts.isIdentifier(firstParam.name) &&
+        ts.identifierToKeywordKind(firstParam.name) === ts.SyntaxKind.ThisKeyword &&
+        ((_a = firstParam.type) === null || _a === void 0 ? void 0 : _a.kind) === ts.SyntaxKind.VoidKeyword;
+    if (!hasThisVoidParameter && (0, function_context_1.getFunctionContextType)(context, type) !== function_context_1.ContextType.Void) {
         if (ts.isArrowFunction(node)) {
             // dummy context for arrow functions with parameters
             if (node.parameters.length > 0) {

package/dist/transformation/visitors/variable-declaration.js

@@ -206,8 +206,8 @@ function transformVariableDeclaration(context, statement) {
 }
 exports.transformVariableDeclaration = transformVariableDeclaration;
 function checkVariableDeclarationList(context, node) {
-    if ((node.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) === 0) {
-        const token = node.getFirstToken();
+    if ((node.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const | ts.NodeFlags.Using | ts.NodeFlags.AwaitUsing)) === 0) {
+        const token = ts.getOriginalNode(node).getFirstToken();
         (0, utils_1.assert)(token);
         context.diagnostics.push((0, diagnostics_1.unsupportedVarDeclaration)(token));
     }

package/dist/transpilation/resolve.js

@@ -10,10 +10,11 @@ const utils_1 = require("../utils");
 const diagnostics_1 = require("./diagnostics");
 const CompilerOptions_1 = require("../CompilerOptions");
 const find_lua_requires_1 = require("./find-lua-requires");
+const picomatch = require("picomatch");
 const resolver = resolve.ResolverFactory.createResolver({
     extensions: [".lua"],
     enforceExtension: true,
-    fileSystem: { ...new resolve.CachedInputFileSystem(fs) },
+    fileSystem: { ...new resolve.CachedInputFileSystem(fs, 0) },
     useSyncFileSystemCalls: true,
     conditionNames: ["require", "node", "tstl", "default"],
     symlinks: false, // Do not resolve symlinks to their original paths (that breaks node_modules detection)
@@ -29,7 +30,9 @@ class ResolutionContext {
         this.processedDependencies = new Set();
         // value is false if already searched but not found
         this.pathToFile = new Map();
-        this.noResolvePaths = new Set(options.noResolvePaths);
+        const unique = [...new Set(options.noResolvePaths)];
+        const matchers = unique.map(x => picomatch(x));
+        this.noResolvePaths = matchers;
     }
     addAndResolveDependencies(file) {
         if (this.resolvedFiles.has(file.fileName))
@@ -59,7 +62,7 @@ class ResolutionContext {
             this.resolvedFiles.set("lualib_bundle", { fileName: "lualib_bundle", code: "" });
             return;
         }
-        if (this.noResolvePaths.has(required.requirePath)) {
+        if (this.noResolvePaths.find(isMatch => isMatch(required.requirePath))) {
             if (this.options.tstlVerbose) {
                 console.log(`Skipping module resolution of ${required.requirePath} as it is in the tsconfig noResolvePaths.`);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "typescript-to-lua",
-    "version": "1.17.0",
+    "version": "1.19.0",
     "description": "A generic TypeScript to Lua transpiler. Write your code in TypeScript and publish Lua!",
     "repository": "https://github.com/TypeScriptToLua/TypeScriptToLua",
     "homepage": "https://typescripttolua.github.io/",
@@ -42,11 +42,12 @@
         "node": ">=16.10.0"
     },
     "peerDependencies": {
-        "typescript": "~5.1.3"
+        "typescript": "5.2.2"
     },
     "dependencies": {
         "@typescript-to-lua/language-extensions": "1.0.0",
         "enhanced-resolve": "^5.8.2",
+        "picomatch": "^2.3.1",
         "resolve": "^1.15.1",
         "source-map": "^0.7.3"
     },
@@ -55,10 +56,11 @@
         "@types/glob": "^7.1.1",
         "@types/jest": "^27.5.2",
         "@types/node": "^13.7.7",
+        "@types/picomatch": "^2.3.0",
         "@types/resolve": "1.14.0",
-        "@typescript-eslint/eslint-plugin": "^5.55.0",
-        "@typescript-eslint/parser": "^5.55.0",
-        "eslint": "^8.36.0",
+        "@typescript-eslint/eslint-plugin": "^5.62.0",
+        "@typescript-eslint/parser": "^5.62.0",
+        "eslint": "^8.47.0",
         "eslint-plugin-import": "^2.27.5",
         "eslint-plugin-jest": "^26.9.0",
         "fs-extra": "^8.1.0",
@@ -70,6 +72,6 @@
         "prettier": "^2.8.4",
         "ts-jest": "^29.1.0",
         "ts-node": "^10.9.1",
-        "typescript": "~5.1.3"
+        "typescript": "^5.2.2"
     }
 }