refactor: use jiti in favour of bundle-require

package.json

@@ -102,7 +102,7 @@
     "husky": "^8.0.0",
     "inquirer": "^9.3.7",
     "jest-extended": "^6.0.0",
-    "jiti": "2.4.2",
+    "jiti": "^2.4.2",
     "jsdom": "~24.0.0",
     "jsonc-eslint-parser": "^2.4.0",
     "knip": "^5.33.3",

packages/core/src/lib/implementation/read-rc-file.ts

@@ -29,7 +29,6 @@ export async function readRcByPath(
   const cfg: CoreConfig = await importModule({
     filepath: filePath,
     tsconfig,
-    format: 'esm',
   });
 
   return validate(coreConfigSchema, cfg, { filePath });

packages/plugin-coverage/src/lib/nx/coverage-paths.ts

@@ -136,7 +136,6 @@ export async function getCoveragePathForVitest(
 
   const vitestConfig = await importModule<VitestCoverageConfig>({
     filepath: config,
-    format: 'esm',
   });
 
   const reportsDirectory =

packages/plugin-lighthouse/src/lib/runner/utils.ts

@@ -134,7 +134,7 @@ export async function getConfig(
       // Resolve the config file path relative to where cli was called.
       return readJsonFile<Config>(filepath);
     } else if (/\.(ts|js|mjs)$/.test(filepath)) {
-      return importModule<Config>({ filepath, format: 'esm' });
+      return importModule<Config>({ filepath });
     } else {
       logger.warn(`Format of file ${filepath} not supported`);
     }

packages/utils/src/lib/file-system.ts

@@ -1,7 +1,8 @@
 import ansis from 'ansis';
-import { type Options, bundleRequire } from 'bundle-require';
+import { createJiti } from 'jiti';
 import { mkdir, readFile, readdir, rm, stat } from 'node:fs/promises';
 import path from 'node:path';
+import { parseJsonConfigFileContent, readConfigFile, sys } from 'typescript';
 import type { Format, PersistConfig } from '@code-pushup/models';
 import { formatBytes } from './formatting.js';
 import { logMultipleResults } from './log-results.js';
@@ -77,10 +78,80 @@ export function logMultipleFileResults(
   );
 }
 
-export async function importModule<T = unknown>(options: Options): Promise<T> {
-  const { mod } = await bundleRequire<object>(options);
+export function loadTargetConfig(tsConfigPath: string) {
+  const resolvedConfigPath = path.resolve(tsConfigPath);
+  const { config, error } = readConfigFile(resolvedConfigPath, sys.readFile);
 
-  if (typeof mod === 'object' && 'default' in mod) {
+  if (error) {
+    throw new Error(
+      `Error reading TypeScript config file at ${tsConfigPath}:\n${error.messageText}`,
+    );
+  }
+
+  const parsedConfig = parseJsonConfigFileContent(
+    config,
+    sys,
+    path.dirname(resolvedConfigPath),
+    {},
+    resolvedConfigPath,
+  );
+
+  if (parsedConfig.fileNames.length === 0) {
+    throw new Error(
+      'No files matched by the TypeScript configuration. Check your "include", "exclude" or "files" settings.',
+    );
+  }
+
+  return parsedConfig;
+}
+
+type JitiOptions = Parameters<typeof createJiti>[1];
+
+export function tsConfigToJitiOptionsTransformer(
+  tsConfigPath: string,
+): JitiOptions {
+  const parsedConfig = loadTargetConfig(tsConfigPath);
+  const compilerOptions = parsedConfig.options;
+
+  const jitiOptions: JitiOptions = {};
+
+  if (compilerOptions.paths) {
+    const aliases: Record<string, string> = {};
+    const basePath = compilerOptions.baseUrl || path.dirname(tsConfigPath);
+
+    for (const alias in compilerOptions.paths) {
+      const paths = compilerOptions.paths[alias];
+      if (paths && paths.length > 0) {
+        aliases[alias] = path.resolve(basePath, paths[0] as string);
+      }
+    }
+    jitiOptions.alias = aliases;
+  }
+
+  if (compilerOptions.jsx) {
+    jitiOptions.jsx = true;
+  }
+
+  return jitiOptions;
+}
+
+export async function importModule<T = unknown>(
+  options: JitiOptions & { filepath: string; tsconfig?: string },
+): Promise<T> {
+  const { filepath, tsconfig, ...jitiOptions } = options;
+
+  const jitiOptionsFromTsConfig = tsconfig
+    ? tsConfigToJitiOptionsTransformer(tsconfig)
+    : {};
+
+  const jiti = createJiti(process.cwd(), {
+    ...jitiOptions,
+    ...jitiOptionsFromTsConfig,
+  });
+
+  const mod = await jiti.import(filepath);
+
+  if (mod && typeof mod === 'object' && 'default' in mod) {
     return mod.default as T;
   }
   return mod as T;