@openrewrite/rewrite 8.66.0-20251028-141506 → 8.66.0-20251029-101717

package/dist/javascript/parser.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
 var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
@@ -33,6 +66,7 @@ exports.JavaScriptParserVisitor = exports.JavaScriptParser = void 0;
  * limitations under the License.
  */
 const typescript_1 = __importDefault(require("typescript"));
+const path = __importStar(require("path"));
 const java_1 = require("../java");
 const _1 = require(".");
 const markers_1 = require("../markers");
@@ -93,7 +127,11 @@ class JavaScriptParser extends parser_1.Parser {
             const inputFiles = new Map();
             // Populate inputFiles map and remove from cache if necessary
             for (const input of inputs) {
-                const sourcePath = (0, parser_1.parserInputFile)(input);
+                let sourcePath = (0, parser_1.parserInputFile)(input);
+                // If relativeTo is set and path is not absolute, make it absolute
+                if (this.relativeTo && !path.isAbsolute(sourcePath)) {
+                    sourcePath = path.join(this.relativeTo, sourcePath);
+                }
                 inputFiles.set(sourcePath, input);
                 // Remove from cache if previously cached
                 this.sourceFileCache && this.sourceFileCache.delete(sourcePath);
@@ -154,6 +192,49 @@ class JavaScriptParser extends parser_1.Parser {
                 const input = inputFiles.get(fileName);
                 return input ? (0, parser_1.parserInputRead)(input) : typescript_1.default.sys.readFile(fileName);
             };
+            // Custom module resolution to handle in-memory imports
+            // This is required because TypeScript's default module resolution looks for files on disk,
+            // but our source files only exist in memory (in the inputFiles map)
+            host.resolveModuleNameLiterals = (moduleLiterals, containingFile) => {
+                const resolvedModules = [];
+                const containingDir = path.dirname(containingFile);
+                for (const moduleLiteral of moduleLiterals) {
+                    const moduleName = moduleLiteral.text;
+                    // For relative imports, try to find in inputFiles first
+                    if (moduleName.startsWith('.')) {
+                        const extensions = ['.tsx', '.ts', '.jsx', '.js', '.mts', '.cts'];
+                        let resolved;
+                        for (const ext of extensions) {
+                            // Try with extension
+                            const candidate = path.join(containingDir, moduleName + ext);
+                            if (inputFiles.has(candidate)) {
+                                resolved = candidate;
+                                break;
+                            }
+                            // Also try exact match (if moduleName already has extension)
+                            const exactCandidate = path.join(containingDir, moduleName);
+                            if (inputFiles.has(exactCandidate)) {
+                                resolved = exactCandidate;
+                                break;
+                            }
+                        }
+                        if (resolved) {
+                            resolvedModules.push({
+                                resolvedModule: {
+                                    resolvedFileName: resolved,
+                                    extension: path.extname(resolved),
+                                    isExternalLibraryImport: false,
+                                }
+                            });
+                            continue;
+                        }
+                    }
+                    // Fall back to TypeScript's default resolution for node_modules and absolute paths
+                    const result = typescript_1.default.resolveModuleName(moduleName, containingFile, this.compilerOptions, host);
+                    resolvedModules.push(result);
+                }
+                return resolvedModules;
+            };
             // Create a new Program, passing the oldProgram for incremental parsing
             const program = typescript_1.default.createProgram([...inputFiles.keys()], this.compilerOptions, host, this.oldProgram);
             // Update the oldProgram reference