feat: support latest Node versions

Author: privatenumber

src/cjs/api/module-resolve-filename/resolve-ts-extensions.ts

@@ -6,7 +6,7 @@ import {
 } from '../../../utils/path-utils.js';
 import { allowJs } from '../../../utils/tsconfig.js';
 import type { SimpleResolve } from '../types.js';
-import { logCjs } from '../../../utils/debug.js';
+import { logCjs as log } from '../../../utils/debug.js';
 
 /**
  * Typescript gives .ts, .cts, or .mts priority over actual .js, .cjs, or .mjs extensions
@@ -16,7 +16,12 @@ const resolveTsFilename = (
 	request: string,
 	isTsParent: boolean,
 ) => {
-	logCjs('resolveTsFilename', request);
+	log('resolveTsFilename', {
+		request,
+		isDirectory: isDirectoryPattern.test(request),
+		isTsParent,
+		allowJs,
+	});
 	if (
 		isDirectoryPattern.test(request)
 		|| (!isTsParent && !allowJs)
@@ -50,7 +55,7 @@ export const createTsExtensionResolver = (
 ): SimpleResolve => (
 	request,
 ) => {
-	logCjs('resolveTsFilename', {
+	log('resolveTsFilename', {
 		request,
 		isTsParent,
 		isFilePath: isFilePath(request),

src/esm/hook/load.ts

@@ -6,17 +6,23 @@ import type { TransformOptions } from 'esbuild';
 import { transform, transformSync } from '../../utils/transform/index.js';
 import { transformDynamicImport } from '../../utils/transform/transform-dynamic-import.js';
 import { inlineSourceMap } from '../../source-map.js';
-import { isFeatureSupported, importAttributes, esmLoadReadFile } from '../../utils/node-features.js';
+import {
+	isFeatureSupported,
+	importAttributes,
+	esmLoadReadFile,
+	requireEsm,
+	loadReadFromSource,
+} from '../../utils/node-features.js';
 import { parent } from '../../utils/ipc/client.js';
 import type { Message } from '../types.js';
 import { fileMatcher } from '../../utils/tsconfig.js';
 import { isJsonPattern, tsExtensionsPattern, fileUrlPrefix } from '../../utils/path-utils.js';
 import { isESM } from '../../utils/es-module-lexer.js';
 import { logEsm as log, debugEnabled } from '../../utils/debug.js';
-import { getNamespace } from './utils.js';
+import { getNamespace, decodeCjsQuery } from './utils.js';
 import { data } from './initialize.js';
 
-const contextAttributesProperty = (
+const importAttributesProperty = (
 	isFeatureSupported(importAttributes)
 		? 'importAttributes'
 		: 'importAssertions' as 'importAttributes'
@@ -32,6 +38,9 @@ let load: LoadHook = async (
 		return nextLoad(url, context);
 	}
 
+	// TODO: Add version
+	url = decodeCjsQuery(url);
+
 	const urlNamespace = getNamespace(url);
 	if (data.namespace && data.namespace !== urlNamespace) {
 		return nextLoad(url, context);
@@ -57,11 +66,121 @@ let load: LoadHook = async (
 		});
 	}
 
+	const filePath = url.startsWith(fileUrlPrefix) ? fileURLToPath(url) : url;
+
+	if (context.format === 'module-json') {
+		const code = await readFile(new URL(url), 'utf8');
+		const transformed = await transform(
+			code,
+			filePath,
+			{
+				tsconfigRaw: (
+					path.isAbsolute(filePath)
+						? fileMatcher?.(filePath) as TransformOptions['tsconfigRaw']
+						: undefined
+				),
+			},
+		);
+		return {
+			shortCircuit: true,
+			format: 'module',
+			source: inlineSourceMap(transformed),
+		};
+	}
+
+	if (context.format === 'commonjs-json') {
+		const code = await readFile(new URL(url), 'utf8');
+		const transformed = transformSync(
+			code,
+			filePath,
+			{
+				tsconfigRaw: (
+					path.isAbsolute(filePath)
+						? fileMatcher?.(filePath) as TransformOptions['tsconfigRaw']
+						: undefined
+				),
+			},
+		);
+
+		const jsonExportKeys = Object.keys(JSON.parse(code));
+		transformed.code += `\n0 && (module.exports = {${jsonExportKeys.join(',')}});`;
+
+		return {
+			shortCircuit: true,
+			format: 'commonjs',
+			source: inlineSourceMap(transformed),
+		};
+	}
+
+	/**
+	 * For compiling ambiguous ESM (ESM syntax in a package without type)
+	 * So Node.js can kind of do this now, but it tries CommonJS first, and if it fails,
+	 * it uses NATIVE ESM. This means ESM code that uses mixed syntax (e.g. __dirname)
+	 * wil not work.
+	 */
+	if (
+		(
+			context.format === undefined
+			|| context.format === 'commonjs'
+			|| context.format === 'commonjs-typescript'
+		)
+		&& isFeatureSupported(esmLoadReadFile)
+		&& url.startsWith('file:') // Could be data:
+		&& filePath.endsWith('.js')
+	) {
+		const code = await readFile(new URL(url), 'utf8');
+
+		// if the file extension is .js, only transform if using esm syntax
+		if (isESM(code)) {
+			/**
+			 * es or cjs module lexer unfortunately cannot be used because it doesn't support
+			 * typescript syntax
+			 *
+			 * While the full code is transformed, only the exports are used for parsing.
+			 * In fact, the code can't even run because imports cannot be resolved relative
+			 * from the data: URL.
+			 *
+			 * This should pre-compile for the CJS loader to have a cache hit
+			 *
+			 * I considered extracting the CJS exports from esbuild via (0&&(module.exports={})
+			 * to minimize the data URL size but this only works for ESM->CJS and not CTS files
+			 * which are already in CJS syntax.
+			 * In CTS, module.exports can be written in any pattern.
+			 */
+			const transformed = transformSync(
+				code,
+				url,
+				{
+					tsconfigRaw: fileMatcher?.(filePath) as TransformOptions['tsconfigRaw'],
+				},
+			);
+
+			if (isFeatureSupported(loadReadFromSource)) {
+				return {
+					shortCircuit: true,
+					format: 'commonjs',
+
+					// This is necessary for CJS exports to be parsed correctly
+					// Returning a `source` makes the ESM translator to handle
+					// the CJS compilation and skips the CJS loader
+					source: inlineSourceMap(transformed),
+				};
+			}
+
+			const filePathWithNamespace = urlNamespace ? `${filePath}?namespace=${encodeURIComponent(urlNamespace)}` : filePath;
+			return {
+				shortCircuit: true,
+				format: 'commonjs',
+				responseURL: `data:text/javascript,${encodeURIComponent(transformed.code)}?filePath=${encodeURIComponent(filePathWithNamespace)}`,
+			};
+		}
+	}
+
 	if (isJsonPattern.test(url)) {
-		let contextAttributes = context[contextAttributesProperty];
+		let contextAttributes = context[importAttributesProperty];
 		if (!contextAttributes) {
 			contextAttributes = {};
-			context[contextAttributesProperty] = contextAttributes;
+			context[importAttributesProperty] = contextAttributes;
 		}
 
 		if (!contextAttributes.type) {
@@ -75,7 +194,21 @@ let load: LoadHook = async (
 		loaded,
 	});
 
-	const filePath = url.startsWith(fileUrlPrefix) ? fileURLToPath(url) : url;
+	if (
+		isFeatureSupported(loadReadFromSource)
+		&& loaded.format === 'commonjs'
+		&& filePath.endsWith('.cjs')
+	) {
+		let code = await readFile(new URL(url), 'utf8');
+		// Contains native ESM check
+		const transformed = transformDynamicImport(filePath, code);
+		if (transformed) {
+			code = inlineSourceMap(transformed);
+		}
+		loaded.source = code;
+		loaded.shortCircuit = true;
+		return loaded;
+	}
 
 	if (
 		loaded.format === 'commonjs'
@@ -86,7 +219,13 @@ let load: LoadHook = async (
 		const code = await readFile(new URL(url), 'utf8');
 
 		// if the file extension is .js, only transform if using esm syntax
-		if (!filePath.endsWith('.js') || isESM(code)) {
+		if (
+			// TypeScript files
+			!filePath.endsWith('.js')
+
+			// ESM syntax in CommonJS type package
+			|| isESM(code)
+		) {
 			/**
 			 * es or cjs module lexer unfortunately cannot be used because it doesn't support
 			 * typescript syntax
@@ -104,15 +243,26 @@ let load: LoadHook = async (
 			 */
 			const transformed = transformSync(
 				code,
-				filePath,
+				url,
 				{
 					tsconfigRaw: fileMatcher?.(filePath) as TransformOptions['tsconfigRaw'],
 				},
 			);
 
-			const filePathWithNamespace = urlNamespace ? `${filePath}?namespace=${encodeURIComponent(urlNamespace)}` : filePath;
-
-			loaded.responseURL = `data:text/javascript,${encodeURIComponent(transformed.code)}?filePath=${encodeURIComponent(filePathWithNamespace)}`;
+			if (isFeatureSupported(loadReadFromSource)) {
+				/**
+				 * Compile ESM to CJS
+				 * In v22.15, the CJS loader logic is now moved to the ESM loader
+				 */
+				loaded.source = inlineSourceMap(transformed);
+			} else {
+				/**
+				 * This tricks Node into thinking the file is a data URL so it doesn't try to read from disk
+				 * to parse the CJS exports
+				 */
+				const filePathWithNamespace = urlNamespace ? `${filePath}?namespace=${encodeURIComponent(urlNamespace)}` : filePath;
+				loaded.responseURL = `data:text/javascript,${encodeURIComponent(transformed.code)}?filePath=${encodeURIComponent(filePathWithNamespace)}`;
+			}
 
 			log('returning CJS export annotation', loaded);
 			return loaded;
@@ -126,8 +276,40 @@ let load: LoadHook = async (
 
 	const code = loaded.source.toString();
 
+	// Since CJS can now require ESM, JSONs are now handled by the
+	// ESM loader as ESM in module contexts
+	// TODO: If we can detect whether this was "required",
+	// we can let the CJS loader handler it by returning an empty source
+	// Support named imports in JSON modules
+	/**
+	 * In versions of Node that supports require'ing ESM,
+	 */
+	if (
+		isFeatureSupported(requireEsm)
+		&& loaded.format === 'json'
+	) {
+		const transformed = transformSync(
+			code,
+			filePath,
+			{
+				tsconfigRaw: (
+					path.isAbsolute(filePath)
+						? fileMatcher?.(filePath) as TransformOptions['tsconfigRaw']
+						: undefined
+				),
+			},
+		);
+
+		const jsonExportKeys = Object.keys(JSON.parse(code));
+		transformed.code += `\n0 && (module.exports = {${jsonExportKeys.join(',')}});`;
+
+		return {
+			format: 'commonjs',
+			source: inlineSourceMap(transformed),
+		};
+	}
+
 	if (
-		// Support named imports in JSON modules
 		loaded.format === 'json'
 		|| tsExtensionsPattern.test(url)
 	) {