typescript-to-lua 1.11.1 → 1.12.0

package/dist/transpilation/find-lua-requires.d.ts

@@ -0,0 +1,6 @@
+export interface LuaRequire {
+    from: number;
+    to: number;
+    requirePath: string;
+}
+export declare function findLuaRequires(lua: string): LuaRequire[];

package/dist/transpilation/find-lua-requires.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findLuaRequires = void 0;
+function findLuaRequires(lua) {
+    return findRequire(lua, 0);
+}
+exports.findLuaRequires = findLuaRequires;
+function findRequire(lua, offset) {
+    const result = [];
+    while (offset < lua.length) {
+        const c = lua[offset];
+        if (c === "r" &&
+            (offset === 0 ||
+                isWhitespace(lua[offset - 1]) ||
+                lua[offset - 1] === "]" ||
+                lua[offset - 1] === "(" ||
+                lua[offset - 1] === "[")) {
+            const m = matchRequire(lua, offset);
+            if (m.matched) {
+                offset = m.match.to + 1;
+                result.push(m.match);
+            }
+            else {
+                offset = m.end;
+            }
+        }
+        else if (c === '"' || c === "'") {
+            offset = readString(lua, offset, c).offset; // Skip string and surrounding quotes
+        }
+        else if (c === "-" && offset + 1 < lua.length && lua[offset + 1] === "-") {
+            offset = skipComment(lua, offset);
+        }
+        else {
+            offset++;
+        }
+    }
+    return result;
+}
+function matchRequire(lua, offset) {
+    const start = offset;
+    for (const c of "require") {
+        if (offset > lua.length) {
+            return { matched: false, end: offset };
+        }
+        if (lua[offset] !== c) {
+            return { matched: false, end: offset };
+        }
+        offset++;
+    }
+    offset = skipWhitespace(lua, offset);
+    let hasParentheses = false;
+    if (offset > lua.length) {
+        return { matched: false, end: offset };
+    }
+    else {
+        if (lua[offset] === "(") {
+            hasParentheses = true;
+            offset++;
+            offset = skipWhitespace(lua, offset);
+        }
+        else if (lua[offset] === '"' || lua[offset] === "'") {
+            // require without parentheses
+        }
+        else {
+            // otherwise fail match
+            return { matched: false, end: offset };
+        }
+    }
+    if (offset > lua.length || (lua[offset] !== '"' && lua[offset] !== "'")) {
+        return { matched: false, end: offset };
+    }
+    const { value: requireString, offset: offsetAfterString } = readString(lua, offset, lua[offset]);
+    offset = offsetAfterString; // Skip string and surrounding quotes
+    if (hasParentheses) {
+        offset = skipWhitespace(lua, offset);
+        if (offset > lua.length || lua[offset] !== ")") {
+            return { matched: false, end: offset };
+        }
+        offset++;
+    }
+    return { matched: true, match: { from: start, to: offset - 1, requirePath: requireString } };
+}
+function readString(lua, offset, delimiter) {
+    expect(lua, offset, delimiter);
+    offset++;
+    let start = offset;
+    let result = "";
+    let escaped = false;
+    while (offset < lua.length && (lua[offset] !== delimiter || escaped)) {
+        if (lua[offset] === "\\" && !escaped) {
+            escaped = true;
+        }
+        else {
+            if (lua[offset] === delimiter) {
+                result += lua.slice(start, offset - 1);
+                start = offset;
+            }
+            escaped = false;
+        }
+        offset++;
+    }
+    if (offset < lua.length) {
+        expect(lua, offset, delimiter);
+    }
+    result += lua.slice(start, offset);
+    return { value: result, offset: offset + 1 };
+}
+function skipWhitespace(lua, offset) {
+    while (offset < lua.length && isWhitespace(lua[offset])) {
+        offset++;
+    }
+    return offset;
+}
+function isWhitespace(c) {
+    return c === " " || c === "\t" || c === "\r" || c === "\n";
+}
+function skipComment(lua, offset) {
+    expect(lua, offset, "-");
+    expect(lua, offset + 1, "-");
+    offset += 2;
+    if (offset + 1 < lua.length && lua[offset] === "[" && lua[offset + 1] === "[") {
+        return skipMultiLineComment(lua, offset);
+    }
+    else {
+        return skipSingleLineComment(lua, offset);
+    }
+}
+function skipMultiLineComment(lua, offset) {
+    while (offset < lua.length && !(lua[offset] === "]" && lua[offset - 1] === "]")) {
+        offset++;
+    }
+    return offset + 1;
+}
+function skipSingleLineComment(lua, offset) {
+    while (offset < lua.length && lua[offset] !== "\n") {
+        offset++;
+    }
+    return offset + 1;
+}
+function expect(lua, offset, char) {
+    if (lua[offset] !== char) {
+        throw new Error(`Expected ${char} at position ${offset} but found ${lua[offset]}`);
+    }
+}
+//# sourceMappingURL=find-lua-requires.js.map

package/dist/transpilation/resolve.js

@@ -9,6 +9,7 @@ const transpiler_1 = require("./transpiler");
 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 resolver = resolve.ResolverFactory.createResolver({
     extensions: [".lua"],
     enforceExtension: true,
@@ -32,12 +33,13 @@ class ResolutionContext {
         if (this.resolvedFiles.has(file.fileName))
             return;
         this.resolvedFiles.set(file.fileName, file);
-        for (const required of findRequiredPaths(file.code)) {
+        // Do this backwards so the replacements do not mess with the positions of the previous requires
+        for (const required of (0, find_lua_requires_1.findLuaRequires)(file.code).reverse()) {
             // Do not resolve noResolution paths
-            if (required.startsWith("@NoResolution:")) {
+            if (required.requirePath.startsWith("@NoResolution:")) {
                 // Remove @NoResolution prefix if not building in library mode
                 if (!isBuildModeLibrary(this.program)) {
-                    const path = required.replace("@NoResolution:", "");
+                    const path = required.requirePath.replace("@NoResolution:", "");
                     replaceRequireInCode(file, required, path);
                     replaceRequireInSourceMap(file, required, path);
                 }
@@ -50,21 +52,21 @@ class ResolutionContext {
     }
     resolveImport(file, required) {
         // Do no resolve lualib - always use the lualib of the application entry point, not the lualib from external packages
-        if (required === "lualib_bundle") {
+        if (required.requirePath === "lualib_bundle") {
             this.resolvedFiles.set("lualib_bundle", { fileName: "lualib_bundle", code: "" });
             return;
         }
-        if (this.noResolvePaths.has(required)) {
+        if (this.noResolvePaths.has(required.requirePath)) {
             if (this.options.tstlVerbose) {
-                console.log(`Skipping module resolution of ${required} as it is in the tsconfig noResolvePaths.`);
+                console.log(`Skipping module resolution of ${required.requirePath} as it is in the tsconfig noResolvePaths.`);
             }
             return;
         }
-        const dependencyPath = this.resolveDependencyPath(file, required);
+        const dependencyPath = this.resolveDependencyPath(file, required.requirePath);
         if (!dependencyPath)
             return this.couldNotResolveImport(required, file);
         if (this.options.tstlVerbose) {
-            console.log(`Resolved ${required} to ${(0, utils_1.normalizeSlashes)(dependencyPath)}`);
+            console.log(`Resolved ${required.requirePath} to ${(0, utils_1.normalizeSlashes)(dependencyPath)}`);
         }
         this.processDependency(dependencyPath);
         // Figure out resolved require path and dependency output path
@@ -96,7 +98,7 @@ class ResolutionContext {
         const fallbackRequire = fallbackResolve(required, (0, transpiler_1.getSourceDir)(this.program), path.dirname(file.fileName));
         replaceRequireInCode(file, required, fallbackRequire);
         replaceRequireInSourceMap(file, required, fallbackRequire);
-        this.diagnostics.push((0, diagnostics_1.couldNotResolveRequire)(required, path.relative((0, transpiler_1.getProjectRoot)(this.program), file.fileName)));
+        this.diagnostics.push((0, diagnostics_1.couldNotResolveRequire)(required.requirePath, path.relative((0, transpiler_1.getProjectRoot)(this.program), file.fileName)));
     }
     resolveDependencyPath(requiringFile, dependency) {
         var _a;
@@ -261,27 +263,17 @@ function shouldIncludeDependency(resolvedDependency, program) {
 function isBuildModeLibrary(program) {
     return program.getCompilerOptions().buildMode === CompilerOptions_1.BuildMode.Library;
 }
-function findRequiredPaths(code) {
-    // Find all require("<path>") paths in a lua code string
-    const paths = [];
-    const pattern = /(^|\s|;|=|\()require\s*\(?(["|'])(.+?)\2\)?/g;
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    let match;
-    while ((match = pattern.exec(code))) {
-        paths.push(match[3]);
-    }
-    return paths;
-}
 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\\s*\\(?["|']${escapedRequire}["|']\\)?`), `$1require("${requirePath}")`);
+    file.code = file.code =
+        file.code.substring(0, originalRequire.from) +
+            `require("${requirePath}")` +
+            file.code.substring(originalRequire.to + 1);
 }
 function replaceRequireInSourceMap(file, originalRequire, newRequire) {
     const requirePath = (0, utils_1.formatPathToLuaPath)(newRequire.replace(".lua", ""));
     if (file.sourceMapNode) {
-        replaceInSourceMap(file.sourceMapNode, file.sourceMapNode, `"${originalRequire}"`, `"${requirePath}"`);
+        replaceInSourceMap(file.sourceMapNode, file.sourceMapNode, `"${originalRequire.requirePath}"`, `"${requirePath}"`);
     }
 }
 function replaceInSourceMap(node, parent, require, resolvedRequire) {
@@ -316,7 +308,7 @@ function hasSourceFileInProject(filePath, program) {
 // Transform an import path to a lua require that is probably not correct, but can be used as fallback when regular resolution fails
 function fallbackResolve(required, sourceRootDir, fileDir) {
     return (0, utils_1.formatPathToLuaPath)(path
-        .normalize(path.join(path.relative(sourceRootDir, fileDir), required))
+        .normalize(path.join(path.relative(sourceRootDir, fileDir), required.requirePath))
         .split(path.sep)
         .filter(s => s !== "." && s !== "..")
         .join(path.sep));

package/package.json

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