typescript-to-lua 1.7.0 → 1.8.0

package/dist/LuaLib.d.ts

@@ -42,6 +42,7 @@ export declare enum LuaLibFeature {
     InstanceOf = "InstanceOf",
     InstanceOfObject = "InstanceOfObject",
     Iterator = "Iterator",
+    LuaIteratorSpread = "LuaIteratorSpread",
     Map = "Map",
     MathAtan2 = "MathAtan2",
     MathSign = "MathSign",

package/dist/LuaLib.js

@@ -46,6 +46,7 @@ var LuaLibFeature;
     LuaLibFeature["InstanceOf"] = "InstanceOf";
     LuaLibFeature["InstanceOfObject"] = "InstanceOfObject";
     LuaLibFeature["Iterator"] = "Iterator";
+    LuaLibFeature["LuaIteratorSpread"] = "LuaIteratorSpread";
     LuaLibFeature["Map"] = "Map";
     LuaLibFeature["MathAtan2"] = "MathAtan2";
     LuaLibFeature["MathSign"] = "MathSign";

package/dist/lualib/LuaIteratorSpread.lua

@@ -0,0 +1,9 @@
+local function __TS__LuaIteratorSpread(self, state, firstKey)
+    local results = {}
+    local key, value = self(state, firstKey)
+    while key do
+        results[#results + 1] = {key, value}
+        key, value = self(state, key)
+    end
+    return __TS__Unpack(results)
+end

package/dist/lualib/lualib_bundle.lua

@@ -1207,6 +1207,16 @@ local function __TS__InstanceOfObject(value)
     return valueType == "table" or valueType == "function"
 end
 
+local function __TS__LuaIteratorSpread(self, state, firstKey)
+    local results = {}
+    local key, value = self(state, firstKey)
+    while key do
+        results[#results + 1] = {key, value}
+        key, value = self(state, key)
+    end
+    return __TS__Unpack(results)
+end
+
 local Map
 do
     Map = __TS__Class()
@@ -2448,6 +2458,7 @@ return {
   __TS__InstanceOf = __TS__InstanceOf,
   __TS__InstanceOfObject = __TS__InstanceOfObject,
   __TS__Iterator = __TS__Iterator,
+  __TS__LuaIteratorSpread = __TS__LuaIteratorSpread,
   Map = Map,
   __TS__MathAtan2 = __TS__MathAtan2,
   __TS__MathSign = __TS__MathSign,

package/dist/lualib/lualib_module_info.json

@@ -264,6 +264,14 @@
       "Symbol"
     ]
   },
+  "LuaIteratorSpread": {
+    "exports": [
+      "__TS__LuaIteratorSpread"
+    ],
+    "dependencies": [
+      "Unpack"
+    ]
+  },
   "Map": {
     "exports": [
       "Map"

package/dist/transformation/utils/language-extensions.d.ts

@@ -60,5 +60,6 @@ export declare enum IterableExtensionKind {
     Pairs = "Pairs",
     PairsKey = "PairsKey"
 }
+export declare function isLuaIterable(context: TransformationContext, type: ts.Type): boolean;
 export declare function getIterableExtensionTypeForType(context: TransformationContext, type: ts.Type): IterableExtensionKind | undefined;
 export declare function getIterableExtensionKindForNode(context: TransformationContext, node: ts.Node): IterableExtensionKind | undefined;

package/dist/transformation/utils/language-extensions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getIterableExtensionKindForNode = exports.getIterableExtensionTypeForType = exports.IterableExtensionKind = exports.getExtensionKindForSymbol = exports.getExtensionKindForNode = exports.getExtensionKindForType = exports.ExtensionKind = void 0;
+exports.getIterableExtensionKindForNode = exports.getIterableExtensionTypeForType = exports.isLuaIterable = exports.IterableExtensionKind = exports.getExtensionKindForSymbol = exports.getExtensionKindForNode = exports.getExtensionKindForType = exports.ExtensionKind = void 0;
 const ts = require("typescript");
 var ExtensionKind;
 (function (ExtensionKind) {
@@ -96,6 +96,10 @@ var IterableExtensionKind;
     IterableExtensionKind["Pairs"] = "Pairs";
     IterableExtensionKind["PairsKey"] = "PairsKey";
 })(IterableExtensionKind = exports.IterableExtensionKind || (exports.IterableExtensionKind = {}));
+function isLuaIterable(context, type) {
+    return getPropertyValue(context, type, "__tstlIterable") !== undefined;
+}
+exports.isLuaIterable = isLuaIterable;
 function getIterableExtensionTypeForType(context, type) {
     const value = getPropertyValue(context, type, "__tstlIterable");
     if (value && value in IterableExtensionKind) {

package/dist/transformation/visitors/call.js

@@ -117,7 +117,7 @@ function transformPropertyCall(context, node, calledMethod) {
     if (calledMethod.expression.kind === ts.SyntaxKind.SuperKeyword) {
         // Super calls take the format of super.call(self,...)
         const parameters = transformArguments(context, node.arguments, signature, ts.factory.createThis());
-        return lua.createCallExpression(context.transformExpression(node.expression), parameters);
+        return lua.createCallExpression(context.transformExpression(node.expression), parameters, node);
     }
     const signatureDeclaration = signature === null || signature === void 0 ? void 0 : signature.getDeclaration();
     if (!signatureDeclaration || (0, function_context_1.getDeclarationContextType)(context, signatureDeclaration) !== function_context_1.ContextType.Void) {
@@ -140,7 +140,7 @@ function transformElementCall(context, node) {
     else {
         // No context
         const [expression, parameters] = transformCallAndArguments(context, node.expression, node.arguments, signature);
-        return lua.createCallExpression(expression, parameters);
+        return lua.createCallExpression(expression, parameters, node);
     }
 }
 const transformCallExpression = (node, context) => {
@@ -175,7 +175,7 @@ const transformCallExpression = (node, context) => {
     // Handle super calls properly
     if (calledExpression.kind === ts.SyntaxKind.SuperKeyword) {
         const parameters = transformArguments(context, node.arguments, signature, ts.factory.createThis());
-        return lua.createCallExpression(lua.createTableIndexExpression(context.transformExpression(ts.factory.createSuper()), lua.createStringLiteral("____constructor")), parameters);
+        return lua.createCallExpression(lua.createTableIndexExpression(context.transformExpression(ts.factory.createSuper()), lua.createStringLiteral("____constructor")), parameters, node);
     }
     let callPath;
     let parameters;

package/dist/transformation/visitors/language-extensions/iterable.js

@@ -9,6 +9,7 @@ const diagnostics_1 = require("../../utils/diagnostics");
 const utils_2 = require("../../../utils");
 const multi_1 = require("./multi");
 function transformForOfMultiIterableStatement(context, statement, block, luaIterator, invalidMultiUseDiagnostic) {
+    context.pushPrecedingStatements();
     let identifiers = [];
     if (ts.isVariableDeclarationList(statement.initializer)) {
         // Variables declared in for loop
@@ -36,6 +37,7 @@ function transformForOfMultiIterableStatement(context, statement, block, luaIter
     if (identifiers.length === 0) {
         identifiers.push(lua.createAnonymousIdentifier());
     }
+    block.statements.unshift(...context.popPrecedingStatements());
     return lua.createForInStatement(block, identifiers, [luaIterator], statement);
 }
 function transformForOfIterableStatement(context, statement, block) {

package/dist/transformation/visitors/modules/import.js

@@ -117,8 +117,8 @@ const transformImportEqualsDeclaration = (node, context) => {
 exports.transformImportEqualsDeclaration = transformImportEqualsDeclaration;
 const transformImportExpression = (node, context) => {
     (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Promise);
-    const importPath = node.arguments.map(a => context.transformExpression(a));
-    return lua.createCallExpression((0, promise_1.createStaticPromiseFunctionAccessor)("resolve", node), importPath, node);
+    const moduleRequire = node.arguments.length > 0 ? createModuleRequire(context, node.arguments[0], node) : lua.createNilLiteral();
+    return lua.createCallExpression((0, promise_1.createStaticPromiseFunctionAccessor)("resolve", node), [moduleRequire], node);
 };
 exports.transformImportExpression = transformImportExpression;
 //# sourceMappingURL=import.js.map

package/dist/transformation/visitors/spread.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformSpreadElement = exports.isOptimizedVarArgSpread = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
+const language_extensions_1 = require("../utils/language-extensions");
 const lua_ast_1 = require("../utils/lua-ast");
 const lualib_1 = require("../utils/lualib");
 const scope_1 = require("../utils/scope");
@@ -60,6 +61,9 @@ const transformSpreadElement = (node, context) => {
     if ((0, multi_1.isMultiReturnCall)(context, tsInnerExpression))
         return innerExpression;
     const type = context.checker.getTypeAtLocation(node.expression); // not ts-inner expression, in case of casts
+    if ((0, language_extensions_1.isLuaIterable)(context, type)) {
+        return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.LuaIteratorSpread, node, innerExpression);
+    }
     if ((0, typescript_1.isArrayType)(context, type)) {
         return (0, lua_ast_1.createUnpackCall)(context, innerExpression, node);
     }

package/dist/transpilation/resolve.js

@@ -104,26 +104,33 @@ class ResolutionContext {
         if (this.options.tstlVerbose) {
             console.log(`Resolving "${dependency}" from ${(0, utils_1.normalizeSlashes)(requiringFile.fileName)}`);
         }
+        const requiredFromLuaFile = requiringFile.fileName.endsWith(".lua");
+        const dependencyPath = requiredFromLuaFile ? luaRequireToPath(dependency) : dependency;
+        if (requiredFromLuaFile && isNodeModulesFile(requiringFile.fileName)) {
+            // If requiring file is in lua module, try to resolve sibling in that file first
+            const resolvedNodeModulesFile = this.resolveLuaDependencyPathFromNodeModules(requiringFile, dependencyPath);
+            if (resolvedNodeModulesFile)
+                return resolvedNodeModulesFile;
+        }
         // Check if the import is relative
         const isRelative = ["/", "./", "../"].some(p => dependency.startsWith(p));
         // If the import is relative, always resolve it relative to the requiring file
         // If the import is not relative, resolve it relative to options.baseUrl if it is set
         const relativeTo = isRelative ? fileDirectory : (_a = this.options.baseUrl) !== null && _a !== void 0 ? _a : fileDirectory;
         // Check if file is a file in the project
-        const resolvedPath = path.join(relativeTo, dependency);
+        const resolvedPath = path.join(relativeTo, dependencyPath);
         const fileFromPath = this.getFileFromPath(resolvedPath);
         if (fileFromPath)
             return fileFromPath;
-        // Check if this is a sibling of a required lua file
-        if (requiringFile.fileName.endsWith(".lua")) {
-            const luaFilePath = resolveLuaPath(fileDirectory, dependency, this.emitHost);
-            if (luaFilePath) {
-                return luaFilePath;
-            }
+        if (this.options.paths && this.options.baseUrl) {
+            // If no file found yet and paths are present, try to find project file via paths mappings
+            const fileFromPaths = this.tryGetModuleNameFromPaths(dependencyPath, this.options.paths, this.options.baseUrl);
+            if (fileFromPaths)
+                return fileFromPaths;
         }
         // Not a TS file in our project sources, use resolver to check if we can find dependency
         try {
-            const resolveResult = resolver.resolveSync({}, fileDirectory, dependency);
+            const resolveResult = resolver.resolveSync({}, fileDirectory, dependencyPath);
             if (resolveResult)
                 return resolveResult;
         }
@@ -132,6 +139,25 @@ class ResolutionContext {
         }
         return undefined;
     }
+    resolveLuaDependencyPathFromNodeModules(requiringFile, dependency) {
+        // We don't know for sure where the lua root is, so guess it is at package root
+        const splitPath = path.normalize(requiringFile.fileName).split(path.sep);
+        let packageRootIndex = splitPath.lastIndexOf("node_modules") + 2;
+        let packageRoot = splitPath.slice(0, packageRootIndex).join(path.sep);
+        while (packageRootIndex < splitPath.length) {
+            // Try to find lua file relative to currently guessed Lua root
+            const resolvedPath = path.join(packageRoot, dependency);
+            const fileFromPath = this.getFileFromPath(resolvedPath);
+            if (fileFromPath) {
+                return fileFromPath;
+            }
+            else {
+                // Did not find file at current root, try again one directory deeper
+                packageRoot = path.join(packageRoot, splitPath[packageRootIndex++]);
+            }
+        }
+        return undefined;
+    }
     getFileFromPath(resolvedPath) {
         const existingFile = this.pathToFile.get(resolvedPath);
         if (existingFile)
@@ -167,6 +193,40 @@ class ResolutionContext {
             }
         }
     }
+    // Taken from TS and modified: https://github.com/microsoft/TypeScript/blob/88a1e3a1dd8d2d86e844ff1c16d5f041cebcfdb9/src/compiler/moduleSpecifiers.ts#L562
+    tryGetModuleNameFromPaths(relativeToBaseUrl, paths, baseUrl) {
+        const relativeImport = removeTrailingDirectorySeparator((0, utils_1.normalizeSlashes)(relativeToBaseUrl));
+        for (const [importPattern, targetPatterns] of Object.entries(paths)) {
+            const pattern = removeFileExtension((0, utils_1.normalizeSlashes)(importPattern));
+            const indexOfStar = pattern.indexOf("*");
+            if (indexOfStar !== -1) {
+                // Try to match <prefix>*<suffix> to relativeImport
+                const prefix = pattern.substring(0, indexOfStar);
+                const suffix = pattern.substring(indexOfStar + 1);
+                if ((relativeImport.length >= prefix.length + suffix.length &&
+                    relativeImport.startsWith(prefix) &&
+                    relativeImport.endsWith(suffix)) ||
+                    (!suffix && relativeImport === removeTrailingDirectorySeparator(prefix))) {
+                    // If import matches <prefix>*<suffix>, extract the matched * path
+                    const matchedStar = relativeImport.substring(prefix.length, relativeImport.length - suffix.length);
+                    // Try to resolve to the target patterns with filled in * pattern
+                    for (const target of targetPatterns) {
+                        const file = this.getFileFromPath(path.join(baseUrl, target.replace("*", matchedStar)));
+                        if (file)
+                            return file;
+                    }
+                }
+            }
+            else if (pattern === relativeImport) {
+                // If there is no * pattern, check for exact matches and try those targets
+                for (const target of targetPatterns) {
+                    const file = this.getFileFromPath(path.join(baseUrl, target));
+                    if (file)
+                        return file;
+                }
+            }
+        }
+    }
 }
 function resolveDependencies(program, files, emitHost) {
     const options = program.getCompilerOptions();
@@ -181,34 +241,6 @@ function resolveDependencies(program, files, emitHost) {
     return { resolvedFiles: [...resolutionContext.resolvedFiles.values()], diagnostics: resolutionContext.diagnostics };
 }
 exports.resolveDependencies = resolveDependencies;
-function resolveLuaPath(fromPath, dependency, emitHost) {
-    const splitDependency = dependency.split(".");
-    if (splitDependency.length === 1) {
-        // If dependency has just one part (the file), look for a lua file with that name
-        const fileDirectory = walkUpFileTreeUntil(fromPath, dir => emitHost.fileExists(path.join(dir, dependency) + ".lua"));
-        if (fileDirectory) {
-            return path.join(fileDirectory, dependency) + ".lua";
-        }
-    }
-    else {
-        // If dependency has multiple parts, look for the first directory of the require path, which must be in the lua root
-        const luaRoot = walkUpFileTreeUntil(fromPath, dir => emitHost.directoryExists(path.join(dir, splitDependency[0])));
-        if (luaRoot) {
-            return path.join(luaRoot, dependency.replace(/\./g, path.sep)) + ".lua";
-        }
-    }
-}
-function walkUpFileTreeUntil(fromDirectory, predicate) {
-    const currentDir = path.normalize(fromDirectory).split(path.sep);
-    while (currentDir.length > 0) {
-        const dir = currentDir.join(path.sep);
-        if (predicate(dir)) {
-            return dir;
-        }
-        currentDir.pop();
-    }
-    return undefined;
-}
 function shouldRewriteRequires(resolvedDependency, program) {
     return !isBuildModeLibrary(program) || !isNodeModulesFile(resolvedDependency);
 }
@@ -228,7 +260,7 @@ function isBuildModeLibrary(program) {
 function findRequiredPaths(code) {
     // Find all require("<path>") paths in a lua code string
     const paths = [];
-    const pattern = /(^|\s|;|=)require\("(.+?)"\)/g;
+    const pattern = /(^|\s|;|=|\()require\("(.+?)"\)/g;
     // eslint-disable-next-line @typescript-eslint/ban-types
     let match;
     while ((match = pattern.exec(code))) {
@@ -240,7 +272,7 @@ function replaceRequireInCode(file, originalRequire, newRequire) {
     const requirePath = (0, utils_1.formatPathToLuaPath)(newRequire.replace(".lua", ""));
     // Escape special characters to prevent the regex from breaking...
     const escapedRequire = originalRequire.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
-    file.code = file.code.replace(new RegExp(`(^|\\s|;|=)require\\("${escapedRequire}"\\)`), `$1require("${requirePath}")`);
+    file.code = file.code.replace(new RegExp(`(^|\\s|;|=|\\()require\\("${escapedRequire}"\\)`), `$1require("${requirePath}")`);
 }
 function replaceRequireInSourceMap(file, originalRequire, newRequire) {
     const requirePath = (0, utils_1.formatPathToLuaPath)(newRequire.replace(".lua", ""));
@@ -285,4 +317,13 @@ function fallbackResolve(required, sourceRootDir, fileDir) {
         .filter(s => s !== "." && s !== "..")
         .join(path.sep));
 }
+function luaRequireToPath(requirePath) {
+    return requirePath.replace(/\./g, path.sep);
+}
+function removeFileExtension(path) {
+    return path.includes(".") ? (0, utils_1.trimExtension)(path) : path;
+}
+function removeTrailingDirectorySeparator(path) {
+    return path.endsWith("/") || path.endsWith("\\") ? path.substring(0, -1) : path;
+}
 //# sourceMappingURL=resolve.js.map

package/language-extensions/index.d.ts

@@ -630,7 +630,7 @@ declare const LuaMap: (new <K extends AnyNotNil = AnyNotNil, V = any>() => LuaMa
  * @param K The type of the keys used to access the table.
  * @param V The type of the values stored in the table.
  */
-declare interface LuaReadonlyMap<K extends AnyNotNil = AnyNotNil, V = any> extends LuaPairsIterable<K, V> {
+declare interface ReadonlyLuaMap<K extends AnyNotNil = AnyNotNil, V = any> extends LuaPairsIterable<K, V> {
     get: LuaTableGetMethod<K, V>;
     has: LuaTableHasMethod<K>;
 }
@@ -660,6 +660,17 @@ declare const LuaSet: (new <T extends AnyNotNil = AnyNotNil>() => LuaSet<T>) & L
  *
  * @param T The type of the keys used to access the table.
  */
-declare interface LuaReadonlySet<T extends AnyNotNil = AnyNotNil> extends LuaPairsKeyIterable<T> {
+declare interface ReadonlyLuaSet<T extends AnyNotNil = AnyNotNil> extends LuaPairsKeyIterable<T> {
     has: LuaTableHasMethod<T>;
 }
+
+interface ObjectConstructor {
+    /** Returns an array of keys of an object, when iterated with `pairs`. */
+    keys<K>(o: LuaPairsIterable<K, any> | LuaPairsKeyIterable<K>): K[];
+
+    /** Returns an array of values of an object, when iterated with `pairs`. */
+    values<V>(o: LuaPairsIterable<any, V>): V[];
+
+    /** Returns an array of key/values of an object, when iterated with `pairs`. */
+    entries<K, V>(o: LuaPairsIterable<K, V>): Array<[K, V]>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "typescript-to-lua",
-    "version": "1.7.0",
+    "version": "1.8.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/",