fix: revert changes

Author: BioPhoton

code-pushup.config.ts

@@ -1,5 +1,4 @@
 import 'dotenv/config';
-import { z } from 'zod';
 import {
   coverageCoreConfigNx,
   eslintCoreConfigNx,

code-pushup.preset.ts

@@ -205,14 +205,12 @@ export const jsDocsCoreConfig = (
 
 export const eslintCoreConfigNx = async (
   projectName?: string,
-  opt?: { cwd?: string },
 ): Promise<CoreConfig> => ({
   plugins: [
     await eslintPlugin(
       await (projectName
         ? eslintConfigFromNxProject(projectName)
         : eslintConfigFromAllNxProjects()),
-      opt,
     ),
   ],
   categories: eslintCategories,

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

@@ -135,9 +135,16 @@ describe('getCoveragePathForTarget', () => {
         },
         'test',
       ),
-    ).resolves.toBe(
-      path.join('packages', 'core', 'coverage', 'core', 'lcov.info'),
-    );
+    ).resolves.toStrictEqual({
+      pathToProject: path.join('packages', 'core'),
+      resultsPath: path.join(
+        'packages',
+        'core',
+        'coverage',
+        'core',
+        'lcov.info',
+      ),
+    });
   });
 
   it('should throw for unsupported executor (only vitest and jest are supported)', async () => {

packages/plugin-eslint/src/bin.ts

@@ -2,6 +2,6 @@ import process from 'node:process';
 import { Parser } from 'yargs/helpers';
 import { executeRunner } from './lib/runner/index.js';
 
-const { runnerConfigPath, runnerOutputPath, cwd } = Parser(process.argv);
+const { runnerConfigPath, runnerOutputPath } = Parser(process.argv);
 
-await executeRunner({ runnerConfigPath, runnerOutputPath }, { cwd });
+await executeRunner({ runnerConfigPath, runnerOutputPath });

packages/plugin-eslint/src/lib/eslint-plugin.ts

@@ -41,7 +41,6 @@ export async function eslintPlugin(
     schemaType: 'ESLint plugin config',
   });
 
-  const cwd = options?.cwd || process.cwd();
   const customGroups = options
     ? parseSchema(eslintPluginOptionsSchema, options, {
         schemaType: 'ESLint plugin options',
@@ -72,8 +71,6 @@ export async function eslintPlugin(
     audits,
     groups,
 
-    runner: await createRunnerConfig(runnerScriptPath, audits, targets, {
-      cwd,
-    }),
+    runner: await createRunnerConfig(runnerScriptPath, audits, targets),
   };
 }

packages/plugin-eslint/src/lib/runner/index.ts

@@ -19,19 +19,16 @@ import type { ESLintPluginRunnerConfig, ESLintTarget } from '../config.js';
 import { lint } from './lint.js';
 import { lintResultsToAudits, mergeLinterOutputs } from './transform.js';
 
-export async function executeRunner(
-  { runnerConfigPath, runnerOutputPath }: RunnerFilesPaths,
-  opt?: { cwd?: string },
-): Promise<void> {
-  const { cwd = process.cwd() } = opt || {};
+export async function executeRunner({
+  runnerConfigPath,
+  runnerOutputPath,
+}: RunnerFilesPaths): Promise<void> {
   const { slugs, targets } =
     await readJsonFile<ESLintPluginRunnerConfig>(runnerConfigPath);
 
-  ui().logger.log(
-    `ESLint plugin executing ${targets.length} lint targets with cwd: ${cwd}`,
-  );
+  ui().logger.log(`ESLint plugin executing ${targets.length} lint targets`);
 
-  const linterOutputs = await asyncSequential(targets, cfg => lint(cfg, opt));
+  const linterOutputs = await asyncSequential(targets, lint);
   const lintResults = mergeLinterOutputs(linterOutputs);
   const failedAudits = lintResultsToAudits(lintResults);
 
@@ -54,7 +51,6 @@ export async function createRunnerConfig(
   scriptPath: string,
   audits: Audit[],
   targets: ESLintTarget[],
-  opt?: { cwd?: string },
 ): Promise<RunnerConfig> {
   const config: ESLintPluginRunnerConfig = {
     targets,
@@ -69,11 +65,7 @@ export async function createRunnerConfig(
     command: 'node',
     args: [
       filePathToCliArg(scriptPath),
-      ...objectToCliArgs({
-        runnerConfigPath,
-        runnerOutputPath,
-        ...(opt?.cwd ? { cwd: opt.cwd } : {}),
-      }),
+      ...objectToCliArgs({ runnerConfigPath, runnerOutputPath }),
     ],
     configFile: runnerConfigPath,
     outputFile: runnerOutputPath,

packages/plugin-eslint/src/lib/runner/lint.ts

@@ -1,6 +1,5 @@
 import type { ESLint, Linter } from 'eslint';
 import { platform } from 'node:os';
-import { join } from 'node:path';
 import {
   distinct,
   executeProcess,
@@ -11,21 +10,20 @@ import type { ESLintTarget } from '../config.js';
 import { setupESLint } from '../setup.js';
 import type { LinterOutput, RuleOptionsPerFile } from './types.js';
 
-export async function lint(
-  { eslintrc, patterns }: ESLintTarget,
-  opt?: { cwd?: string },
-): Promise<LinterOutput> {
-  const results = await executeLint({ eslintrc, patterns }, opt);
+export async function lint({
+  eslintrc,
+  patterns,
+}: ESLintTarget): Promise<LinterOutput> {
+  const results = await executeLint({ eslintrc, patterns });
   const eslint = await setupESLint(eslintrc);
   const ruleOptionsPerFile = await loadRuleOptionsPerFile(eslint, results);
   return { results, ruleOptionsPerFile };
 }
 
-async function executeLint(
-  { eslintrc, patterns }: ESLintTarget,
-  opt?: { cwd?: string },
-): Promise<ESLint.LintResult[]> {
-  const { cwd = process.cwd() } = opt ?? {};
+async function executeLint({
+  eslintrc,
+  patterns,
+}: ESLintTarget): Promise<ESLint.LintResult[]> {
   // running as CLI because ESLint#lintFiles() runs out of memory
   const { stdout } = await executeProcess({
     command: 'npx',
@@ -35,14 +33,13 @@ async function executeLint(
       ...(typeof eslintrc === 'object' ? ['--no-eslintrc'] : []),
       '--no-error-on-unmatched-pattern',
       '--format=json',
-      `--output-file=${join(cwd, '.eslint-results.json')}`,
       ...toArray(patterns).map(pattern =>
         // globs need to be escaped on Unix
         platform() === 'win32' ? pattern : `'${pattern}'`,
       ),
     ],
     ignoreExitCode: true,
-    cwd,
+    cwd: process.cwd(),
   });
 
   return JSON.parse(stdout) as ESLint.LintResult[];