refactor-extract-backend

Author: SukkaW

src/backend/esbuild/eval.ts

@@ -0,0 +1,12 @@
+export const createEsbuildEvalTransformSync = (esbuild: typeof import('esbuild')) => {
+	return function evalTransformSync(evalCode: string, inputType?: string) {
+		return esbuild.transformSync(
+			evalCode,
+			{
+				loader: 'default',
+				sourcefile: '/eval.ts',
+				format: inputType === 'module' ? 'esm' : 'cjs',
+			},
+		).code
+	}
+}

src/utils/transform/get-esbuild-options.ts renamed to src/backend/esbuild/get-esbuild-options.ts

@@ -0,0 +1,14 @@
+import type { TransformOptions } from 'esbuild';
+import type { Backend } from '..';
+import { createEsbuildEvalTransformSync } from './eval';
+import { createEsbuildReplTransform } from './repl';
+import { createEsbuildTransformSync, createEsbuildTransform } from './transform';
+
+export default function getEsbuildBackend(esbuild: typeof import('esbuild')): Backend<TransformOptions> {
+	return {
+		evalTransformSync: createEsbuildEvalTransformSync(esbuild),
+		replTransform: createEsbuildReplTransform(esbuild),
+		transformSync: createEsbuildTransformSync(esbuild),
+		transform: createEsbuildTransform(esbuild),
+	}
+}

src/backend/esbuild/index.ts

@@ -0,0 +1,19 @@
+export const createEsbuildReplTransform = (esbuild: typeof import('esbuild')) => {
+	return async function replTransform (code: string, filename: string): Promise<string> {
+		return (await esbuild.transform(
+			code,
+			{
+				sourcefile: filename,
+				loader: 'ts',
+				tsconfigRaw: {
+					compilerOptions: {
+						preserveValueImports: true,
+					},
+				},
+				define: {
+					require: 'global.require',
+				},
+			},
+		)).code
+	}
+}

src/backend/esbuild/repl.ts

@@ -0,0 +1,141 @@
+import { pathToFileURL } from 'node:url';
+import {
+	type TransformOptions,
+	type TransformFailure,
+} from 'esbuild';
+import { sha1 } from '../../utils/sha1.js';
+import {
+	version as transformDynamicImportVersion,
+	transformDynamicImport,
+} from '../../utils/transform/transform-dynamic-import.js';
+import cache from '../../utils/transform/cache.js';
+import {
+	applyTransformersSync,
+	applyTransformers,
+	type Transformed,
+} from '../../utils/transform/apply-transformers.js';
+import {
+	cacheConfig,
+	patchOptions,
+} from './get-esbuild-options.js';
+
+const formatEsbuildError = (
+	error: TransformFailure,
+) => {
+	error.name = 'TransformError';
+	// @ts-expect-error deleting non-option property
+	delete error.errors;
+	// @ts-expect-error deleting non-option property
+	delete error.warnings;
+	throw error;
+};
+
+export const createEsbuildTransformSync = (esbuild: typeof import('esbuild')) => {
+	// Used by cjs-loader
+	return function transformSync(
+		code: string,
+		filePath: string,
+		extendOptions?: TransformOptions,
+	): Transformed {
+		const [filePathWithoutQuery, query] = filePath.split('?');
+		const define: { [key: string]: string } = {};
+
+		if (!(filePathWithoutQuery.endsWith('.cjs') || filePathWithoutQuery.endsWith('.cts'))) {
+			define['import.meta.url'] = JSON.stringify(pathToFileURL(filePathWithoutQuery) + (query ? `?${query}` : ''));
+		}
+
+		const esbuildOptions = {
+			...cacheConfig,
+			format: 'cjs',
+			sourcefile: filePathWithoutQuery,
+			define,
+			banner: '(()=>{',
+			footer: '})()',
+
+			// CJS Annotations for Node. Used by ESM loader for CJS interop
+			platform: 'node',
+
+			...extendOptions,
+		} as const;
+
+		const hash = sha1([
+			code,
+			JSON.stringify(esbuildOptions),
+			esbuild.version,
+			transformDynamicImportVersion,
+		].join('-'));
+		let transformed = cache.get(hash);
+
+		if (!transformed) {
+			transformed = applyTransformersSync(
+				filePath,
+				code,
+				[
+					(_filePath, _code) => {
+						const patchResult = patchOptions(esbuildOptions);
+						let result;
+						try {
+							result = esbuild.transformSync(_code, esbuildOptions);
+						} catch (error) {
+							throw formatEsbuildError(error as TransformFailure);
+						}
+						return patchResult(result);
+					},
+					(_filePath, _code) => transformDynamicImport(_filePath, _code, true),
+				],
+			);
+
+			cache.set(hash, transformed);
+		}
+
+		return transformed;
+	};
+};
+
+export const createEsbuildTransform = (esbuild: typeof import('esbuild')) => {
+	// Used by esm-loader
+	return async function transform(
+		code: string,
+		filePath: string,
+		extendOptions?: TransformOptions,
+	): Promise<Transformed> {
+		const esbuildOptions = {
+			...cacheConfig,
+			format: 'esm',
+			sourcefile: filePath,
+			...extendOptions,
+		} as const;
+
+		const hash = sha1([
+			code,
+			JSON.stringify(esbuildOptions),
+			esbuild.version,
+			transformDynamicImportVersion,
+		].join('-'));
+		let transformed = cache.get(hash);
+
+		if (!transformed) {
+			transformed = await applyTransformers(
+				filePath,
+				code,
+				[
+					async (_filePath, _code) => {
+						const patchResult = patchOptions(esbuildOptions);
+						let result;
+						try {
+							result = await esbuild.transform(_code, esbuildOptions);
+						} catch (error) {
+							throw formatEsbuildError(error as TransformFailure);
+						}
+						return patchResult(result);
+					},
+					(_filePath, _code) => transformDynamicImport(_filePath, _code, true),
+				],
+			);
+
+			cache.set(hash, transformed);
+		}
+
+		return transformed;
+	};
+}

src/backend/esbuild/transform.ts

@@ -0,0 +1,24 @@
+import type { Transformed } from '../utils/transform/apply-transformers';
+
+import esbuild from 'esbuild';
+
+import getEsbuildBackend from './esbuild';
+
+export interface Backend<ExtendedTransformOptions> {
+	evalTransformSync: (evalCode: string, inputType?: string) => string;
+	replTransform: (code: string, filename: string) => Promise<string>;
+	transformSync: (
+		code: string,
+		filePath: string,
+		extendOptions?: ExtendedTransformOptions,
+	) => Transformed,
+	transform: (
+		code: string,
+		filePath: string,
+		extendOptions?: ExtendedTransformOptions,
+	) => Promise<Transformed>,
+}
+
+const backend = getEsbuildBackend(esbuild);
+
+export default backend;

src/backend/index.ts

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import Module from 'node:module';
 import type { TransformOptions } from 'esbuild';
-import { transformSync } from '../../utils/transform/index.js';
+import backend from '../../backend/index.js';
 import { transformDynamicImport } from '../../utils/transform/transform-dynamic-import.js';
 import { isESM } from '../../utils/es-module-lexer.js';
 import { shouldApplySourceMap, inlineSourceMap } from '../../source-map.js';
@@ -140,7 +140,7 @@ export const createExtensions = (
 			// CommonJS file but uses ESM import/export
 			|| isESM(code)
 		) {
-			const transformed = transformSync(
+			const transformed = backend.transformSync(
 				code,
 				filePath,
 				{

src/cjs/api/module-extensions.ts

@@ -2,9 +2,6 @@ import { constants as osConstants } from 'node:os';
 import type { ChildProcess, Serializable } from 'node:child_process';
 import type { Server } from 'node:net';
 import { cli } from 'cleye';
-import {
-	transformSync as esbuildTransformSync,
-} from 'esbuild';
 import { version } from '../package.json';
 import { run } from './run.js';
 import { watchCommand } from './watch/index.js';
@@ -14,6 +11,7 @@ import {
 } from './remove-argv-flags.js';
 import { isFeatureSupported, testRunnerGlob } from './utils/node-features.js';
 import { createIpcServer } from './utils/ipc/server.js';
+import backend from './backend';
 
 // const debug = (...messages: any[]) => {
 // 	if (process.env.DEBUG) {
@@ -206,16 +204,12 @@ cli({
 	if (evalType) {
 		const { inputType } = interceptedFlags;
 		const evalCode = interceptedFlags[evalType]!;
-		const transformed = esbuildTransformSync(
+		const transformed = backend.evalTransformSync(
 			evalCode,
-			{
-				loader: 'default',
-				sourcefile: '/eval.ts',
-				format: inputType === 'module' ? 'esm' : 'cjs',
-			},
+			inputType,
 		);
 
-		argvsToRun.unshift(`--${evalType}`, transformed.code);
+		argvsToRun.unshift(`--${evalType}`, transformed);
 	}
 
 	// Default --test glob to find TypeScript files

src/cli.ts

@@ -1,9 +1,9 @@
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
-import type { LoadHook } from 'node:module';
+import type { LoadHook, LoadHookContext } from 'node:module';
 import { readFile } from 'node:fs/promises';
 import type { TransformOptions } from 'esbuild';
-import { transform, transformSync } from '../../utils/transform/index.js';
+import backend from '../../backend/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';
@@ -56,11 +56,8 @@ export const load: LoadHook = async (
 	}
 
 	if (isJsonPattern.test(url)) {
-		if (!context[contextAttributesProperty]) {
-			context[contextAttributesProperty] = {};
-		}
-
-		context[contextAttributesProperty]!.type = 'json';
+		context[contextAttributesProperty as keyof LoadHookContext] ||= {} as any;
+		(context[contextAttributesProperty as keyof LoadHookContext] as ImportAttributes).type = 'json';
 	}
 
 	const loaded = await nextLoad(url, context);
@@ -91,7 +88,7 @@ export const load: LoadHook = async (
 			 * which are already in CJS syntax.
 			 * In CTS, module.exports can be written in any pattern.
 			 */
-			const transformed = transformSync(
+			const transformed = backend.transformSync(
 				code,
 				filePath,
 				{
@@ -118,7 +115,7 @@ export const load: LoadHook = async (
 		loaded.format === 'json'
 		|| tsExtensionsPattern.test(url)
 	) {
-		const transformed = await transform(
+		const transformed = await backend.transform(
 			code,
 			filePath,
 			{

src/esm/hook/load.ts

@@ -1,27 +1,11 @@
 import repl, { type REPLServer, type REPLEval } from 'node:repl';
-import { transform } from 'esbuild';
+import backend from './backend';
 
 const patchEval = (nodeRepl: REPLServer) => {
 	const { eval: defaultEval } = nodeRepl;
 	const preEval: REPLEval = async function (code, context, filename, callback) {
 		try {
-			const transformed = await transform(
-				code,
-				{
-					sourcefile: filename,
-					loader: 'ts',
-					tsconfigRaw: {
-						compilerOptions: {
-							preserveValueImports: true,
-						},
-					},
-					define: {
-						require: 'global.require',
-					},
-				},
-			);
-
-			code = transformed.code;
+			code = await backend.replTransform(code, filename);
 		} catch {}
 
 		return defaultEval.call(this, code, context, filename, callback);