typescript-to-lua 1.7.1 → 1.7.2

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/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/package.json

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