From bf1775ded6a5ee9f68bb6e1e5c91d5e1ffbad540 Mon Sep 17 00:00:00 2001 From: Alejandro Date: Tue, 17 Dec 2024 19:03:39 +0100 Subject: [PATCH 01/39] feat(plugin-doc-coverage): add mvp version of a plugin doc coverage based on compodoc --- packages/plugin-doc-coverage/README.md | 205 ++++++++++++++++++ packages/plugin-doc-coverage/eslint.config.js | 21 ++ .../mocks/documentation.json | 11 + packages/plugin-doc-coverage/package.json | 47 ++++ packages/plugin-doc-coverage/project.json | 42 ++++ packages/plugin-doc-coverage/src/bin.ts | 3 + packages/plugin-doc-coverage/src/index.ts | 4 + .../plugin-doc-coverage/src/lib/config.ts | 25 +++ .../src/lib/config.unit.test.ts | 52 +++++ .../src/lib/doc-coverage-plugin.ts | 76 +++++++ .../src/lib/doc-coverage-plugin.unit.test.ts | 87 ++++++++ .../src/lib/runner/constants.ts | 11 + .../src/lib/runner/index.ts | 82 +++++++ .../src/lib/runner/runner.integration.test.ts | 80 +++++++ packages/plugin-doc-coverage/tsconfig.json | 23 ++ .../plugin-doc-coverage/tsconfig.lib.json | 16 ++ .../plugin-doc-coverage/tsconfig.test.json | 13 ++ .../vite.config.integration.ts | 29 +++ .../plugin-doc-coverage/vite.config.unit.ts | 31 +++ 19 files changed, 858 insertions(+) create mode 100644 packages/plugin-doc-coverage/README.md create mode 100644 packages/plugin-doc-coverage/eslint.config.js create mode 100644 packages/plugin-doc-coverage/mocks/documentation.json create mode 100644 packages/plugin-doc-coverage/package.json create mode 100644 packages/plugin-doc-coverage/project.json create mode 100644 packages/plugin-doc-coverage/src/bin.ts create mode 100644 packages/plugin-doc-coverage/src/index.ts create mode 100644 packages/plugin-doc-coverage/src/lib/config.ts create mode 100644 packages/plugin-doc-coverage/src/lib/config.unit.test.ts create mode 100644 packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts create mode 100644 packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts create mode 100644 packages/plugin-doc-coverage/src/lib/runner/constants.ts create mode 100644 packages/plugin-doc-coverage/src/lib/runner/index.ts create mode 100644 packages/plugin-doc-coverage/src/lib/runner/runner.integration.test.ts create mode 100644 packages/plugin-doc-coverage/tsconfig.json create mode 100644 packages/plugin-doc-coverage/tsconfig.lib.json create mode 100644 packages/plugin-doc-coverage/tsconfig.test.json create mode 100644 packages/plugin-doc-coverage/vite.config.integration.ts create mode 100644 packages/plugin-doc-coverage/vite.config.unit.ts diff --git a/packages/plugin-doc-coverage/README.md b/packages/plugin-doc-coverage/README.md new file mode 100644 index 000000000..0b4fb33e6 --- /dev/null +++ b/packages/plugin-doc-coverage/README.md @@ -0,0 +1,205 @@ +# @code-pushup/doc-coverage-plugin + +[![npm](https://img.shields.io/npm/v/%40code-pushup%2Fdoc-coverage-plugin.svg)](https://www.npmjs.com/package/@code-pushup/doc-coverage-plugin) +[![downloads](https://img.shields.io/npm/dm/%40code-pushup%2Fdoc-coverage-plugin)](https://npmtrends.com/@code-pushup/doc-coverage-plugin) +[![dependencies](https://img.shields.io/librariesio/release/npm/%40code-pushup%2Fdoc-coverage-plugin)](https://www.npmjs.com/package/@code-pushup/doc-coverage-plugin?activeTab=dependencies) + +📚 **Code PushUp plugin for tracking documentation coverage.** 📝 + +This plugin allows you to measure and track documentation coverage in your TypeScript/JavaScript project. +It analyzes your codebase and checks for documentation on different code elements like classes, functions, interfaces, types, and variables. + +Measured documentation types are mapped to Code PushUp audits in the following way: + +- The value is in range 0-100 and represents the documentation coverage for all passed results (_documented / total_) +- The score is value converted to 0-1 range +- Missing documentation is mapped to issues in the audit details (undocumented classes, functions, interfaces, etc.) + +## Getting started + +1. If you haven't already, install [@code-pushup/cli](../cli/README.md) and create a configuration file. + +2. Install as a dev dependency with your package manager: + + ```sh + npm install --save-dev @code-pushup/doc-coverage-plugin + ``` + + ```sh + yarn add --dev @code-pushup/doc-coverage-plugin + ``` + + ```sh + pnpm add --save-dev @code-pushup/doc-coverage-plugin + ``` + +3. Add Compodoc to your project. You can follow the instructions [here](https://compodoc.app/guides/installation.html). + +4. Add this plugin to the `plugins` array in your Code PushUp CLI config file (e.g. `code-pushup.config.js`). + + Pass the target files to analyze and optionally specify which types of documentation you want to track. + All documentation types are measured by default. If you wish to focus on a subset of offered types, define them in `docTypes`. + + The configuration will look similarly to the following: + + ```js + import docCoveragePlugin from '@code-pushup/doc-coverage-plugin'; + + export default { + // ... + plugins: [ + // ... + await docCoveragePlugin({ + coverageToolCommand: { + command: 'npx', + args: ['compodoc', '-p', 'tsconfig.doc.json', '-e', 'json'], + }, + }), + ], + }; + ``` + +5. (Optional) Reference individual audits or the provided plugin group which you wish to include in custom categories (use `npx code-pushup print-config` to list audits and groups). + + 💡 Assign weights based on what influence each documentation type should have on the overall category score (assign weight 0 to only include as extra info, without influencing category score). + + ```js + export default { + // ... + categories: [ + { + slug: 'documentation', + title: 'Documentation', + refs: [ + { + type: 'group', + plugin: 'doc-coverage', + slug: 'doc-coverage', + weight: 1, + }, + // ... + ], + }, + // ... + ], + }; + ``` + +6. Run the CLI with `npx code-pushup collect` and view or upload report (refer to [CLI docs](../cli/README.md)). + +## About documentation coverage + +Documentation coverage is a metric that indicates what percentage of your code elements have proper documentation. It helps ensure your codebase is well-documented and maintainable. + +The plugin provides a single audit that measures the overall percentage of documentation coverage across your codebase: + +- **Percentage coverage**: Measures how many percent of the codebase have documentation. + +## Plugin architecture + +### Plugin configuration specification + +The plugin accepts the following parameters: + +- (optional) `coverageToolCommand`: If you wish to run your documentation coverage tool (compodoc) to generate the results first, you may define it here. + - `command`: Command to run coverage tool (e.g. `npx`). + - `args`: Arguments to be passed to the coverage tool (e.g. `['compodoc', '-p', 'tsconfig.doc.json', '-e', 'json']`). +- `outputPath`: Path to the documentation.json file. Defaults to `'documentation/documentation.json'`. + +### Audits and group + +This plugin provides a group for convenient declaration in your config. When defined this way, all measured documentation type audits have the same weight. + +```ts + // ... + categories: [ + { + slug: 'documentation', + title: 'Documentation', + refs: [ + { + type: 'group', + plugin: 'doc-coverage', + slug: 'doc-coverage', + weight: 1, + }, + // ... + ], + }, + // ... + ], +``` + +Each documentation type still has its own audit. So when you want to include a subset of documentation types or assign different weights to them, you can do so in the following way: + +```ts + // ... + categories: [ + { + slug: 'documentation', + title: 'Documentation', + refs: [ + { + type: 'audit', + plugin: 'doc-coverage', + slug: 'class-doc-coverage', + weight: 2, + }, + { + type: 'audit', + plugin: 'doc-coverage', + slug: 'function-doc-coverage', + weight: 1, + }, + // ... + ], + }, + // ... + ], +``` + +### Audit output + +The plugin outputs a single audit that measures the overall documentation coverage percentage of your codebase. + +For instance, this is an example of the plugin output: + +```json +{ + "packageName": "@code-pushup/doc-coverage-plugin", + "version": "0.57.0", + "title": "Documentation coverage", + "slug": "doc-coverage", + "icon": "folder-src", + "duration": 920, + "date": "2024-12-17T16:45:28.581Z", + "audits": [ + { + "slug": "percentage-coverage", + "displayValue": "16 %", + "value": 16, + "score": 0.16, + "details": { + "issues": [] + }, + "title": "Percentage of codebase with documentation", + "description": "Measures how many % of the codebase have documentation." + } + ], + "description": "Official Code PushUp documentation coverage plugin.", + "docsUrl": "https://www.npmjs.com/package/@code-pushup/doc-coverage-plugin/", + "groups": [ + { + "slug": "doc-coverage", + "refs": [ + { + "slug": "percentage-coverage", + "weight": 1 + } + ], + "title": "Documentation coverage metrics", + "description": "Group containing all defined documentation coverage types as audits." + } + ] +} +``` diff --git a/packages/plugin-doc-coverage/eslint.config.js b/packages/plugin-doc-coverage/eslint.config.js new file mode 100644 index 000000000..40165321a --- /dev/null +++ b/packages/plugin-doc-coverage/eslint.config.js @@ -0,0 +1,21 @@ +import tseslint from 'typescript-eslint'; +import baseConfig from '../../eslint.config.js'; + +export default tseslint.config( + ...baseConfig, + { + files: ['**/*.ts'], + languageOptions: { + parserOptions: { + projectService: true, + tsconfigRootDir: import.meta.dirname, + }, + }, + }, + { + files: ['**/*.json'], + rules: { + '@nx/dependency-checks': 'error', + }, + }, +); diff --git a/packages/plugin-doc-coverage/mocks/documentation.json b/packages/plugin-doc-coverage/mocks/documentation.json new file mode 100644 index 000000000..7a608253c --- /dev/null +++ b/packages/plugin-doc-coverage/mocks/documentation.json @@ -0,0 +1,11 @@ +{ + "coverage": { + "count": 85, + "files": { + "src/app/services/my.service.ts": { + "documented": 17, + "total": 20 + } + } + } +} diff --git a/packages/plugin-doc-coverage/package.json b/packages/plugin-doc-coverage/package.json new file mode 100644 index 000000000..1c2ebe241 --- /dev/null +++ b/packages/plugin-doc-coverage/package.json @@ -0,0 +1,47 @@ +{ + "name": "@code-pushup/doc-coverage-plugin", + "version": "0.57.0", + "description": "Code PushUp plugin for tracking documentation coverage 📚", + "license": "MIT", + "homepage": "https://github.com/code-pushup/cli/tree/main/packages/plugin-doc-coverage#readme", + "bugs": { + "url": "https://github.com/code-pushup/cli/issues?q=is%3Aissue%20state%3Aopen%20type%3ABug%20label%3A\"🧩%20doc-coverage-plugin\"" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/code-pushup/cli.git", + "directory": "packages/plugin-doc-coverage" + }, + "keywords": [ + "CLI", + "Code PushUp", + "plugin", + "automation", + "developer tools", + "conformance", + "documentation coverage", + "documentation", + "docs", + "KPI tracking", + "automated feedback", + "regression guard", + "actionable feedback", + "audit", + "score monitoring" + ], + "publishConfig": { + "access": "public" + }, + "type": "module", + "dependencies": { + "@code-pushup/models": "0.57.0", + "@code-pushup/utils": "0.57.0", + "ansis": "^3.3.0", + "zod": "^3.22.4" + }, + "peerDependenciesMeta": { + "@nx/devkit": { + "optional": true + } + } +} diff --git a/packages/plugin-doc-coverage/project.json b/packages/plugin-doc-coverage/project.json new file mode 100644 index 000000000..ea971b133 --- /dev/null +++ b/packages/plugin-doc-coverage/project.json @@ -0,0 +1,42 @@ +{ + "name": "plugin-doc-coverage", + "$schema": "../../node_modules/nx/schemas/project-schema.json", + "sourceRoot": "packages/plugin-doc-coverage/src", + "projectType": "library", + "targets": { + "build": { + "executor": "@nx/js:tsc", + "outputs": ["{options.outputPath}"], + "options": { + "outputPath": "dist/packages/plugin-doc-coverage", + "main": "packages/plugin-doc-coverage/src/index.ts", + "tsConfig": "packages/plugin-doc-coverage/tsconfig.lib.json", + "additionalEntryPoints": ["packages/plugin-doc-coverage/src/bin.ts"], + "assets": ["packages/plugin-doc-coverage/*.md"] + } + }, + "lint": { + "executor": "@nx/linter:eslint", + "outputs": ["{options.outputFile}"], + "options": { + "lintFilePatterns": [ + "packages/plugin-doc-coverage/**/*.ts", + "packages/plugin-doc-coverage/package.json" + ] + } + }, + "unit-test": { + "executor": "@nx/vite:test", + "options": { + "configFile": "packages/plugin-doc-coverage/vite.config.unit.ts" + } + }, + "integration-test": { + "executor": "@nx/vite:test", + "options": { + "configFile": "packages/plugin-doc-coverage/vite.config.integration.ts" + } + } + }, + "tags": ["scope:plugin", "type:feature", "publishable"] +} diff --git a/packages/plugin-doc-coverage/src/bin.ts b/packages/plugin-doc-coverage/src/bin.ts new file mode 100644 index 000000000..bf6572a76 --- /dev/null +++ b/packages/plugin-doc-coverage/src/bin.ts @@ -0,0 +1,3 @@ +import { executeRunner } from './lib/runner/index.js'; + +await executeRunner(); diff --git a/packages/plugin-doc-coverage/src/index.ts b/packages/plugin-doc-coverage/src/index.ts new file mode 100644 index 000000000..d26f57375 --- /dev/null +++ b/packages/plugin-doc-coverage/src/index.ts @@ -0,0 +1,4 @@ +import { docCoveragePlugin } from './lib/doc-coverage-plugin.js'; + +export default docCoveragePlugin; +export type { DocCoveragePluginConfig } from './lib/config.js'; diff --git a/packages/plugin-doc-coverage/src/lib/config.ts b/packages/plugin-doc-coverage/src/lib/config.ts new file mode 100644 index 000000000..139f2d77a --- /dev/null +++ b/packages/plugin-doc-coverage/src/lib/config.ts @@ -0,0 +1,25 @@ +import { z } from 'zod'; + +export type DocType = 'percentage-coverage'; + +export const docCoveragePluginConfigSchema = z.object({ + coverageToolCommand: z + .object({ + command: z + .string({ description: 'Command to run coverage tool (compodoc).' }) + .min(1), + args: z + .array(z.string(), { + description: 'Arguments to be passed to the coverage tool.', + }) + .optional(), + }) + .optional(), + outputPath: z + .string({ description: 'Path to the documentation.json file.' }) + .default('documentation/documentation.json'), +}); + +export type DocCoveragePluginConfig = z.infer< + typeof docCoveragePluginConfigSchema +>; diff --git a/packages/plugin-doc-coverage/src/lib/config.unit.test.ts b/packages/plugin-doc-coverage/src/lib/config.unit.test.ts new file mode 100644 index 000000000..3964fa186 --- /dev/null +++ b/packages/plugin-doc-coverage/src/lib/config.unit.test.ts @@ -0,0 +1,52 @@ +import { describe, expect, it } from 'vitest'; +import { + type DocCoveragePluginConfig, + docCoveragePluginConfigSchema, +} from './config.js'; + +describe('docCoveragePluginConfigSchema', () => { + it('accepts a documentation coverage configuration with all entities', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + coverageToolCommand: { + command: 'npx @compodoc/compodoc', + args: ['-p', 'tsconfig.json'], + }, + outputPath: 'documentation/custom-doc.json', + } satisfies DocCoveragePluginConfig), + ).not.toThrow(); + }); + + it('accepts a minimal documentation coverage configuration', () => { + expect(() => + docCoveragePluginConfigSchema.parse({} satisfies DocCoveragePluginConfig), + ).not.toThrow(); + }); + + it('uses default output path when not provided', () => { + const config = {} satisfies DocCoveragePluginConfig; + const parsed = docCoveragePluginConfigSchema.parse(config); + + expect(parsed.outputPath).toBe('documentation/documentation.json'); + }); + + it('throws for missing command in coverageToolCommand', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + coverageToolCommand: { + args: ['-p', 'tsconfig.json'], + }, + }), + ).toThrow('invalid_type'); + }); + + it('accepts empty args in coverageToolCommand', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + coverageToolCommand: { + command: 'npx @compodoc/compodoc', + }, + } satisfies DocCoveragePluginConfig), + ).not.toThrow(); + }); +}); diff --git a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts new file mode 100644 index 000000000..0519eed82 --- /dev/null +++ b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts @@ -0,0 +1,76 @@ +import { createRequire } from 'node:module'; +import path from 'node:path'; +import { fileURLToPath } from 'node:url'; +import type { Group, PluginConfig } from '@code-pushup/models'; +import { + type DocCoveragePluginConfig, + docCoveragePluginConfigSchema, +} from './config.js'; +import { createRunnerConfig } from './runner/index.js'; + +/** + * Instantiates Code PushUp documentation coverage plugin for core config. + * + * @example + * import docCoveragePlugin from '@code-pushup/doc-coverage-plugin' + * + * export default { + * // ... core config ... + * plugins: [ + * // ... other plugins ... + * await docCoveragePlugin({ + * + * docTypes: ['class', 'function'] + * }) + * ] + * } + * + * @returns Plugin configuration. + */ +export async function docCoveragePlugin( + config: DocCoveragePluginConfig, +): Promise { + const docCoverageConfig = docCoveragePluginConfigSchema.parse(config); + + const audits = [ + { + slug: 'percentage-coverage', + title: 'Percentage of codebase with documentation', + description: 'Measures how many % of the codebase have documentation.', + }, + ]; + + const group: Group = { + slug: 'doc-coverage', + title: 'Documentation coverage metrics', + description: + 'Group containing all defined documentation coverage types as audits.', + refs: audits.map(audit => ({ + ...audit, + weight: 1, + })), + }; + + const runnerScriptPath = path.join( + fileURLToPath(path.dirname(import.meta.url)), + '..', + 'bin.js', + ); + + const packageJson = createRequire(import.meta.url)( + '../../package.json', + ) as typeof import('../../package.json'); + + return { + slug: 'doc-coverage', + title: 'Documentation coverage', + icon: 'folder-src', + description: 'Official Code PushUp documentation coverage plugin.', + docsUrl: 'https://www.npmjs.com/package/@code-pushup/doc-coverage-plugin/', + packageName: packageJson.name, + version: packageJson.version, + audits, + groups: [group], + runner: await createRunnerConfig(runnerScriptPath, docCoverageConfig), + }; +} diff --git a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts new file mode 100644 index 000000000..fbb2c452a --- /dev/null +++ b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts @@ -0,0 +1,87 @@ +import { describe, expect, it } from 'vitest'; +import type { RunnerConfig } from '@code-pushup/models'; +import { docCoveragePlugin } from './doc-coverage-plugin.js'; + +vi.mock('./runner/index.ts', () => ({ + createRunnerConfig: vi.fn().mockReturnValue({ + command: 'node', + outputFile: 'runner-output.json', + } satisfies RunnerConfig), +})); + +describe('docCoveragePlugin', () => { + it('should initialise a Documentation coverage plugin', async () => { + await expect( + docCoveragePlugin({ + outputPath: 'documentation/documentation.json', + }), + ).resolves.toStrictEqual( + expect.objectContaining({ + slug: 'doc-coverage', + title: 'Documentation coverage', + audits: expect.any(Array), + groups: expect.any(Array), + runner: expect.any(Object), + }), + ); + }); + + it('should generate percentage coverage audit', async () => { + await expect( + docCoveragePlugin({ + outputPath: 'documentation/documentation.json', + }), + ).resolves.toStrictEqual( + expect.objectContaining({ + audits: [ + { + slug: 'percentage-coverage', + title: 'Percentage of codebase with documentation', + description: expect.stringContaining( + 'how many % of the codebase have documentation', + ), + }, + ], + }), + ); + }); + + it('should provide a documentation coverage group', async () => { + await expect( + docCoveragePlugin({ + outputPath: 'documentation/documentation.json', + }), + ).resolves.toStrictEqual( + expect.objectContaining({ + groups: [ + expect.objectContaining({ + slug: 'doc-coverage', + title: 'Documentation coverage metrics', + refs: [ + expect.objectContaining({ + slug: 'percentage-coverage', + weight: 1, + }), + ], + }), + ], + }), + ); + }); + + it('should include package metadata', async () => { + await expect( + docCoveragePlugin({ + outputPath: 'documentation/documentation.json', + }), + ).resolves.toStrictEqual( + expect.objectContaining({ + icon: 'folder-src', + description: expect.stringContaining('documentation coverage plugin'), + docsUrl: expect.stringContaining('npmjs.com'), + packageName: expect.any(String), + version: expect.any(String), + }), + ); + }); +}); diff --git a/packages/plugin-doc-coverage/src/lib/runner/constants.ts b/packages/plugin-doc-coverage/src/lib/runner/constants.ts new file mode 100644 index 000000000..8b9843ee6 --- /dev/null +++ b/packages/plugin-doc-coverage/src/lib/runner/constants.ts @@ -0,0 +1,11 @@ +import path from 'node:path'; +import { pluginWorkDir } from '@code-pushup/utils'; + +export const WORKDIR = pluginWorkDir('doc-coverage'); + +export const PLUGIN_CONFIG_PATH = path.join( + process.cwd(), + WORKDIR, + 'plugin-config.json', +); +export const RUNNER_OUTPUT_PATH = path.join(WORKDIR, 'runner-output.json'); diff --git a/packages/plugin-doc-coverage/src/lib/runner/index.ts b/packages/plugin-doc-coverage/src/lib/runner/index.ts new file mode 100644 index 000000000..638777aaa --- /dev/null +++ b/packages/plugin-doc-coverage/src/lib/runner/index.ts @@ -0,0 +1,82 @@ +import { bold } from 'ansis'; +import { writeFile } from 'node:fs/promises'; +import path from 'node:path'; +import type { AuditOutput, RunnerConfig } from '@code-pushup/models'; +import { + ProcessError, + ensureDirectoryExists, + executeProcess, + filePathToCliArg, + readJsonFile, + ui, +} from '@code-pushup/utils'; +import type { DocCoveragePluginConfig } from '../config.js'; +import { PLUGIN_CONFIG_PATH, RUNNER_OUTPUT_PATH } from './constants.js'; + +export { PLUGIN_CONFIG_PATH, RUNNER_OUTPUT_PATH } from './constants.js'; + +export async function executeRunner(): Promise { + const { outputPath, coverageToolCommand } = + await readJsonFile(PLUGIN_CONFIG_PATH); + if (coverageToolCommand != null) { + const { command, args = [] } = coverageToolCommand; + try { + await executeProcess({ command, args }); + } catch (error) { + if (error instanceof ProcessError) { + ui().logger.error(bold('stdout from failed Compodoc process:')); + ui().logger.error(error.stdout); + ui().logger.error(bold('stderr from failed Compodoc process:')); + ui().logger.error(error.stderr); + } + throw new Error( + 'Doc Coverage plugin: Running Compodoc failed. Please check the error above.', + ); + } + } + + try { + // From the output of Compodoc, we can get the coverage percentage. + const docData: { coverage: { count: number } } = + await readJsonFile(outputPath); + const coverage = docData.coverage.count || 0; + + const auditOutputs: AuditOutput[] = [ + { + slug: 'percentage-coverage', + value: coverage, + score: coverage / 100, + displayValue: `${coverage} %`, + }, + ]; + + await ensureDirectoryExists(path.dirname(RUNNER_OUTPUT_PATH)); + await writeFile(RUNNER_OUTPUT_PATH, JSON.stringify(auditOutputs)); + } catch (error) { + if (error instanceof ProcessError) { + ui().logger.error(bold('stdout from failed coverage tool process:')); + ui().logger.error(error.stdout); + ui().logger.error(bold('stderr from failed coverage tool process:')); + ui().logger.error(error.stderr); + + throw new Error( + 'Doc Coverage plugin: Running Compodoc failed. Please check the error above.', + ); + } + } +} + +export async function createRunnerConfig( + scriptPath: string, + config: DocCoveragePluginConfig, +): Promise { + // Create JSON config for executeRunner + await ensureDirectoryExists(path.dirname(PLUGIN_CONFIG_PATH)); + await writeFile(PLUGIN_CONFIG_PATH, JSON.stringify(config)); + + return { + command: 'node', + args: [filePathToCliArg(scriptPath)], + outputFile: RUNNER_OUTPUT_PATH, + }; +} diff --git a/packages/plugin-doc-coverage/src/lib/runner/runner.integration.test.ts b/packages/plugin-doc-coverage/src/lib/runner/runner.integration.test.ts new file mode 100644 index 000000000..f67e5791c --- /dev/null +++ b/packages/plugin-doc-coverage/src/lib/runner/runner.integration.test.ts @@ -0,0 +1,80 @@ +import { writeFile } from 'node:fs/promises'; +import path from 'node:path'; +import { fileURLToPath } from 'node:url'; +import { describe, it } from 'vitest'; +import type { + AuditOutput, + AuditOutputs, + RunnerConfig, +} from '@code-pushup/models'; +import { readJsonFile, removeDirectoryIfExists } from '@code-pushup/utils'; +import type { DocCoveragePluginConfig } from '../config.js'; +import { + PLUGIN_CONFIG_PATH, + RUNNER_OUTPUT_PATH, + WORKDIR, +} from './constants.js'; +import { createRunnerConfig, executeRunner } from './index.js'; + +describe('createRunnerConfig', () => { + it('should create a valid runner config', async () => { + const runnerConfig = await createRunnerConfig('executeRunner.ts', { + coverageToolCommand: { + command: 'npx', + args: ['@compodoc/compodoc', '-p', 'tsconfig.json'], + }, + outputPath: 'documentation/documentation.json', + }); + expect(runnerConfig).toStrictEqual({ + command: 'node', + args: ['"executeRunner.ts"'], + outputFile: expect.stringContaining('runner-output.json'), + }); + }); + + it('should provide plugin config to runner in JSON file', async () => { + await removeDirectoryIfExists(WORKDIR); + + const pluginConfig: DocCoveragePluginConfig = { + coverageToolCommand: { + command: 'npx', + args: ['@compodoc/compodoc', '-p', 'tsconfig.json'], + }, + outputPath: 'documentation/documentation.json', + }; + + await createRunnerConfig('executeRunner.ts', pluginConfig); + + const config = + await readJsonFile(PLUGIN_CONFIG_PATH); + expect(config).toStrictEqual(pluginConfig); + }); +}); + +describe('executeRunner', () => { + it('should successfully execute runner', async () => { + const config: DocCoveragePluginConfig = { + outputPath: path.join( + fileURLToPath(path.dirname(import.meta.url)), + '..', + '..', + '..', + 'mocks', + 'documentation.json', + ), + }; + + await writeFile(PLUGIN_CONFIG_PATH, JSON.stringify(config)); + await executeRunner(); + + const results = await readJsonFile(RUNNER_OUTPUT_PATH); + expect(results).toStrictEqual([ + expect.objectContaining({ + slug: 'percentage-coverage', + score: 0.85, + value: 85, + displayValue: '85 %', + } satisfies AuditOutput), + ]); + }); +}); diff --git a/packages/plugin-doc-coverage/tsconfig.json b/packages/plugin-doc-coverage/tsconfig.json new file mode 100644 index 000000000..893f9a925 --- /dev/null +++ b/packages/plugin-doc-coverage/tsconfig.json @@ -0,0 +1,23 @@ +{ + "extends": "../../tsconfig.base.json", + "compilerOptions": { + "module": "ESNext", + "forceConsistentCasingInFileNames": true, + "strict": true, + "noImplicitOverride": true, + "noPropertyAccessFromIndexSignature": true, + "noImplicitReturns": true, + "noFallthroughCasesInSwitch": true, + "types": ["vitest"] + }, + "files": [], + "include": [], + "references": [ + { + "path": "./tsconfig.lib.json" + }, + { + "path": "./tsconfig.test.json" + } + ] +} diff --git a/packages/plugin-doc-coverage/tsconfig.lib.json b/packages/plugin-doc-coverage/tsconfig.lib.json new file mode 100644 index 000000000..ef2f7e2b3 --- /dev/null +++ b/packages/plugin-doc-coverage/tsconfig.lib.json @@ -0,0 +1,16 @@ +{ + "extends": "./tsconfig.json", + "compilerOptions": { + "outDir": "../../dist/out-tsc", + "declaration": true, + "types": ["node"] + }, + "include": ["src/**/*.ts"], + "exclude": [ + "vite.config.unit.ts", + "vite.config.integration.ts", + "src/**/*.test.ts", + "src/**/*.mock.ts", + "mocks/**/*.ts" + ] +} diff --git a/packages/plugin-doc-coverage/tsconfig.test.json b/packages/plugin-doc-coverage/tsconfig.test.json new file mode 100644 index 000000000..9f29d6bb0 --- /dev/null +++ b/packages/plugin-doc-coverage/tsconfig.test.json @@ -0,0 +1,13 @@ +{ + "extends": "./tsconfig.json", + "compilerOptions": { + "outDir": "../../dist/out-tsc", + "types": ["vitest/globals", "vitest/importMeta", "vite/client", "node"] + }, + "include": [ + "vite.config.unit.ts", + "vite.config.integration.ts", + "mocks/**/*.ts", + "src/**/*.test.ts" + ] +} diff --git a/packages/plugin-doc-coverage/vite.config.integration.ts b/packages/plugin-doc-coverage/vite.config.integration.ts new file mode 100644 index 000000000..b04d62c56 --- /dev/null +++ b/packages/plugin-doc-coverage/vite.config.integration.ts @@ -0,0 +1,29 @@ +/// +import { defineConfig } from 'vite'; +import { tsconfigPathAliases } from '../../tools/vitest-tsconfig-path-aliases.js'; + +export default defineConfig({ + cacheDir: '../../node_modules/.vite/plugin-coverage', + test: { + reporters: ['basic'], + globals: true, + cache: { + dir: '../../node_modules/.vitest', + }, + alias: tsconfigPathAliases(), + pool: 'threads', + poolOptions: { threads: { singleThread: true } }, + coverage: { + reporter: ['text', 'lcov'], + reportsDirectory: '../../coverage/plugin-doc-coverage/integration-tests', + exclude: ['mocks/**', '**/types.ts'], + }, + environment: 'node', + include: ['src/**/*.integration.test.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'], + globalSetup: ['../../global-setup.ts'], + setupFiles: [ + '../../testing/test-setup/src/lib/console.mock.ts', + '../../testing/test-setup/src/lib/reset.mocks.ts', + ], + }, +}); diff --git a/packages/plugin-doc-coverage/vite.config.unit.ts b/packages/plugin-doc-coverage/vite.config.unit.ts new file mode 100644 index 000000000..3cae73a58 --- /dev/null +++ b/packages/plugin-doc-coverage/vite.config.unit.ts @@ -0,0 +1,31 @@ +/// +import { defineConfig } from 'vite'; +import { tsconfigPathAliases } from '../../tools/vitest-tsconfig-path-aliases.js'; + +export default defineConfig({ + cacheDir: '../../node_modules/.vite/plugin-coverage', + test: { + reporters: ['basic'], + globals: true, + cache: { + dir: '../../node_modules/.vitest', + }, + alias: tsconfigPathAliases(), + pool: 'threads', + poolOptions: { threads: { singleThread: true } }, + coverage: { + reporter: ['text', 'lcov'], + reportsDirectory: '../../coverage/plugin-doc-coverage/unit-tests', + exclude: ['mocks/**', '**/types.ts'], + }, + environment: 'node', + include: ['src/**/*.unit.test.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'], + globalSetup: ['../../global-setup.ts'], + setupFiles: [ + '../../testing/test-setup/src/lib/cliui.mock.ts', + '../../testing/test-setup/src/lib/fs.mock.ts', + '../../testing/test-setup/src/lib/console.mock.ts', + '../../testing/test-setup/src/lib/reset.mocks.ts', + ], + }, +}); From b07eb8abc972d14aaa24915d7de41da3f39812cc Mon Sep 17 00:00:00 2001 From: Alejandro Date: Tue, 17 Dec 2024 22:49:48 +0100 Subject: [PATCH 02/39] feat: change from compodoc to typedoc --- package-lock.json | 162 ++++++++++++++++++ package.json | 2 + .../mocks/component-mock.ts | 4 + .../plugin-doc-coverage/src/lib/config.ts | 26 ++- .../src/lib/config.unit.test.ts | 50 ++++-- .../src/lib/doc-coverage-plugin.ts | 3 +- .../src/lib/doc-coverage-plugin.unit.test.ts | 8 +- .../src/lib/runner/constants.ts | 33 +++- .../src/lib/runner/index.ts | 93 +++++++--- .../src/lib/runner/runner.integration.test.ts | 62 +++---- .../plugin-doc-coverage/tsconfig.test.json | 3 +- 11 files changed, 346 insertions(+), 100 deletions(-) create mode 100644 packages/plugin-doc-coverage/mocks/component-mock.ts diff --git a/package-lock.json b/package-lock.json index 0459e1180..9138feee2 100644 --- a/package-lock.json +++ b/package-lock.json @@ -97,6 +97,8 @@ "tsconfig-paths": "^4.2.0", "tsx": "^4.19.0", "type-fest": "^4.26.1", + "typedoc": "^0.27.5", + "typedoc-plugin-coverage": "^3.4.0", "typescript": "5.5.4", "typescript-eslint": "^8.18.0", "verdaccio": "^5.32.2", @@ -3233,6 +3235,17 @@ "tslib": "^2.4.0" } }, + "node_modules/@gerrit0/mini-shiki": { + "version": "1.24.4", + "resolved": "https://registry.npmjs.org/@gerrit0/mini-shiki/-/mini-shiki-1.24.4.tgz", + "integrity": "sha512-YEHW1QeAg6UmxEmswiQbOVEg1CW22b1XUD/lNTliOsu0LD0wqoyleFMnmbTp697QE0pcadQiR5cVtbbAPncvpw==", + "dev": true, + "dependencies": { + "@shikijs/engine-oniguruma": "^1.24.2", + "@shikijs/types": "^1.24.2", + "@shikijs/vscode-textmate": "^9.3.1" + } + }, "node_modules/@graphql-typed-document-node/core": { "version": "3.2.0", "resolved": "https://registry.npmjs.org/@graphql-typed-document-node/core/-/core-3.2.0.tgz", @@ -6159,6 +6172,32 @@ "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz", "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==" }, + "node_modules/@shikijs/engine-oniguruma": { + "version": "1.24.2", + "resolved": "https://registry.npmjs.org/@shikijs/engine-oniguruma/-/engine-oniguruma-1.24.2.tgz", + "integrity": "sha512-ZN6k//aDNWRJs1uKB12pturKHh7GejKugowOFGAuG7TxDRLod1Bd5JhpOikOiFqPmKjKEPtEA6mRCf7q3ulDyQ==", + "dev": true, + "dependencies": { + "@shikijs/types": "1.24.2", + "@shikijs/vscode-textmate": "^9.3.0" + } + }, + "node_modules/@shikijs/types": { + "version": "1.24.2", + "resolved": "https://registry.npmjs.org/@shikijs/types/-/types-1.24.2.tgz", + "integrity": "sha512-bdeWZiDtajGLG9BudI0AHet0b6e7FbR0EsE4jpGaI0YwHm/XJunI9+3uZnzFtX65gsyJ6ngCIWUfA4NWRPnBkQ==", + "dev": true, + "dependencies": { + "@shikijs/vscode-textmate": "^9.3.0", + "@types/hast": "^3.0.4" + } + }, + "node_modules/@shikijs/vscode-textmate": { + "version": "9.3.1", + "resolved": "https://registry.npmjs.org/@shikijs/vscode-textmate/-/vscode-textmate-9.3.1.tgz", + "integrity": "sha512-79QfK1393x9Ho60QFyLti+QfdJzRQCVLFb97kOIV7Eo9vQU/roINgk7m24uv0a7AUvN//RDH36FLjjK48v0s9g==", + "dev": true + }, "node_modules/@sinclair/typebox": { "version": "0.27.8", "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.27.8.tgz", @@ -7296,6 +7335,15 @@ "@types/node": "*" } }, + "node_modules/@types/hast": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/hast/-/hast-3.0.4.tgz", + "integrity": "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==", + "dev": true, + "dependencies": { + "@types/unist": "*" + } + }, "node_modules/@types/http-cache-semantics": { "version": "4.0.4", "resolved": "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.0.4.tgz", @@ -7427,6 +7475,12 @@ "integrity": "sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw==", "dev": true }, + "node_modules/@types/unist": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz", + "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==", + "dev": true + }, "node_modules/@types/yargs": { "version": "17.0.33", "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-17.0.33.tgz", @@ -19654,6 +19708,15 @@ "node": "^12.20.0 || ^14.13.1 || >=16.0.0" } }, + "node_modules/linkify-it": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/linkify-it/-/linkify-it-5.0.0.tgz", + "integrity": "sha512-5aHCbzQRADcdP+ATqnDuhhJ/MRIqDkZX5pyjFHRRysS8vZ5AbqGEoFIb6pYHPZ+L/OC2Lc+xT8uHVVR5CAK/wQ==", + "dev": true, + "dependencies": { + "uc.micro": "^2.0.0" + } + }, "node_modules/load-tsconfig": { "version": "0.2.5", "resolved": "https://registry.npmjs.org/load-tsconfig/-/load-tsconfig-0.2.5.tgz", @@ -20146,6 +20209,12 @@ "yallist": "^3.0.2" } }, + "node_modules/lunr": { + "version": "2.3.9", + "resolved": "https://registry.npmjs.org/lunr/-/lunr-2.3.9.tgz", + "integrity": "sha512-zTU3DaZaF3Rt9rhN3uBMGQD3dD2/vFQqnvZCDv4dl5iOzq2IZQqTxu90r4E5J+nP70J3ilqVCrbho2eWaeW8Ow==", + "dev": true + }, "node_modules/luxon": { "version": "3.5.0", "resolved": "https://registry.npmjs.org/luxon/-/luxon-3.5.0.tgz", @@ -20214,6 +20283,29 @@ "tmpl": "1.0.5" } }, + "node_modules/markdown-it": { + "version": "14.1.0", + "resolved": "https://registry.npmjs.org/markdown-it/-/markdown-it-14.1.0.tgz", + "integrity": "sha512-a54IwgWPaeBCAAsv13YgmALOF1elABB08FxO9i+r4VFk5Vl4pKokRPeX8u5TCgSsPi6ec1otfLjdOpVcgbpshg==", + "dev": true, + "dependencies": { + "argparse": "^2.0.1", + "entities": "^4.4.0", + "linkify-it": "^5.0.0", + "mdurl": "^2.0.0", + "punycode.js": "^2.3.1", + "uc.micro": "^2.1.0" + }, + "bin": { + "markdown-it": "bin/markdown-it.mjs" + } + }, + "node_modules/markdown-it/node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "dev": true + }, "node_modules/marky": { "version": "1.2.5", "resolved": "https://registry.npmjs.org/marky/-/marky-1.2.5.tgz", @@ -20234,6 +20326,12 @@ "integrity": "sha512-GaqWWShW4kv/G9IEucWScBx9G1/vsFZZJUO+tD26M8J8z3Kw5RDQjaoZe03YAClgeS/SWPOcb4nkFBTEi5DUEA==", "dev": true }, + "node_modules/mdurl": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/mdurl/-/mdurl-2.0.0.tgz", + "integrity": "sha512-Lf+9+2r+Tdp5wXDXC4PcIBjTDtq4UKjCPMQhKIuzpJNW0b96kVqSwW0bT7FhRSfmAiFYgP+SCRvdrDozfh0U5w==", + "dev": true + }, "node_modules/media-typer": { "version": "0.3.0", "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz", @@ -22243,6 +22341,15 @@ "node": ">=6" } }, + "node_modules/punycode.js": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/punycode.js/-/punycode.js-2.3.1.tgz", + "integrity": "sha512-uxFIHU0YlHYhDQtV4R9J6a52SLx28BCjT+4ieh7IGbgwVJWO+km431c4yRlREUAsAmt/uMjQUyQHNEPf0M39CA==", + "dev": true, + "engines": { + "node": ">=6" + } + }, "node_modules/puppeteer-core": { "version": "22.15.0", "resolved": "https://registry.npmjs.org/puppeteer-core/-/puppeteer-core-22.15.0.tgz", @@ -25192,6 +25299,55 @@ "is-typedarray": "^1.0.0" } }, + "node_modules/typedoc": { + "version": "0.27.5", + "resolved": "https://registry.npmjs.org/typedoc/-/typedoc-0.27.5.tgz", + "integrity": "sha512-x+fhKJtTg4ozXwKayh/ek4wxZQI/+2hmZUdO2i2NGDBRUflDble70z+ewHod3d4gRpXSO6fnlnjbDTnJk7HlkQ==", + "dev": true, + "dependencies": { + "@gerrit0/mini-shiki": "^1.24.0", + "lunr": "^2.3.9", + "markdown-it": "^14.1.0", + "minimatch": "^9.0.5", + "yaml": "^2.6.1" + }, + "bin": { + "typedoc": "bin/typedoc" + }, + "engines": { + "node": ">= 18" + }, + "peerDependencies": { + "typescript": "5.0.x || 5.1.x || 5.2.x || 5.3.x || 5.4.x || 5.5.x || 5.6.x || 5.7.x" + } + }, + "node_modules/typedoc-plugin-coverage": { + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/typedoc-plugin-coverage/-/typedoc-plugin-coverage-3.4.0.tgz", + "integrity": "sha512-I8fLeQEERncGn4sUlGZ+B1ehx4L7VRwqa3i6AP+PFfvZK0ToXBGkh9sK7xs8l8FLPXq7Cv0yVy4YCEGgWNzDBw==", + "dev": true, + "engines": { + "node": ">= 18" + }, + "peerDependencies": { + "typedoc": "0.25.x || 0.26.x || 0.27.x" + } + }, + "node_modules/typedoc/node_modules/minimatch": { + "version": "9.0.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz", + "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==", + "dev": true, + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, "node_modules/typescript": { "version": "5.5.4", "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.5.4.tgz", @@ -25279,6 +25435,12 @@ "typescript": ">=4.8.4 <5.8.0" } }, + "node_modules/uc.micro": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/uc.micro/-/uc.micro-2.1.0.tgz", + "integrity": "sha512-ARDJmphmdvUk6Glw7y9DQ2bFkKBHwQHLi2lsaH6PPmz/Ka9sFOBsBluozhDltWmnv9u/cF6Rt87znRTPV+yp/A==", + "dev": true + }, "node_modules/ufo": { "version": "1.5.4", "resolved": "https://registry.npmjs.org/ufo/-/ufo-1.5.4.tgz", diff --git a/package.json b/package.json index 2782021cf..de4938f30 100644 --- a/package.json +++ b/package.json @@ -110,6 +110,8 @@ "tsconfig-paths": "^4.2.0", "tsx": "^4.19.0", "type-fest": "^4.26.1", + "typedoc": "^0.27.5", + "typedoc-plugin-coverage": "^3.4.0", "typescript": "5.5.4", "typescript-eslint": "^8.18.0", "verdaccio": "^5.32.2", diff --git a/packages/plugin-doc-coverage/mocks/component-mock.ts b/packages/plugin-doc-coverage/mocks/component-mock.ts new file mode 100644 index 000000000..f8008c421 --- /dev/null +++ b/packages/plugin-doc-coverage/mocks/component-mock.ts @@ -0,0 +1,4 @@ +/** Dummy function */ +export function DUMMY_FUNCTION() { + return 'Hello World'; +} diff --git a/packages/plugin-doc-coverage/src/lib/config.ts b/packages/plugin-doc-coverage/src/lib/config.ts index 139f2d77a..052f35c47 100644 --- a/packages/plugin-doc-coverage/src/lib/config.ts +++ b/packages/plugin-doc-coverage/src/lib/config.ts @@ -3,23 +3,21 @@ import { z } from 'zod'; export type DocType = 'percentage-coverage'; export const docCoveragePluginConfigSchema = z.object({ - coverageToolCommand: z - .object({ - command: z - .string({ description: 'Command to run coverage tool (compodoc).' }) - .min(1), - args: z - .array(z.string(), { - description: 'Arguments to be passed to the coverage tool.', - }) - .optional(), + language: z.enum(['javascript', 'typescript'], { + description: 'Programming language of the source code to analyze', + }), + sourceGlob: z + .string({ + description: 'Glob pattern to find source files', + }) + .optional(), + outputFolderPath: z + .string({ + description: 'Path to the output folder', }) .optional(), - outputPath: z - .string({ description: 'Path to the documentation.json file.' }) - .default('documentation/documentation.json'), }); -export type DocCoveragePluginConfig = z.infer< +export type DocCoveragePluginConfig = z.input< typeof docCoveragePluginConfigSchema >; diff --git a/packages/plugin-doc-coverage/src/lib/config.unit.test.ts b/packages/plugin-doc-coverage/src/lib/config.unit.test.ts index 3964fa186..36840ece8 100644 --- a/packages/plugin-doc-coverage/src/lib/config.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/config.unit.test.ts @@ -8,45 +8,57 @@ describe('docCoveragePluginConfigSchema', () => { it('accepts a documentation coverage configuration with all entities', () => { expect(() => docCoveragePluginConfigSchema.parse({ - coverageToolCommand: { - command: 'npx @compodoc/compodoc', - args: ['-p', 'tsconfig.json'], - }, - outputPath: 'documentation/custom-doc.json', + language: 'typescript', + sourceGlob: 'src/**/*.{ts,tsx}', } satisfies DocCoveragePluginConfig), ).not.toThrow(); }); - it('accepts a minimal documentation coverage configuration', () => { + it('accepts minimal configuration with only language', () => { expect(() => - docCoveragePluginConfigSchema.parse({} satisfies DocCoveragePluginConfig), + docCoveragePluginConfigSchema.parse({ + language: 'javascript', + } satisfies DocCoveragePluginConfig), ).not.toThrow(); }); - it('uses default output path when not provided', () => { - const config = {} satisfies DocCoveragePluginConfig; + it('accepts configuration without sourceGlob', () => { + const config = { + language: 'typescript', + } satisfies DocCoveragePluginConfig; const parsed = docCoveragePluginConfigSchema.parse(config); - expect(parsed.outputPath).toBe('documentation/documentation.json'); + expect(parsed.sourceGlob).toBeUndefined(); }); - it('throws for missing command in coverageToolCommand', () => { + it('throws for missing language', () => { expect(() => docCoveragePluginConfigSchema.parse({ - coverageToolCommand: { - args: ['-p', 'tsconfig.json'], - }, + sourceGlob: 'src/**/*.ts', }), ).toThrow('invalid_type'); }); - it('accepts empty args in coverageToolCommand', () => { + it('throws for invalid language', () => { expect(() => docCoveragePluginConfigSchema.parse({ - coverageToolCommand: { - command: 'npx @compodoc/compodoc', - }, - } satisfies DocCoveragePluginConfig), + language: 'python', + sourceGlob: 'src/**/*.py', + }), + ).toThrow('Invalid enum value'); + }); + + it('accepts both typescript and javascript as valid languages', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + language: 'typescript', + }), + ).not.toThrow(); + + expect(() => + docCoveragePluginConfigSchema.parse({ + language: 'javascript', + }), ).not.toThrow(); }); }); diff --git a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts index 0519eed82..c2e55412b 100644 --- a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts +++ b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts @@ -19,8 +19,7 @@ import { createRunnerConfig } from './runner/index.js'; * plugins: [ * // ... other plugins ... * await docCoveragePlugin({ - * - * docTypes: ['class', 'function'] + * language: 'typescript' * }) * ] * } diff --git a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts index fbb2c452a..29c45bcf3 100644 --- a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts @@ -13,7 +13,7 @@ describe('docCoveragePlugin', () => { it('should initialise a Documentation coverage plugin', async () => { await expect( docCoveragePlugin({ - outputPath: 'documentation/documentation.json', + language: 'typescript', }), ).resolves.toStrictEqual( expect.objectContaining({ @@ -29,7 +29,7 @@ describe('docCoveragePlugin', () => { it('should generate percentage coverage audit', async () => { await expect( docCoveragePlugin({ - outputPath: 'documentation/documentation.json', + language: 'typescript', }), ).resolves.toStrictEqual( expect.objectContaining({ @@ -49,7 +49,7 @@ describe('docCoveragePlugin', () => { it('should provide a documentation coverage group', async () => { await expect( docCoveragePlugin({ - outputPath: 'documentation/documentation.json', + language: 'typescript', }), ).resolves.toStrictEqual( expect.objectContaining({ @@ -72,7 +72,7 @@ describe('docCoveragePlugin', () => { it('should include package metadata', async () => { await expect( docCoveragePlugin({ - outputPath: 'documentation/documentation.json', + language: 'typescript', }), ).resolves.toStrictEqual( expect.objectContaining({ diff --git a/packages/plugin-doc-coverage/src/lib/runner/constants.ts b/packages/plugin-doc-coverage/src/lib/runner/constants.ts index 8b9843ee6..9cf24d169 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/constants.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/constants.ts @@ -3,9 +3,40 @@ import { pluginWorkDir } from '@code-pushup/utils'; export const WORKDIR = pluginWorkDir('doc-coverage'); +export const RUNNER_OUTPUT_PATH = path.join(WORKDIR, 'runner-output.json'); + export const PLUGIN_CONFIG_PATH = path.join( process.cwd(), WORKDIR, 'plugin-config.json', ); -export const RUNNER_OUTPUT_PATH = path.join(WORKDIR, 'runner-output.json'); + +export const enum ProgrammingLanguage { + JavaScript = 'javascript', + TypeScript = 'typescript', +} + +export const DEFAULT_SOURCE_GLOB = { + [ProgrammingLanguage.JavaScript]: '"src/**/*.js"', + [ProgrammingLanguage.TypeScript]: '"src/**/*.ts"', +}; + +export const DEFAULT_OUTPUT_FOLDER_PATH = './documentation'; + +export const COMMANDS_FOR_LANGUAGES: Readonly< + Record +> = { + [ProgrammingLanguage.JavaScript]: { + command: 'npx', + args: 'typedoc $sourceGlob --entryPointStrategy expand --plugin typedoc-plugin-coverage --coverageOutputType json --skipErrorChecking --out $outputFolderPath', + }, + [ProgrammingLanguage.TypeScript]: { + command: 'npx', + args: 'typedoc $sourceGlob --entryPointStrategy expand --plugin typedoc-plugin-coverage --coverageOutputType json --skipErrorChecking --out $outputFolderPath', + }, +} as const; + +export type TypedocResult = { + percent: number; + notDocumented: string[]; +}; diff --git a/packages/plugin-doc-coverage/src/lib/runner/index.ts b/packages/plugin-doc-coverage/src/lib/runner/index.ts index 638777aaa..d5f83fc39 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/index.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/index.ts @@ -11,42 +11,79 @@ import { ui, } from '@code-pushup/utils'; import type { DocCoveragePluginConfig } from '../config.js'; -import { PLUGIN_CONFIG_PATH, RUNNER_OUTPUT_PATH } from './constants.js'; +import { + COMMANDS_FOR_LANGUAGES, + DEFAULT_OUTPUT_FOLDER_PATH, + DEFAULT_SOURCE_GLOB, + PLUGIN_CONFIG_PATH, + ProgrammingLanguage, + RUNNER_OUTPUT_PATH, + type TypedocResult, +} from './constants.js'; export { PLUGIN_CONFIG_PATH, RUNNER_OUTPUT_PATH } from './constants.js'; -export async function executeRunner(): Promise { - const { outputPath, coverageToolCommand } = - await readJsonFile(PLUGIN_CONFIG_PATH); - if (coverageToolCommand != null) { - const { command, args = [] } = coverageToolCommand; - try { - await executeProcess({ command, args }); - } catch (error) { - if (error instanceof ProcessError) { - ui().logger.error(bold('stdout from failed Compodoc process:')); - ui().logger.error(error.stdout); - ui().logger.error(bold('stderr from failed Compodoc process:')); - ui().logger.error(error.stderr); - } - throw new Error( - 'Doc Coverage plugin: Running Compodoc failed. Please check the error above.', - ); +/** + * Execute the Typedoc process. + * @param config - The configuration for the Typedoc process. + */ +async function _executeTypedocProcess( + config: DocCoveragePluginConfig, +): Promise { + const { + sourceGlob, + language, + outputFolderPath = DEFAULT_OUTPUT_FOLDER_PATH, + } = config; + const { args: originalArgs } = COMMANDS_FOR_LANGUAGES[language]; + const processedArgs = + language === ProgrammingLanguage.TypeScript + ? originalArgs + .replace('$outputFolderPath', outputFolderPath) + .replace('$sourceGlob', sourceGlob || DEFAULT_SOURCE_GLOB[language]) + : originalArgs; + + try { + await executeProcess({ + command: COMMANDS_FOR_LANGUAGES[language].command, + args: processedArgs.split(' '), + }); + } catch (error) { + if (error instanceof ProcessError) { + ui().logger.error(bold('stdout from failed Typedoc process:')); + ui().logger.error(error.stdout); + ui().logger.error(bold('stderr from failed Typedoc process:')); + ui().logger.error(error.stderr); } + throw new Error( + 'Doc Coverage plugin: Running Typedoc failed. Please check the error above.', + ); } +} +/** + * Process the Typedoc results. + * @param outputFolderPath - The path to the output folder. + */ +async function _processTypedocResults(outputFolderPath: string): Promise { try { - // From the output of Compodoc, we can get the coverage percentage. - const docData: { coverage: { count: number } } = - await readJsonFile(outputPath); - const coverage = docData.coverage.count || 0; - + const docData: TypedocResult = await readJsonFile( + path.join(outputFolderPath, 'coverage.json'), + ); + const coverage = docData.percent || 0; const auditOutputs: AuditOutput[] = [ { slug: 'percentage-coverage', value: coverage, score: coverage / 100, displayValue: `${coverage} %`, + details: { + issues: docData.notDocumented.map(file => ({ + message: 'Missing documentation', + source: { file }, + severity: 'warning', + })), + }, }, ]; @@ -58,7 +95,6 @@ export async function executeRunner(): Promise { ui().logger.error(error.stdout); ui().logger.error(bold('stderr from failed coverage tool process:')); ui().logger.error(error.stderr); - throw new Error( 'Doc Coverage plugin: Running Compodoc failed. Please check the error above.', ); @@ -66,6 +102,15 @@ export async function executeRunner(): Promise { } } +export async function executeRunner(): Promise { + const config = + await readJsonFile(PLUGIN_CONFIG_PATH); + await _executeTypedocProcess(config); + await _processTypedocResults( + config.outputFolderPath || DEFAULT_OUTPUT_FOLDER_PATH, + ); +} + export async function createRunnerConfig( scriptPath: string, config: DocCoveragePluginConfig, diff --git a/packages/plugin-doc-coverage/src/lib/runner/runner.integration.test.ts b/packages/plugin-doc-coverage/src/lib/runner/runner.integration.test.ts index f67e5791c..d7fc8e5e9 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/runner.integration.test.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/runner.integration.test.ts @@ -1,6 +1,4 @@ import { writeFile } from 'node:fs/promises'; -import path from 'node:path'; -import { fileURLToPath } from 'node:url'; import { describe, it } from 'vitest'; import type { AuditOutput, @@ -19,11 +17,9 @@ import { createRunnerConfig, executeRunner } from './index.js'; describe('createRunnerConfig', () => { it('should create a valid runner config', async () => { const runnerConfig = await createRunnerConfig('executeRunner.ts', { - coverageToolCommand: { - command: 'npx', - args: ['@compodoc/compodoc', '-p', 'tsconfig.json'], - }, - outputPath: 'documentation/documentation.json', + language: 'typescript', + sourceGlob: 'src/**/*.ts', + outputFolderPath: 'documentation', }); expect(runnerConfig).toStrictEqual({ command: 'node', @@ -36,11 +32,9 @@ describe('createRunnerConfig', () => { await removeDirectoryIfExists(WORKDIR); const pluginConfig: DocCoveragePluginConfig = { - coverageToolCommand: { - command: 'npx', - args: ['@compodoc/compodoc', '-p', 'tsconfig.json'], - }, - outputPath: 'documentation/documentation.json', + language: 'typescript', + sourceGlob: 'src/**/*.ts', + outputFolderPath: 'documentation', }; await createRunnerConfig('executeRunner.ts', pluginConfig); @@ -52,29 +46,27 @@ describe('createRunnerConfig', () => { }); describe('executeRunner', () => { - it('should successfully execute runner', async () => { - const config: DocCoveragePluginConfig = { - outputPath: path.join( - fileURLToPath(path.dirname(import.meta.url)), - '..', - '..', - '..', - 'mocks', - 'documentation.json', - ), - }; + it( + 'should successfully execute runner', + async () => { + const config: DocCoveragePluginConfig = { + language: 'typescript', + sourceGlob: '"packages/plugin-doc-coverage/mocks/component-mock.ts"', + }; - await writeFile(PLUGIN_CONFIG_PATH, JSON.stringify(config)); - await executeRunner(); + await writeFile(PLUGIN_CONFIG_PATH, JSON.stringify(config)); + await executeRunner(); - const results = await readJsonFile(RUNNER_OUTPUT_PATH); - expect(results).toStrictEqual([ - expect.objectContaining({ - slug: 'percentage-coverage', - score: 0.85, - value: 85, - displayValue: '85 %', - } satisfies AuditOutput), - ]); - }); + const results = await readJsonFile(RUNNER_OUTPUT_PATH); + expect(results).toStrictEqual([ + expect.objectContaining({ + slug: 'percentage-coverage', + score: 1, + value: 100, + displayValue: '100 %', + } satisfies AuditOutput), + ]); + }, + { timeout: 60 * 1000 }, + ); }); diff --git a/packages/plugin-doc-coverage/tsconfig.test.json b/packages/plugin-doc-coverage/tsconfig.test.json index 9f29d6bb0..05637ee6e 100644 --- a/packages/plugin-doc-coverage/tsconfig.test.json +++ b/packages/plugin-doc-coverage/tsconfig.test.json @@ -8,6 +8,7 @@ "vite.config.unit.ts", "vite.config.integration.ts", "mocks/**/*.ts", - "src/**/*.test.ts" + "src/**/*.test.ts", + "mocks/component-mock.ts" ] } From 0de6d3fb3767c3065990108dbc16902bca00374b Mon Sep 17 00:00:00 2001 From: Alejandro Date: Wed, 18 Dec 2024 03:01:40 +0100 Subject: [PATCH 03/39] feat(plugin-doc-coverage): change to use ts-morph instead of typedoc. MVP --- code-pushup.config.ts | 2 + code-pushup.preset.ts | 28 ++ package-lock.json | 242 ++++++------------ package.json | 3 +- .../mocks/component-mock.ts | 5 +- packages/plugin-doc-coverage/package.json | 3 +- .../plugin-doc-coverage/src/lib/config.ts | 5 - .../src/lib/doc-coverage-plugin.ts | 34 +-- .../src/lib/doc-coverage-plugin.unit.test.ts | 24 -- .../plugin-doc-coverage/src/lib/models.ts | 7 + .../src/lib/runner/doc-processer.ts | 198 ++++++++++++++ .../src/lib/runner/index.ts | 55 ++-- .../src/lib/runner/runner.integration.test.ts | 4 +- .../plugin-doc-coverage/tsconfig.lib.json | 2 +- tsconfig.base.json | 3 + 15 files changed, 362 insertions(+), 253 deletions(-) create mode 100644 packages/plugin-doc-coverage/src/lib/models.ts create mode 100644 packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts diff --git a/code-pushup.config.ts b/code-pushup.config.ts index bd089d884..d1b674a1d 100644 --- a/code-pushup.config.ts +++ b/code-pushup.config.ts @@ -2,6 +2,7 @@ import 'dotenv/config'; import { z } from 'zod'; import { coverageCoreConfigNx, + docCoverageCoreConfig, eslintCoreConfigNx, jsPackagesCoreConfig, lighthouseCoreConfig, @@ -39,4 +40,5 @@ export default mergeConfigs( 'https://github.com/code-pushup/cli?tab=readme-ov-file#code-pushup-cli/', ), await eslintCoreConfigNx(), + await docCoverageCoreConfig(), ); diff --git a/code-pushup.preset.ts b/code-pushup.preset.ts index 74e6b51ce..979610544 100644 --- a/code-pushup.preset.ts +++ b/code-pushup.preset.ts @@ -5,6 +5,8 @@ import type { import coveragePlugin, { getNxCoveragePaths, } from './packages/plugin-coverage/src/index.js'; +import docCoveragePlugin from './packages/plugin-doc-coverage/src/index.js'; +import { docCoverageAudits } from './packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.js'; import eslintPlugin, { eslintConfigFromAllNxProjects, eslintConfigFromNxProject, @@ -82,6 +84,20 @@ export const eslintCategories: CategoryConfig[] = [ }, ]; +export const docCoverageCategories: CategoryConfig[] = [ + { + slug: 'doc-coverage', + title: 'Documentation coverage', + description: 'Measures how much of your code is **documented**.', + refs: docCoverageAudits.map(audit => ({ + weight: 1, + type: 'audit', + plugin: 'doc-coverage', + slug: audit.slug, + })), + }, +]; + export const coverageCategories: CategoryConfig[] = [ { slug: 'code-coverage', @@ -114,6 +130,18 @@ export const lighthouseCoreConfig = async ( }; }; +export const docCoverageCoreConfig = async (): Promise => { + return { + plugins: [ + await docCoveragePlugin({ + language: 'typescript', + sourceGlob: 'packages/**/*.ts', + }), + ], + categories: docCoverageCategories, + }; +}; + export const eslintCoreConfigNx = async ( projectName?: string, ): Promise => { diff --git a/package-lock.json b/package-lock.json index 9138feee2..206de309d 100644 --- a/package-lock.json +++ b/package-lock.json @@ -27,6 +27,7 @@ "parse-lcov": "^1.0.4", "semver": "^7.6.3", "simple-git": "^3.26.0", + "ts-morph": "^24.0.0", "tslib": "^2.6.2", "vscode-material-icons": "^0.1.1", "yaml": "^2.5.1", @@ -97,8 +98,6 @@ "tsconfig-paths": "^4.2.0", "tsx": "^4.19.0", "type-fest": "^4.26.1", - "typedoc": "^0.27.5", - "typedoc-plugin-coverage": "^3.4.0", "typescript": "5.5.4", "typescript-eslint": "^8.18.0", "verdaccio": "^5.32.2", @@ -3235,17 +3234,6 @@ "tslib": "^2.4.0" } }, - "node_modules/@gerrit0/mini-shiki": { - "version": "1.24.4", - "resolved": "https://registry.npmjs.org/@gerrit0/mini-shiki/-/mini-shiki-1.24.4.tgz", - "integrity": "sha512-YEHW1QeAg6UmxEmswiQbOVEg1CW22b1XUD/lNTliOsu0LD0wqoyleFMnmbTp697QE0pcadQiR5cVtbbAPncvpw==", - "dev": true, - "dependencies": { - "@shikijs/engine-oniguruma": "^1.24.2", - "@shikijs/types": "^1.24.2", - "@shikijs/vscode-textmate": "^9.3.1" - } - }, "node_modules/@graphql-typed-document-node/core": { "version": "3.2.0", "resolved": "https://registry.npmjs.org/@graphql-typed-document-node/core/-/core-3.2.0.tgz", @@ -6172,32 +6160,6 @@ "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz", "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==" }, - "node_modules/@shikijs/engine-oniguruma": { - "version": "1.24.2", - "resolved": "https://registry.npmjs.org/@shikijs/engine-oniguruma/-/engine-oniguruma-1.24.2.tgz", - "integrity": "sha512-ZN6k//aDNWRJs1uKB12pturKHh7GejKugowOFGAuG7TxDRLod1Bd5JhpOikOiFqPmKjKEPtEA6mRCf7q3ulDyQ==", - "dev": true, - "dependencies": { - "@shikijs/types": "1.24.2", - "@shikijs/vscode-textmate": "^9.3.0" - } - }, - "node_modules/@shikijs/types": { - "version": "1.24.2", - "resolved": "https://registry.npmjs.org/@shikijs/types/-/types-1.24.2.tgz", - "integrity": "sha512-bdeWZiDtajGLG9BudI0AHet0b6e7FbR0EsE4jpGaI0YwHm/XJunI9+3uZnzFtX65gsyJ6ngCIWUfA4NWRPnBkQ==", - "dev": true, - "dependencies": { - "@shikijs/vscode-textmate": "^9.3.0", - "@types/hast": "^3.0.4" - } - }, - "node_modules/@shikijs/vscode-textmate": { - "version": "9.3.1", - "resolved": "https://registry.npmjs.org/@shikijs/vscode-textmate/-/vscode-textmate-9.3.1.tgz", - "integrity": "sha512-79QfK1393x9Ho60QFyLti+QfdJzRQCVLFb97kOIV7Eo9vQU/roINgk7m24uv0a7AUvN//RDH36FLjjK48v0s9g==", - "dev": true - }, "node_modules/@sinclair/typebox": { "version": "0.27.8", "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.27.8.tgz", @@ -7184,6 +7146,30 @@ "node": ">=10.13.0" } }, + "node_modules/@ts-morph/common": { + "version": "0.25.0", + "resolved": "https://registry.npmjs.org/@ts-morph/common/-/common-0.25.0.tgz", + "integrity": "sha512-kMnZz+vGGHi4GoHnLmMhGNjm44kGtKUXGnOvrKmMwAuvNjM/PgKVGfUnL7IDvK7Jb2QQ82jq3Zmp04Gy+r3Dkg==", + "dependencies": { + "minimatch": "^9.0.4", + "path-browserify": "^1.0.1", + "tinyglobby": "^0.2.9" + } + }, + "node_modules/@ts-morph/common/node_modules/minimatch": { + "version": "9.0.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz", + "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, "node_modules/@tsconfig/node10": { "version": "1.0.11", "resolved": "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.11.tgz", @@ -7335,15 +7321,6 @@ "@types/node": "*" } }, - "node_modules/@types/hast": { - "version": "3.0.4", - "resolved": "https://registry.npmjs.org/@types/hast/-/hast-3.0.4.tgz", - "integrity": "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==", - "dev": true, - "dependencies": { - "@types/unist": "*" - } - }, "node_modules/@types/http-cache-semantics": { "version": "4.0.4", "resolved": "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.0.4.tgz", @@ -7475,12 +7452,6 @@ "integrity": "sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw==", "dev": true }, - "node_modules/@types/unist": { - "version": "3.0.3", - "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz", - "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==", - "dev": true - }, "node_modules/@types/yargs": { "version": "17.0.33", "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-17.0.33.tgz", @@ -10852,6 +10823,11 @@ "node": ">= 0.12.0" } }, + "node_modules/code-block-writer": { + "version": "13.0.3", + "resolved": "https://registry.npmjs.org/code-block-writer/-/code-block-writer-13.0.3.tgz", + "integrity": "sha512-Oofo0pq3IKnsFtuHqSF7TqBfr71aeyZDVJ0HpmqB7FBM2qEigL0iPONSCZSO9pE9dZTAxANe5XHG9Uy0YMv8cg==" + }, "node_modules/collect-v8-coverage": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/collect-v8-coverage/-/collect-v8-coverage-1.0.2.tgz", @@ -19708,15 +19684,6 @@ "node": "^12.20.0 || ^14.13.1 || >=16.0.0" } }, - "node_modules/linkify-it": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/linkify-it/-/linkify-it-5.0.0.tgz", - "integrity": "sha512-5aHCbzQRADcdP+ATqnDuhhJ/MRIqDkZX5pyjFHRRysS8vZ5AbqGEoFIb6pYHPZ+L/OC2Lc+xT8uHVVR5CAK/wQ==", - "dev": true, - "dependencies": { - "uc.micro": "^2.0.0" - } - }, "node_modules/load-tsconfig": { "version": "0.2.5", "resolved": "https://registry.npmjs.org/load-tsconfig/-/load-tsconfig-0.2.5.tgz", @@ -20209,12 +20176,6 @@ "yallist": "^3.0.2" } }, - "node_modules/lunr": { - "version": "2.3.9", - "resolved": "https://registry.npmjs.org/lunr/-/lunr-2.3.9.tgz", - "integrity": "sha512-zTU3DaZaF3Rt9rhN3uBMGQD3dD2/vFQqnvZCDv4dl5iOzq2IZQqTxu90r4E5J+nP70J3ilqVCrbho2eWaeW8Ow==", - "dev": true - }, "node_modules/luxon": { "version": "3.5.0", "resolved": "https://registry.npmjs.org/luxon/-/luxon-3.5.0.tgz", @@ -20283,29 +20244,6 @@ "tmpl": "1.0.5" } }, - "node_modules/markdown-it": { - "version": "14.1.0", - "resolved": "https://registry.npmjs.org/markdown-it/-/markdown-it-14.1.0.tgz", - "integrity": "sha512-a54IwgWPaeBCAAsv13YgmALOF1elABB08FxO9i+r4VFk5Vl4pKokRPeX8u5TCgSsPi6ec1otfLjdOpVcgbpshg==", - "dev": true, - "dependencies": { - "argparse": "^2.0.1", - "entities": "^4.4.0", - "linkify-it": "^5.0.0", - "mdurl": "^2.0.0", - "punycode.js": "^2.3.1", - "uc.micro": "^2.1.0" - }, - "bin": { - "markdown-it": "bin/markdown-it.mjs" - } - }, - "node_modules/markdown-it/node_modules/argparse": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", - "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", - "dev": true - }, "node_modules/marky": { "version": "1.2.5", "resolved": "https://registry.npmjs.org/marky/-/marky-1.2.5.tgz", @@ -20326,12 +20264,6 @@ "integrity": "sha512-GaqWWShW4kv/G9IEucWScBx9G1/vsFZZJUO+tD26M8J8z3Kw5RDQjaoZe03YAClgeS/SWPOcb4nkFBTEi5DUEA==", "dev": true }, - "node_modules/mdurl": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/mdurl/-/mdurl-2.0.0.tgz", - "integrity": "sha512-Lf+9+2r+Tdp5wXDXC4PcIBjTDtq4UKjCPMQhKIuzpJNW0b96kVqSwW0bT7FhRSfmAiFYgP+SCRvdrDozfh0U5w==", - "dev": true - }, "node_modules/media-typer": { "version": "0.3.0", "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz", @@ -21772,6 +21704,11 @@ "node": ">= 0.8" } }, + "node_modules/path-browserify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-1.0.1.tgz", + "integrity": "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==" + }, "node_modules/path-exists": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-5.0.0.tgz", @@ -22341,15 +22278,6 @@ "node": ">=6" } }, - "node_modules/punycode.js": { - "version": "2.3.1", - "resolved": "https://registry.npmjs.org/punycode.js/-/punycode.js-2.3.1.tgz", - "integrity": "sha512-uxFIHU0YlHYhDQtV4R9J6a52SLx28BCjT+4ieh7IGbgwVJWO+km431c4yRlREUAsAmt/uMjQUyQHNEPf0M39CA==", - "dev": true, - "engines": { - "node": ">=6" - } - }, "node_modules/puppeteer-core": { "version": "22.15.0", "resolved": "https://registry.npmjs.org/puppeteer-core/-/puppeteer-core-22.15.0.tgz", @@ -24740,6 +24668,42 @@ "integrity": "sha512-WiCJLEECkO18gwqIp6+hJg0//p23HXp4S+gGtAKu3mI2F2/sXC4FvHvXvB0zJVVaTPhx1/tOwdbRsa1sOBIKqQ==", "dev": true }, + "node_modules/tinyglobby": { + "version": "0.2.10", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.10.tgz", + "integrity": "sha512-Zc+8eJlFMvgatPZTl6A9L/yht8QqdmUNtURHaKZLmKBE12hNPSrqNkUp2cs3M/UKmNVVAMFQYSjYIVHDjW5zew==", + "dependencies": { + "fdir": "^6.4.2", + "picomatch": "^4.0.2" + }, + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/tinyglobby/node_modules/fdir": { + "version": "6.4.2", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.4.2.tgz", + "integrity": "sha512-KnhMXsKSPZlAhp7+IjUkRZKPb4fUyccpDrdFXbi4QL1qkmFh9kVY09Yox+n4MaOb3lHZ1Tv829C3oaaXoMYPDQ==", + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, + "node_modules/tinyglobby/node_modules/picomatch": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.2.tgz", + "integrity": "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, "node_modules/tinypool": { "version": "0.8.4", "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-0.8.4.tgz", @@ -24963,6 +24927,15 @@ "typescript": ">=4.0.0" } }, + "node_modules/ts-morph": { + "version": "24.0.0", + "resolved": "https://registry.npmjs.org/ts-morph/-/ts-morph-24.0.0.tgz", + "integrity": "sha512-2OAOg/Ob5yx9Et7ZX4CvTCc0UFoZHwLEJ+dpDPSUi5TgwwlTlX47w+iFRrEwzUZwYACjq83cgjS/Da50Ga37uw==", + "dependencies": { + "@ts-morph/common": "~0.25.0", + "code-block-writer": "^13.0.3" + } + }, "node_modules/ts-node": { "version": "10.9.1", "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-10.9.1.tgz", @@ -25299,55 +25272,6 @@ "is-typedarray": "^1.0.0" } }, - "node_modules/typedoc": { - "version": "0.27.5", - "resolved": "https://registry.npmjs.org/typedoc/-/typedoc-0.27.5.tgz", - "integrity": "sha512-x+fhKJtTg4ozXwKayh/ek4wxZQI/+2hmZUdO2i2NGDBRUflDble70z+ewHod3d4gRpXSO6fnlnjbDTnJk7HlkQ==", - "dev": true, - "dependencies": { - "@gerrit0/mini-shiki": "^1.24.0", - "lunr": "^2.3.9", - "markdown-it": "^14.1.0", - "minimatch": "^9.0.5", - "yaml": "^2.6.1" - }, - "bin": { - "typedoc": "bin/typedoc" - }, - "engines": { - "node": ">= 18" - }, - "peerDependencies": { - "typescript": "5.0.x || 5.1.x || 5.2.x || 5.3.x || 5.4.x || 5.5.x || 5.6.x || 5.7.x" - } - }, - "node_modules/typedoc-plugin-coverage": { - "version": "3.4.0", - "resolved": "https://registry.npmjs.org/typedoc-plugin-coverage/-/typedoc-plugin-coverage-3.4.0.tgz", - "integrity": "sha512-I8fLeQEERncGn4sUlGZ+B1ehx4L7VRwqa3i6AP+PFfvZK0ToXBGkh9sK7xs8l8FLPXq7Cv0yVy4YCEGgWNzDBw==", - "dev": true, - "engines": { - "node": ">= 18" - }, - "peerDependencies": { - "typedoc": "0.25.x || 0.26.x || 0.27.x" - } - }, - "node_modules/typedoc/node_modules/minimatch": { - "version": "9.0.5", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz", - "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==", - "dev": true, - "dependencies": { - "brace-expansion": "^2.0.1" - }, - "engines": { - "node": ">=16 || 14 >=14.17" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, "node_modules/typescript": { "version": "5.5.4", "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.5.4.tgz", @@ -25435,12 +25359,6 @@ "typescript": ">=4.8.4 <5.8.0" } }, - "node_modules/uc.micro": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/uc.micro/-/uc.micro-2.1.0.tgz", - "integrity": "sha512-ARDJmphmdvUk6Glw7y9DQ2bFkKBHwQHLi2lsaH6PPmz/Ka9sFOBsBluozhDltWmnv9u/cF6Rt87znRTPV+yp/A==", - "dev": true - }, "node_modules/ufo": { "version": "1.5.4", "resolved": "https://registry.npmjs.org/ufo/-/ufo-1.5.4.tgz", diff --git a/package.json b/package.json index de4938f30..6366530e8 100644 --- a/package.json +++ b/package.json @@ -40,6 +40,7 @@ "parse-lcov": "^1.0.4", "semver": "^7.6.3", "simple-git": "^3.26.0", + "ts-morph": "^24.0.0", "tslib": "^2.6.2", "vscode-material-icons": "^0.1.1", "yaml": "^2.5.1", @@ -110,8 +111,6 @@ "tsconfig-paths": "^4.2.0", "tsx": "^4.19.0", "type-fest": "^4.26.1", - "typedoc": "^0.27.5", - "typedoc-plugin-coverage": "^3.4.0", "typescript": "5.5.4", "typescript-eslint": "^8.18.0", "verdaccio": "^5.32.2", diff --git a/packages/plugin-doc-coverage/mocks/component-mock.ts b/packages/plugin-doc-coverage/mocks/component-mock.ts index f8008c421..e66f4f859 100644 --- a/packages/plugin-doc-coverage/mocks/component-mock.ts +++ b/packages/plugin-doc-coverage/mocks/component-mock.ts @@ -1,4 +1,7 @@ -/** Dummy function */ +/** + * Dummy function that returns 'Hello World'. + * @returns {string} - The string 'Hello World'. + */ export function DUMMY_FUNCTION() { return 'Hello World'; } diff --git a/packages/plugin-doc-coverage/package.json b/packages/plugin-doc-coverage/package.json index 1c2ebe241..ec8b984a9 100644 --- a/packages/plugin-doc-coverage/package.json +++ b/packages/plugin-doc-coverage/package.json @@ -37,7 +37,8 @@ "@code-pushup/models": "0.57.0", "@code-pushup/utils": "0.57.0", "ansis": "^3.3.0", - "zod": "^3.22.4" + "zod": "^3.22.4", + "ts-morph": "^24.0.0" }, "peerDependenciesMeta": { "@nx/devkit": { diff --git a/packages/plugin-doc-coverage/src/lib/config.ts b/packages/plugin-doc-coverage/src/lib/config.ts index 052f35c47..a55a46137 100644 --- a/packages/plugin-doc-coverage/src/lib/config.ts +++ b/packages/plugin-doc-coverage/src/lib/config.ts @@ -11,11 +11,6 @@ export const docCoveragePluginConfigSchema = z.object({ description: 'Glob pattern to find source files', }) .optional(), - outputFolderPath: z - .string({ - description: 'Path to the output folder', - }) - .optional(), }); export type DocCoveragePluginConfig = z.input< diff --git a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts index c2e55412b..0504c8218 100644 --- a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts +++ b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts @@ -1,7 +1,7 @@ import { createRequire } from 'node:module'; import path from 'node:path'; import { fileURLToPath } from 'node:url'; -import type { Group, PluginConfig } from '@code-pushup/models'; +import type { PluginConfig } from '@code-pushup/models'; import { type DocCoveragePluginConfig, docCoveragePluginConfigSchema, @@ -26,30 +26,20 @@ import { createRunnerConfig } from './runner/index.js'; * * @returns Plugin configuration. */ + +export const docCoverageAudits = [ + { + slug: 'percentage-coverage', + title: 'Percentage of codebase with documentation', + description: 'Measures how many % of the codebase have documentation.', + }, +]; + export async function docCoveragePlugin( config: DocCoveragePluginConfig, ): Promise { const docCoverageConfig = docCoveragePluginConfigSchema.parse(config); - const audits = [ - { - slug: 'percentage-coverage', - title: 'Percentage of codebase with documentation', - description: 'Measures how many % of the codebase have documentation.', - }, - ]; - - const group: Group = { - slug: 'doc-coverage', - title: 'Documentation coverage metrics', - description: - 'Group containing all defined documentation coverage types as audits.', - refs: audits.map(audit => ({ - ...audit, - weight: 1, - })), - }; - const runnerScriptPath = path.join( fileURLToPath(path.dirname(import.meta.url)), '..', @@ -68,8 +58,8 @@ export async function docCoveragePlugin( docsUrl: 'https://www.npmjs.com/package/@code-pushup/doc-coverage-plugin/', packageName: packageJson.name, version: packageJson.version, - audits, - groups: [group], + audits: docCoverageAudits, + // groups: [group], runner: await createRunnerConfig(runnerScriptPath, docCoverageConfig), }; } diff --git a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts index 29c45bcf3..20e44b1da 100644 --- a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts @@ -20,7 +20,6 @@ describe('docCoveragePlugin', () => { slug: 'doc-coverage', title: 'Documentation coverage', audits: expect.any(Array), - groups: expect.any(Array), runner: expect.any(Object), }), ); @@ -46,29 +45,6 @@ describe('docCoveragePlugin', () => { ); }); - it('should provide a documentation coverage group', async () => { - await expect( - docCoveragePlugin({ - language: 'typescript', - }), - ).resolves.toStrictEqual( - expect.objectContaining({ - groups: [ - expect.objectContaining({ - slug: 'doc-coverage', - title: 'Documentation coverage metrics', - refs: [ - expect.objectContaining({ - slug: 'percentage-coverage', - weight: 1, - }), - ], - }), - ], - }), - ); - }); - it('should include package metadata', async () => { await expect( docCoveragePlugin({ diff --git a/packages/plugin-doc-coverage/src/lib/models.ts b/packages/plugin-doc-coverage/src/lib/models.ts new file mode 100644 index 000000000..ff4605b8c --- /dev/null +++ b/packages/plugin-doc-coverage/src/lib/models.ts @@ -0,0 +1,7 @@ +export type UndocumentedItem = { + file: string; + type: string; + name: string; + line: number; + class?: string; +}; diff --git a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts new file mode 100644 index 000000000..86d75b343 --- /dev/null +++ b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts @@ -0,0 +1,198 @@ +import { Project } from 'ts-morph'; +import type { UndocumentedItem } from '../models.js'; + +/* eslint-disable @typescript-eslint/no-explicit-any */ +/* eslint-disable functional/immutable-data */ +/* eslint-disable @typescript-eslint/max-params */ +/* eslint-disable functional/no-let */ + +export function processDocCoverage(toInclude: string): { + undocumentedItems: UndocumentedItem[]; + coverage: number; +} { + const project = new Project(); + project.addSourceFilesAtPaths(toInclude); + + let itsDocumented = 0; + const undocumentedItems: UndocumentedItem[] = []; + + project.getSourceFiles().forEach(sourceFile => { + if (isTestFile(sourceFile.getFilePath())) { + return; + } + + processClassDeclarations( + sourceFile, + undocumentedItems, + count => (itsDocumented += count), + ); + processDeclarations( + sourceFile, + undocumentedItems, + count => (itsDocumented += count), + ); + }); + + return calculateCoverage(undocumentedItems, itsDocumented); +} + +function isTestFile(filePath: string): boolean { + return filePath.includes('.spec.') || filePath.includes('.test.'); +} + +function addUndocumentedItem( + file: string, + type: string, + name: string, + line: number, +): UndocumentedItem { + return { + file, + type, + name, + line, + }; +} + +function processClassDeclarations( + sourceFile: any, + undocumentedItems: UndocumentedItem[], + onDocumented: (count: number) => void, +): void { + sourceFile.getClasses().forEach((classDeclaration: any) => { + const className = classDeclaration.getName() || 'Anonymous Class'; + const filePath = sourceFile.getFilePath(); + + // Process class itself + if (classDeclaration.getJsDocs().length === 0) { + undocumentedItems.push( + addUndocumentedItem( + filePath, + 'class', + className, + classDeclaration.getStartLineNumber(), + ), + ); + } else { + onDocumented(1); + } + + // Process properties + classDeclaration.getProperties().forEach((property: any) => { + if (property.getJsDocs().length === 0) { + undocumentedItems.push( + addUndocumentedItem( + filePath, + 'property', + property.getName(), + property.getStartLineNumber(), + ), + ); + } else { + onDocumented(1); + } + }); + + // Process methods + classDeclaration.getMethods().forEach((method: any) => { + if (method.getJsDocs().length === 0) { + undocumentedItems.push( + addUndocumentedItem( + filePath, + 'method', + method.getName(), + method.getStartLineNumber(), + ), + ); + } else { + onDocumented(1); + } + }); + }); +} + +function processDeclarations( + sourceFile: any, + undocumentedItems: UndocumentedItem[], + onDocumented: (count: number) => void, +): void { + const filePath = sourceFile.getFilePath(); + + // Process functions + processItems( + sourceFile.getFunctions(), + 'function', + item => item.getName() || 'Anonymous Function', + filePath, + undocumentedItems, + onDocumented, + ); + + // Process variables + sourceFile.getVariableStatements().forEach((statement: any) => { + statement.getDeclarations().forEach((declaration: any) => { + if (statement.getJsDocs().length === 0) { + undocumentedItems.push( + addUndocumentedItem( + filePath, + 'variable', + declaration.getName(), + declaration.getStartLineNumber(), + ), + ); + } else { + onDocumented(1); + } + }); + }); + + // Process interfaces and types + processItems( + sourceFile.getInterfaces(), + 'interface', + item => item.getName(), + filePath, + undocumentedItems, + onDocumented, + ); + processItems( + sourceFile.getTypeAliases(), + 'type', + item => item.getName(), + filePath, + undocumentedItems, + onDocumented, + ); +} + +function processItems( + items: any[], + type: string, + getName: (item: any) => string, + filePath: string, + undocumentedItems: UndocumentedItem[], + onDocumented: (count: number) => void, +): void { + items.forEach(item => { + if (item.getJsDocs().length === 0) { + undocumentedItems.push( + addUndocumentedItem( + filePath, + type, + getName(item), + item.getStartLineNumber(), + ), + ); + } else { + onDocumented(1); + } + }); +} + +function calculateCoverage( + undocumentedItems: UndocumentedItem[], + documented: number, +) { + const coverage = (documented / (documented + undocumentedItems.length)) * 100; + return { undocumentedItems, coverage }; +} diff --git a/packages/plugin-doc-coverage/src/lib/runner/index.ts b/packages/plugin-doc-coverage/src/lib/runner/index.ts index d5f83fc39..23aed7a92 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/index.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/index.ts @@ -5,21 +5,18 @@ import type { AuditOutput, RunnerConfig } from '@code-pushup/models'; import { ProcessError, ensureDirectoryExists, - executeProcess, filePathToCliArg, readJsonFile, ui, } from '@code-pushup/utils'; import type { DocCoveragePluginConfig } from '../config.js'; +import type { UndocumentedItem } from '../models.js'; import { - COMMANDS_FOR_LANGUAGES, - DEFAULT_OUTPUT_FOLDER_PATH, DEFAULT_SOURCE_GLOB, PLUGIN_CONFIG_PATH, - ProgrammingLanguage, RUNNER_OUTPUT_PATH, - type TypedocResult, } from './constants.js'; +import { processDocCoverage } from './doc-processer.js'; export { PLUGIN_CONFIG_PATH, RUNNER_OUTPUT_PATH } from './constants.js'; @@ -29,25 +26,19 @@ export { PLUGIN_CONFIG_PATH, RUNNER_OUTPUT_PATH } from './constants.js'; */ async function _executeTypedocProcess( config: DocCoveragePluginConfig, -): Promise { - const { - sourceGlob, - language, - outputFolderPath = DEFAULT_OUTPUT_FOLDER_PATH, - } = config; - const { args: originalArgs } = COMMANDS_FOR_LANGUAGES[language]; - const processedArgs = - language === ProgrammingLanguage.TypeScript - ? originalArgs - .replace('$outputFolderPath', outputFolderPath) - .replace('$sourceGlob', sourceGlob || DEFAULT_SOURCE_GLOB[language]) - : originalArgs; +): Promise<{ + undocumentedItems: UndocumentedItem[]; + coverage: number; +}> { + const { sourceGlob, language } = config; try { - await executeProcess({ - command: COMMANDS_FOR_LANGUAGES[language].command, - args: processedArgs.split(' '), - }); + return processDocCoverage(sourceGlob || DEFAULT_SOURCE_GLOB[language]); + // console.table(undocumentedItems); + // await executeProcess({ + // command: COMMANDS_FOR_LANGUAGES[language].command, + // args: processedArgs.split(' '), + // }); } catch (error) { if (error instanceof ProcessError) { ui().logger.error(bold('stdout from failed Typedoc process:')); @@ -65,12 +56,11 @@ async function _executeTypedocProcess( * Process the Typedoc results. * @param outputFolderPath - The path to the output folder. */ -async function _processTypedocResults(outputFolderPath: string): Promise { +async function _processTypedocResults( + undocumentedItems: UndocumentedItem[], + coverage: number, +): Promise { try { - const docData: TypedocResult = await readJsonFile( - path.join(outputFolderPath, 'coverage.json'), - ); - const coverage = docData.percent || 0; const auditOutputs: AuditOutput[] = [ { slug: 'percentage-coverage', @@ -78,9 +68,9 @@ async function _processTypedocResults(outputFolderPath: string): Promise { score: coverage / 100, displayValue: `${coverage} %`, details: { - issues: docData.notDocumented.map(file => ({ - message: 'Missing documentation', - source: { file }, + issues: undocumentedItems.map(item => ({ + message: `Missing documentation for a ${item.type}`, + source: { file: item.file, position: { startLine: item.line } }, severity: 'warning', })), }, @@ -105,9 +95,10 @@ async function _processTypedocResults(outputFolderPath: string): Promise { export async function executeRunner(): Promise { const config = await readJsonFile(PLUGIN_CONFIG_PATH); - await _executeTypedocProcess(config); + const processResult = await _executeTypedocProcess(config); await _processTypedocResults( - config.outputFolderPath || DEFAULT_OUTPUT_FOLDER_PATH, + processResult.undocumentedItems, + processResult.coverage, ); } diff --git a/packages/plugin-doc-coverage/src/lib/runner/runner.integration.test.ts b/packages/plugin-doc-coverage/src/lib/runner/runner.integration.test.ts index d7fc8e5e9..49cd966d3 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/runner.integration.test.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/runner.integration.test.ts @@ -19,7 +19,6 @@ describe('createRunnerConfig', () => { const runnerConfig = await createRunnerConfig('executeRunner.ts', { language: 'typescript', sourceGlob: 'src/**/*.ts', - outputFolderPath: 'documentation', }); expect(runnerConfig).toStrictEqual({ command: 'node', @@ -34,7 +33,6 @@ describe('createRunnerConfig', () => { const pluginConfig: DocCoveragePluginConfig = { language: 'typescript', sourceGlob: 'src/**/*.ts', - outputFolderPath: 'documentation', }; await createRunnerConfig('executeRunner.ts', pluginConfig); @@ -51,7 +49,7 @@ describe('executeRunner', () => { async () => { const config: DocCoveragePluginConfig = { language: 'typescript', - sourceGlob: '"packages/plugin-doc-coverage/mocks/component-mock.ts"', + sourceGlob: 'packages/plugin-doc-coverage/mocks/*.ts', }; await writeFile(PLUGIN_CONFIG_PATH, JSON.stringify(config)); diff --git a/packages/plugin-doc-coverage/tsconfig.lib.json b/packages/plugin-doc-coverage/tsconfig.lib.json index ef2f7e2b3..37e86c560 100644 --- a/packages/plugin-doc-coverage/tsconfig.lib.json +++ b/packages/plugin-doc-coverage/tsconfig.lib.json @@ -5,7 +5,7 @@ "declaration": true, "types": ["node"] }, - "include": ["src/**/*.ts"], + "include": ["src/**/*.ts", "src/lib/runner/doc-processer.js"], "exclude": [ "vite.config.unit.ts", "vite.config.integration.ts", diff --git a/tsconfig.base.json b/tsconfig.base.json index d088eca5a..c5cddb98c 100644 --- a/tsconfig.base.json +++ b/tsconfig.base.json @@ -25,6 +25,9 @@ "@code-pushup/core": ["packages/core/src/index.ts"], "@code-pushup/coverage-plugin": ["packages/plugin-coverage/src/index.ts"], "@code-pushup/eslint-plugin": ["packages/plugin-eslint/src/index.ts"], + "@code-pushup/doc-coverage-plugin": [ + "packages/plugin-doc-coverage/src/index.ts" + ], "@code-pushup/js-packages-plugin": [ "packages/plugin-js-packages/src/index.ts" ], From 164a86a660053563fa101c3b9faf829335e6d884 Mon Sep 17 00:00:00 2001 From: Alejandro Date: Thu, 19 Dec 2024 00:08:02 +0100 Subject: [PATCH 04/39] feat: doc-processer give coverage by type of property. Some tests enhanced and some code improved --- .../mocks/component-mock.ts | 42 ++++ .../plugin-doc-coverage/src/lib/config.ts | 7 +- .../src/lib/config.unit.test.ts | 49 +---- .../src/lib/doc-coverage-plugin.ts | 2 +- .../src/lib/doc-coverage-plugin.unit.test.ts | 12 +- .../plugin-doc-coverage/src/lib/models.ts | 23 +++ .../runner/doc-processer.integration.test.ts | 21 ++ .../src/lib/runner/doc-processer.ts | 191 +++++++++++++----- .../src/lib/runner/index.ts | 110 ++++------ .../src/lib/runner/runner.integration.test.ts | 22 +- 10 files changed, 279 insertions(+), 200 deletions(-) create mode 100644 packages/plugin-doc-coverage/src/lib/runner/doc-processer.integration.test.ts diff --git a/packages/plugin-doc-coverage/mocks/component-mock.ts b/packages/plugin-doc-coverage/mocks/component-mock.ts index e66f4f859..acd80f441 100644 --- a/packages/plugin-doc-coverage/mocks/component-mock.ts +++ b/packages/plugin-doc-coverage/mocks/component-mock.ts @@ -5,3 +5,45 @@ export function DUMMY_FUNCTION() { return 'Hello World'; } + +export function DUMMY_FUNCTION_2() { + return 'Hello World 2'; +} + +class DummyClass { + /** + * Dummy property that returns 'Hello World 3'. + * @returns {string} - The string 'Hello World 3'. + */ + dummyProperty = 'Hello World 3'; + + /** + * Dummy method that returns 'Hello World 4'. + * @returns {string} - The string 'Hello World 4'. + */ + dummyMethod() { + return 'Hello World 4'; + } + + constructor() { + this.dummyProperty = 'Hello World 3'; + } +} + +export default DummyClass; + +export const variableDummy = 'Hello World 5'; + +export const variableDummy2 = 'Hello World 6'; + +/** Dummy variable that returns 'Hello World 7'. */ +export const variableDummy3 = 'Hello World 7'; + +/** Dummy interface that returns 'Hello World 8'. */ +export interface DummyInterface { + dummyProperty: string; + dummyMethod(): string; +} + +/** Dummy type that returns 'Hello World 9'. */ +export type DummyType = string; diff --git a/packages/plugin-doc-coverage/src/lib/config.ts b/packages/plugin-doc-coverage/src/lib/config.ts index a55a46137..853099796 100644 --- a/packages/plugin-doc-coverage/src/lib/config.ts +++ b/packages/plugin-doc-coverage/src/lib/config.ts @@ -3,16 +3,13 @@ import { z } from 'zod'; export type DocType = 'percentage-coverage'; export const docCoveragePluginConfigSchema = z.object({ - language: z.enum(['javascript', 'typescript'], { - description: 'Programming language of the source code to analyze', - }), sourceGlob: z .string({ description: 'Glob pattern to find source files', }) - .optional(), + .default('src/**/*.{ts,tsx}'), }); -export type DocCoveragePluginConfig = z.input< +export type DocCoveragePluginConfig = z.infer< typeof docCoveragePluginConfigSchema >; diff --git a/packages/plugin-doc-coverage/src/lib/config.unit.test.ts b/packages/plugin-doc-coverage/src/lib/config.unit.test.ts index 36840ece8..4cb85ed8a 100644 --- a/packages/plugin-doc-coverage/src/lib/config.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/config.unit.test.ts @@ -5,60 +5,23 @@ import { } from './config.js'; describe('docCoveragePluginConfigSchema', () => { - it('accepts a documentation coverage configuration with all entities', () => { + it('accepts a valid source glob pattern', () => { expect(() => docCoveragePluginConfigSchema.parse({ - language: 'typescript', sourceGlob: 'src/**/*.{ts,tsx}', } satisfies DocCoveragePluginConfig), ).not.toThrow(); }); - it('accepts minimal configuration with only language', () => { - expect(() => - docCoveragePluginConfigSchema.parse({ - language: 'javascript', - } satisfies DocCoveragePluginConfig), - ).not.toThrow(); - }); - - it('accepts configuration without sourceGlob', () => { - const config = { - language: 'typescript', - } satisfies DocCoveragePluginConfig; - const parsed = docCoveragePluginConfigSchema.parse(config); - - expect(parsed.sourceGlob).toBeUndefined(); - }); - - it('throws for missing language', () => { - expect(() => - docCoveragePluginConfigSchema.parse({ - sourceGlob: 'src/**/*.ts', - }), - ).toThrow('invalid_type'); + it('not throws for missing sourceGlob', () => { + expect(() => docCoveragePluginConfigSchema.parse({})).not.toThrow(); }); - it('throws for invalid language', () => { + it('throws for invalid sourceGlob type', () => { expect(() => docCoveragePluginConfigSchema.parse({ - language: 'python', - sourceGlob: 'src/**/*.py', + sourceGlob: 123, }), - ).toThrow('Invalid enum value'); - }); - - it('accepts both typescript and javascript as valid languages', () => { - expect(() => - docCoveragePluginConfigSchema.parse({ - language: 'typescript', - }), - ).not.toThrow(); - - expect(() => - docCoveragePluginConfigSchema.parse({ - language: 'javascript', - }), - ).not.toThrow(); + ).toThrow('Expected string'); }); }); diff --git a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts index 0504c8218..37d54858e 100644 --- a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts +++ b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts @@ -19,7 +19,7 @@ import { createRunnerConfig } from './runner/index.js'; * plugins: [ * // ... other plugins ... * await docCoveragePlugin({ - * language: 'typescript' + * sourceGlob: 'src/**/*.{ts,tsx}' * }) * ] * } diff --git a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts index 20e44b1da..992f6de6c 100644 --- a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts @@ -12,9 +12,7 @@ vi.mock('./runner/index.ts', () => ({ describe('docCoveragePlugin', () => { it('should initialise a Documentation coverage plugin', async () => { await expect( - docCoveragePlugin({ - language: 'typescript', - }), + docCoveragePlugin({ sourceGlob: 'src/**/*.ts' }), ).resolves.toStrictEqual( expect.objectContaining({ slug: 'doc-coverage', @@ -27,9 +25,7 @@ describe('docCoveragePlugin', () => { it('should generate percentage coverage audit', async () => { await expect( - docCoveragePlugin({ - language: 'typescript', - }), + docCoveragePlugin({ sourceGlob: 'src/**/*.ts' }), ).resolves.toStrictEqual( expect.objectContaining({ audits: [ @@ -47,9 +43,7 @@ describe('docCoveragePlugin', () => { it('should include package metadata', async () => { await expect( - docCoveragePlugin({ - language: 'typescript', - }), + docCoveragePlugin({ sourceGlob: 'src/**/*.ts' }), ).resolves.toStrictEqual( expect.objectContaining({ icon: 'folder-src', diff --git a/packages/plugin-doc-coverage/src/lib/models.ts b/packages/plugin-doc-coverage/src/lib/models.ts index ff4605b8c..dd61e1bdc 100644 --- a/packages/plugin-doc-coverage/src/lib/models.ts +++ b/packages/plugin-doc-coverage/src/lib/models.ts @@ -5,3 +5,26 @@ export type UndocumentedItem = { line: number; class?: string; }; + +export type CoverageByType = { + functions: number; + variables: number; + classes: number; + methods: number; + properties: number; + interfaces: number; + types: number; +}; + +export type CoverageKey = keyof CoverageByType; + +export type DocumentationStats = { + documented: number; + total: number; +}; + +export type CoverageResult = { + undocumentedItems: UndocumentedItem[]; + currentCoverage: number; + coverageByType: CoverageByType; +}; diff --git a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.integration.test.ts b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.integration.test.ts new file mode 100644 index 000000000..94bebac27 --- /dev/null +++ b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.integration.test.ts @@ -0,0 +1,21 @@ +import { processDocCoverage } from './doc-processer'; + +describe('docProcesser', () => { + it('should successfully get documentation coverage', () => { + const results = processDocCoverage( + 'packages/plugin-doc-coverage/mocks/**/*.ts', + ); + console.log(results); + expect(results).toBeDefined(); + expect(results.currentCoverage).toBe(60); + expect(results.coverageByType).toEqual({ + functions: 50, + variables: 33.33, + classes: 0, + methods: 100, + properties: 100, + interfaces: 100, + types: 100, + }); + }); +}); diff --git a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts index 86d75b343..46a2cbacf 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts @@ -1,19 +1,36 @@ import { Project } from 'ts-morph'; -import type { UndocumentedItem } from '../models.js'; +import type { + CoverageByType, + CoverageKey, + CoverageResult, + DocumentationStats, + UndocumentedItem, +} from '../models.js'; /* eslint-disable @typescript-eslint/no-explicit-any */ /* eslint-disable functional/immutable-data */ /* eslint-disable @typescript-eslint/max-params */ /* eslint-disable functional/no-let */ -export function processDocCoverage(toInclude: string): { - undocumentedItems: UndocumentedItem[]; - coverage: number; -} { +/** + * Processes documentation coverage for TypeScript files in the specified path + * @param toInclude - The file path pattern to include for documentation analysis + * @returns {CoverageResult} Object containing coverage statistics and undocumented items + */ +export function processDocCoverage(toInclude: string): CoverageResult { const project = new Project(); project.addSourceFilesAtPaths(toInclude); - let itsDocumented = 0; + const stats: Record = { + functions: { documented: 0, total: 0 }, + variables: { documented: 0, total: 0 }, + classes: { documented: 0, total: 0 }, + methods: { documented: 0, total: 0 }, + properties: { documented: 0, total: 0 }, + interfaces: { documented: 0, total: 0 }, + types: { documented: 0, total: 0 }, + }; + const undocumentedItems: UndocumentedItem[] = []; project.getSourceFiles().forEach(sourceFile => { @@ -21,127 +38,146 @@ export function processDocCoverage(toInclude: string): { return; } - processClassDeclarations( - sourceFile, - undocumentedItems, - count => (itsDocumented += count), - ); - processDeclarations( - sourceFile, - undocumentedItems, - count => (itsDocumented += count), - ); + processClassDeclarations(sourceFile, undocumentedItems, stats); + processDeclarations(sourceFile, undocumentedItems, stats); }); - return calculateCoverage(undocumentedItems, itsDocumented); + return { + undocumentedItems, + currentCoverage: calculateOverallCoverage(stats), + coverageByType: calculateCoverageByType(stats), + }; } +/** + * Checks if a file is a test file based on its path + * @param filePath - The path of the file to check + * @returns {boolean} True if the file is a test file, false otherwise + */ function isTestFile(filePath: string): boolean { return filePath.includes('.spec.') || filePath.includes('.test.'); } +/** + * Creates an undocumented item entry + * @param file - The file path where the item was found + * @param type - The type of the undocumented item + * @param name - The name of the undocumented item + * @param line - The line number where the item appears + * @returns {UndocumentedItem} The undocumented item entry + */ function addUndocumentedItem( file: string, - type: string, + type: CoverageKey, name: string, line: number, ): UndocumentedItem { - return { - file, - type, - name, - line, - }; + return { file, type, name, line }; } +/** + * Processes class declarations in a source file and updates documentation statistics + * @param sourceFile - The source file to process + * @param undocumentedItems - Array to store undocumented items found + * @param stats - Object to track documentation statistics + */ function processClassDeclarations( sourceFile: any, undocumentedItems: UndocumentedItem[], - onDocumented: (count: number) => void, + stats: Record, ): void { sourceFile.getClasses().forEach((classDeclaration: any) => { const className = classDeclaration.getName() || 'Anonymous Class'; const filePath = sourceFile.getFilePath(); + stats.classes.total++; - // Process class itself if (classDeclaration.getJsDocs().length === 0) { undocumentedItems.push( addUndocumentedItem( filePath, - 'class', + 'classes', className, classDeclaration.getStartLineNumber(), ), ); } else { - onDocumented(1); + stats.classes.documented++; } // Process properties classDeclaration.getProperties().forEach((property: any) => { + stats.properties.total++; if (property.getJsDocs().length === 0) { undocumentedItems.push( addUndocumentedItem( filePath, - 'property', + 'properties', property.getName(), property.getStartLineNumber(), ), ); } else { - onDocumented(1); + stats.properties.documented++; } }); // Process methods classDeclaration.getMethods().forEach((method: any) => { + stats.methods.total++; if (method.getJsDocs().length === 0) { undocumentedItems.push( addUndocumentedItem( filePath, - 'method', + 'methods', method.getName(), method.getStartLineNumber(), ), ); } else { - onDocumented(1); + stats.methods.documented++; } }); }); } +/** + * Processes declarations (functions, variables, interfaces, and types) in a source file + * @param sourceFile - The source file to process + * @param undocumentedItems - Array to store undocumented items found + * @param stats - Object to track documentation statistics + */ function processDeclarations( sourceFile: any, undocumentedItems: UndocumentedItem[], - onDocumented: (count: number) => void, + stats: Record, ): void { const filePath = sourceFile.getFilePath(); // Process functions processItems( sourceFile.getFunctions(), - 'function', + 'functions', item => item.getName() || 'Anonymous Function', filePath, undocumentedItems, - onDocumented, + stats, ); // Process variables sourceFile.getVariableStatements().forEach((statement: any) => { statement.getDeclarations().forEach((declaration: any) => { + stats.variables.total++; if (statement.getJsDocs().length === 0) { undocumentedItems.push( addUndocumentedItem( filePath, - 'variable', + 'variables', declaration.getName(), declaration.getStartLineNumber(), ), ); } else { - onDocumented(1); + stats.variables.documented++; } }); }); @@ -149,31 +185,41 @@ function processDeclarations( // Process interfaces and types processItems( sourceFile.getInterfaces(), - 'interface', + 'interfaces', item => item.getName(), filePath, undocumentedItems, - onDocumented, + stats, ); processItems( sourceFile.getTypeAliases(), - 'type', + 'types', item => item.getName(), filePath, undocumentedItems, - onDocumented, + stats, ); } +/** + * Generic function to process a collection of items and update documentation statistics + * @param items - Array of items to process + * @param type - The type of items being processed + * @param getName - Function to extract the name from an item + * @param filePath - The path of the file being processed + * @param undocumentedItems - Array to store undocumented items found + * @param stats - Object to track documentation statistics + */ function processItems( items: any[], - type: string, + type: CoverageKey, getName: (item: any) => string, filePath: string, undocumentedItems: UndocumentedItem[], - onDocumented: (count: number) => void, + stats: Record, ): void { items.forEach(item => { + stats[type].total++; if (item.getJsDocs().length === 0) { undocumentedItems.push( addUndocumentedItem( @@ -184,15 +230,60 @@ function processItems( ), ); } else { - onDocumented(1); + stats[type].documented++; } }); } -function calculateCoverage( - undocumentedItems: UndocumentedItem[], - documented: number, -) { - const coverage = (documented / (documented + undocumentedItems.length)) * 100; - return { undocumentedItems, coverage }; +/** + * Calculates the overall documentation coverage percentage + * @param stats - Object containing documentation statistics + * @returns {number} The overall coverage percentage (0-100) + */ +function calculateOverallCoverage( + stats: Record, +): number { + let totalDocumented = 0; + let totalItems = 0; + + Object.values(stats).forEach(({ documented, total }) => { + totalDocumented += documented; + totalItems += total; + }); + + return totalItems === 0 ? 0 : (totalDocumented / totalItems) * 100; +} + +/** + * Calculates documentation coverage percentage for each type + * @param stats - Object containing documentation statistics + * @returns {CoverageByType} Object containing coverage percentages for each type + */ +function calculateCoverageByType( + stats: Record, +): CoverageByType { + const calculatePercentage = (documented: number, total: number) => + total === 0 ? 0 : Number(((documented / total) * 100).toFixed(2)); + + return { + functions: calculatePercentage( + stats.functions.documented, + stats.functions.total, + ), + variables: calculatePercentage( + stats.variables.documented, + stats.variables.total, + ), + classes: calculatePercentage(stats.classes.documented, stats.classes.total), + methods: calculatePercentage(stats.methods.documented, stats.methods.total), + properties: calculatePercentage( + stats.properties.documented, + stats.properties.total, + ), + interfaces: calculatePercentage( + stats.interfaces.documented, + stats.interfaces.total, + ), + types: calculatePercentage(stats.types.documented, stats.types.total), + }; } diff --git a/packages/plugin-doc-coverage/src/lib/runner/index.ts b/packages/plugin-doc-coverage/src/lib/runner/index.ts index 23aed7a92..c56713ada 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/index.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/index.ts @@ -10,35 +10,19 @@ import { ui, } from '@code-pushup/utils'; import type { DocCoveragePluginConfig } from '../config.js'; -import type { UndocumentedItem } from '../models.js'; -import { - DEFAULT_SOURCE_GLOB, - PLUGIN_CONFIG_PATH, - RUNNER_OUTPUT_PATH, -} from './constants.js'; +import type { CoverageResult } from '../models.js'; +import { PLUGIN_CONFIG_PATH, RUNNER_OUTPUT_PATH } from './constants.js'; import { processDocCoverage } from './doc-processer.js'; export { PLUGIN_CONFIG_PATH, RUNNER_OUTPUT_PATH } from './constants.js'; -/** - * Execute the Typedoc process. - * @param config - The configuration for the Typedoc process. - */ -async function _executeTypedocProcess( - config: DocCoveragePluginConfig, -): Promise<{ - undocumentedItems: UndocumentedItem[]; - coverage: number; -}> { - const { sourceGlob, language } = config; - +export async function executeRunner(): Promise { try { - return processDocCoverage(sourceGlob || DEFAULT_SOURCE_GLOB[language]); - // console.table(undocumentedItems); - // await executeProcess({ - // command: COMMANDS_FOR_LANGUAGES[language].command, - // args: processedArgs.split(' '), - // }); + const config = + await readJsonFile(PLUGIN_CONFIG_PATH); + console.log(config.sourceGlob, 'dadawdawd'); + const processResult = processDocCoverage(config.sourceGlob); + await _createFinalReport(processResult); } catch (error) { if (error instanceof ProcessError) { ui().logger.error(bold('stdout from failed Typedoc process:')); @@ -52,61 +36,10 @@ async function _executeTypedocProcess( } } -/** - * Process the Typedoc results. - * @param outputFolderPath - The path to the output folder. - */ -async function _processTypedocResults( - undocumentedItems: UndocumentedItem[], - coverage: number, -): Promise { - try { - const auditOutputs: AuditOutput[] = [ - { - slug: 'percentage-coverage', - value: coverage, - score: coverage / 100, - displayValue: `${coverage} %`, - details: { - issues: undocumentedItems.map(item => ({ - message: `Missing documentation for a ${item.type}`, - source: { file: item.file, position: { startLine: item.line } }, - severity: 'warning', - })), - }, - }, - ]; - - await ensureDirectoryExists(path.dirname(RUNNER_OUTPUT_PATH)); - await writeFile(RUNNER_OUTPUT_PATH, JSON.stringify(auditOutputs)); - } catch (error) { - if (error instanceof ProcessError) { - ui().logger.error(bold('stdout from failed coverage tool process:')); - ui().logger.error(error.stdout); - ui().logger.error(bold('stderr from failed coverage tool process:')); - ui().logger.error(error.stderr); - throw new Error( - 'Doc Coverage plugin: Running Compodoc failed. Please check the error above.', - ); - } - } -} - -export async function executeRunner(): Promise { - const config = - await readJsonFile(PLUGIN_CONFIG_PATH); - const processResult = await _executeTypedocProcess(config); - await _processTypedocResults( - processResult.undocumentedItems, - processResult.coverage, - ); -} - export async function createRunnerConfig( scriptPath: string, config: DocCoveragePluginConfig, ): Promise { - // Create JSON config for executeRunner await ensureDirectoryExists(path.dirname(PLUGIN_CONFIG_PATH)); await writeFile(PLUGIN_CONFIG_PATH, JSON.stringify(config)); @@ -116,3 +49,30 @@ export async function createRunnerConfig( outputFile: RUNNER_OUTPUT_PATH, }; } + +/** + * Create the final report. + * @param coverageResult - The coverage result. + */ +async function _createFinalReport( + coverageResult: CoverageResult, +): Promise { + const auditOutputs: AuditOutput[] = [ + { + slug: 'percentage-coverage', + value: coverageResult.currentCoverage, + score: coverageResult.currentCoverage / 100, + displayValue: `${coverageResult.currentCoverage} %`, + details: { + issues: coverageResult.undocumentedItems.map(item => ({ + message: `Missing documentation for a ${item.type}`, + source: { file: item.file, position: { startLine: item.line } }, + severity: 'warning', + })), + }, + }, + ]; + + await ensureDirectoryExists(path.dirname(RUNNER_OUTPUT_PATH)); + await writeFile(RUNNER_OUTPUT_PATH, JSON.stringify(auditOutputs)); +} diff --git a/packages/plugin-doc-coverage/src/lib/runner/runner.integration.test.ts b/packages/plugin-doc-coverage/src/lib/runner/runner.integration.test.ts index 49cd966d3..8d8fe081a 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/runner.integration.test.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/runner.integration.test.ts @@ -1,10 +1,6 @@ import { writeFile } from 'node:fs/promises'; import { describe, it } from 'vitest'; -import type { - AuditOutput, - AuditOutputs, - RunnerConfig, -} from '@code-pushup/models'; +import type { AuditOutputs, RunnerConfig } from '@code-pushup/models'; import { readJsonFile, removeDirectoryIfExists } from '@code-pushup/utils'; import type { DocCoveragePluginConfig } from '../config.js'; import { @@ -17,7 +13,6 @@ import { createRunnerConfig, executeRunner } from './index.js'; describe('createRunnerConfig', () => { it('should create a valid runner config', async () => { const runnerConfig = await createRunnerConfig('executeRunner.ts', { - language: 'typescript', sourceGlob: 'src/**/*.ts', }); expect(runnerConfig).toStrictEqual({ @@ -31,7 +26,6 @@ describe('createRunnerConfig', () => { await removeDirectoryIfExists(WORKDIR); const pluginConfig: DocCoveragePluginConfig = { - language: 'typescript', sourceGlob: 'src/**/*.ts', }; @@ -46,9 +40,11 @@ describe('createRunnerConfig', () => { describe('executeRunner', () => { it( 'should successfully execute runner', + { + timeout: 60 * 1000, + }, async () => { const config: DocCoveragePluginConfig = { - language: 'typescript', sourceGlob: 'packages/plugin-doc-coverage/mocks/*.ts', }; @@ -56,15 +52,7 @@ describe('executeRunner', () => { await executeRunner(); const results = await readJsonFile(RUNNER_OUTPUT_PATH); - expect(results).toStrictEqual([ - expect.objectContaining({ - slug: 'percentage-coverage', - score: 1, - value: 100, - displayValue: '100 %', - } satisfies AuditOutput), - ]); + expect(results).toBeDefined(); }, - { timeout: 60 * 1000 }, ); }); From 3fe6e3b8cca195650eb6e42645147ac80e121f6c Mon Sep 17 00:00:00 2001 From: Alejandro Date: Fri, 20 Dec 2024 03:35:13 +0100 Subject: [PATCH 05/39] feat(plugin-doc-coverage): improve code fragmentation, tests and models. Solid version working --- code-pushup.config.bundled_oq2x2csd2at.mjs | 1210 +++++++++++++++++ code-pushup.config.ts | 19 +- code-pushup.preset.ts | 53 +- .../mocks/component-mock.spec.ts | 16 + .../mocks/component-mock.ts | 74 +- .../mocks/fixtures/angular/app.component.css | 4 + .../mocks/fixtures/angular/app.component.html | 1 + .../fixtures/angular/app.component.spec.ts | 3 + .../mocks/fixtures/angular/app.component.ts | 18 + .../fixtures/angular/map-event.function.ts | 8 + .../mocks/source-files.mock.ts | 114 ++ .../plugin-doc-coverage/src/lib/config.ts | 9 +- .../src/lib/config.unit.test.ts | 2 +- .../plugin-doc-coverage/src/lib/constants.ts | 68 + .../src/lib/doc-coverage-plugin.ts | 53 +- .../src/lib/doc-coverage-plugin.unit.test.ts | 12 +- .../plugin-doc-coverage/src/lib/models.ts | 31 +- .../doc-processer.integration.test.ts.snap | 139 ++ .../doc-processer.unit.test.ts.snap | 92 ++ .../src/lib/runner/constants.ts | 42 - .../runner/doc-processer.integration.test.ts | 34 +- .../src/lib/runner/doc-processer.ts | 350 ++--- .../src/lib/runner/doc-processer.unit.test.ts | 198 +++ .../runner/doc-processer.unit.test.ts.snap | 125 ++ .../src/lib/runner/index.ts | 78 -- .../src/lib/runner/models.ts | 37 + .../src/lib/runner/runner.integration.test.ts | 58 - .../src/lib/runner/runner.ts | 49 + .../src/lib/runner/utils.ts | 61 + packages/plugin-doc-coverage/src/lib/utils.ts | 46 + .../plugin-doc-coverage/tsconfig.test.json | 3 +- 31 files changed, 2417 insertions(+), 590 deletions(-) create mode 100644 code-pushup.config.bundled_oq2x2csd2at.mjs create mode 100644 packages/plugin-doc-coverage/mocks/component-mock.spec.ts create mode 100644 packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.css create mode 100644 packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.html create mode 100644 packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.spec.ts create mode 100644 packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.ts create mode 100644 packages/plugin-doc-coverage/mocks/fixtures/angular/map-event.function.ts create mode 100644 packages/plugin-doc-coverage/mocks/source-files.mock.ts create mode 100644 packages/plugin-doc-coverage/src/lib/constants.ts create mode 100644 packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.integration.test.ts.snap create mode 100644 packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.unit.test.ts.snap delete mode 100644 packages/plugin-doc-coverage/src/lib/runner/constants.ts create mode 100644 packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts create mode 100644 packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts.snap delete mode 100644 packages/plugin-doc-coverage/src/lib/runner/index.ts create mode 100644 packages/plugin-doc-coverage/src/lib/runner/models.ts delete mode 100644 packages/plugin-doc-coverage/src/lib/runner/runner.integration.test.ts create mode 100644 packages/plugin-doc-coverage/src/lib/runner/runner.ts create mode 100644 packages/plugin-doc-coverage/src/lib/runner/utils.ts create mode 100644 packages/plugin-doc-coverage/src/lib/utils.ts diff --git a/code-pushup.config.bundled_oq2x2csd2at.mjs b/code-pushup.config.bundled_oq2x2csd2at.mjs new file mode 100644 index 000000000..4c033e42d --- /dev/null +++ b/code-pushup.config.bundled_oq2x2csd2at.mjs @@ -0,0 +1,1210 @@ +// code-pushup.config.ts +// packages/utils/src/lib/logging.ts +import isaacs_cliui from '@isaacs/cliui'; +import { cliui } from '@poppinss/cliui'; +// packages/plugin-coverage/src/lib/runner/index.ts +import { bold } from 'ansis'; +// packages/plugin-coverage/src/lib/nx/coverage-paths.ts +import { bold as bold2 } from 'ansis'; +// packages/plugin-lighthouse/src/lib/normalize-flags.ts +import { bold as bold3, yellow } from 'ansis'; +// packages/plugin-lighthouse/src/lib/runner/utils.ts +import { bold as bold7 } from 'ansis'; +// packages/plugin-lighthouse/src/lib/runner/details/details.ts +import { bold as bold6, yellow as yellow2 } from 'ansis'; +// packages/plugin-lighthouse/src/lib/runner/details/item-value.ts +import { bold as bold4 } from 'ansis'; +// packages/plugin-lighthouse/src/lib/runner/details/utils.ts +import { bold as bold5 } from 'ansis'; +// packages/utils/src/lib/reports/utils.ts +import ansis from 'ansis'; +// packages/utils/src/lib/file-system.ts +import { bold as bold8, gray } from 'ansis'; +import { underline } from 'ansis'; +// packages/utils/src/lib/progress.ts +import { black, bold as bold9, gray as gray2, green } from 'ansis'; +// packages/utils/src/lib/reports/log-stdout-summary.ts +import { bold as bold11, cyan, cyanBright, green as green2, red } from 'ansis'; +// packages/utils/src/lib/zod-validation.ts +import { bold as bold12, red as red2 } from 'ansis'; +// packages/plugin-js-packages/src/lib/runner/audit/transform.ts +import { md } from 'build-md'; +// packages/plugin-js-packages/src/lib/runner/outdated/transform.ts +import { md as md2 } from 'build-md'; +import { md as md3 } from 'build-md'; +// packages/utils/src/lib/reports/generate-md-report.ts +import { MarkdownDocument as MarkdownDocument3, md as md6 } from 'build-md'; +// packages/utils/src/lib/reports/formatting.ts +import { MarkdownDocument, md as md4 } from 'build-md'; +// packages/utils/src/lib/reports/generate-md-report-categoy-section.ts +import { MarkdownDocument as MarkdownDocument2, md as md5 } from 'build-md'; +// packages/utils/src/lib/reports/generate-md-reports-diff.ts +import { MarkdownDocument as MarkdownDocument5, md as md8 } from 'build-md'; +// packages/utils/src/lib/reports/generate-md-reports-diff-utils.ts +import { MarkdownDocument as MarkdownDocument4, md as md7 } from 'build-md'; +import { bundleRequire } from 'bundle-require'; +// packages/plugin-lighthouse/src/lib/constants.ts +import { DEFAULT_FLAGS } from 'chrome-launcher/dist/flags.js'; +import 'dotenv/config'; +// packages/plugin-eslint/src/lib/setup.ts +import { ESLint } from 'eslint'; +// packages/plugin-eslint/src/lib/meta/versions/detect.ts +import { ESLint as ESLint2 } from 'eslint'; +// packages/plugin-eslint/src/lib/meta/versions/flat.ts +import { builtinRules } from 'eslint/use-at-your-own-risk'; +// packages/plugin-lighthouse/src/lib/runner/constants.ts +import { defaultConfig } from 'lighthouse'; +import log from 'lighthouse-logger'; +// packages/plugin-lighthouse/src/lib/runner/runner.ts +import { runLighthouse } from 'lighthouse/cli/run.js'; +import desktopConfig from 'lighthouse/core/config/desktop-config.js'; +import experimentalConfig from 'lighthouse/core/config/experimental-config.js'; +import perfConfig from 'lighthouse/core/config/perf-config.js'; +import { MultiProgressBars } from 'multi-progress-bars'; +// packages/utils/src/lib/execute-process.ts +import { spawn } from 'node:child_process'; +// packages/plugin-eslint/src/lib/meta/hash.ts +import { createHash } from 'node:crypto'; +import { writeFile } from 'node:fs/promises'; +// packages/plugin-eslint/src/lib/runner/index.ts +import { writeFile as writeFile2 } from 'node:fs/promises'; +// packages/plugin-js-packages/src/lib/runner/index.ts +import { writeFile as writeFile3 } from 'node:fs/promises'; +// packages/plugin-js-packages/src/lib/package-managers/derive-package-manager.ts +import { readFile } from 'node:fs/promises'; +import { + mkdir, + readFile as readFile2, + readdir, + rm, + stat, +} from 'node:fs/promises'; +// packages/plugin-coverage/src/lib/coverage-plugin.ts +import { createRequire } from 'node:module'; +// packages/plugin-eslint/src/lib/eslint-plugin.ts +import { createRequire as createRequire2 } from 'node:module'; +// packages/plugin-js-packages/src/lib/js-packages-plugin.ts +import { createRequire as createRequire3 } from 'node:module'; +// packages/plugin-lighthouse/src/lib/lighthouse-plugin.ts +import { createRequire as createRequire4 } from 'node:module'; +// packages/plugin-eslint/src/lib/runner/lint.ts +import { platform } from 'node:os'; +// packages/utils/src/lib/transform.ts +import { platform as platform2 } from 'node:os'; +import path4 from 'node:path'; +import path3 from 'node:path'; +// packages/plugin-coverage/src/lib/runner/constants.ts +import path from 'node:path'; +// packages/plugin-coverage/src/lib/runner/lcov/lcov-runner.ts +import path2 from 'node:path'; +import path5 from 'node:path'; +import path8 from 'node:path'; +import path6 from 'node:path'; +import path7 from 'node:path'; +// packages/plugin-eslint/src/lib/nx/utils.ts +import path9 from 'node:path'; +import path14 from 'node:path'; +// packages/plugin-js-packages/src/lib/runner/utils.ts +import path10 from 'node:path'; +import path12 from 'node:path'; +// packages/plugin-js-packages/src/lib/runner/constants.ts +import path11 from 'node:path'; +import path13 from 'node:path'; +import path15 from 'node:path'; +import path16 from 'node:path'; +import path17 from 'node:path'; +import path18 from 'node:path'; +// packages/utils/src/lib/git/git.ts +import path19 from 'node:path'; +import path20 from 'node:path'; +// packages/utils/src/lib/reports/load-report.ts +import path21 from 'node:path'; +import { fileURLToPath } from 'node:url'; +import { fileURLToPath as fileURLToPath2 } from 'node:url'; +import { pathToFileURL } from 'node:url'; +import { fileURLToPath as fileURLToPath3 } from 'node:url'; +// packages/plugin-coverage/src/lib/runner/lcov/parse-lcov.ts +import parseLcovExport from 'parse-lcov'; +import { clean, diff, neq } from 'semver'; +// packages/utils/src/lib/semver.ts +import { rcompare, valid } from 'semver'; +// packages/utils/src/lib/git/git.commits-and-tags.ts +import { simpleGit } from 'simple-git'; +import { simpleGit as simpleGit2 } from 'simple-git'; +// packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts +import { Project } from 'ts-morph'; +// packages/plugin-doc-coverage/src/lib/utils.ts +import { SyntaxKind } from 'typescript'; +import { z as z5 } from 'zod'; +// packages/plugin-coverage/src/lib/config.ts +import { z } from 'zod'; +// packages/plugin-doc-coverage/src/lib/config.ts +import { z as z2 } from 'zod'; +// packages/plugin-eslint/src/lib/config.ts +import { z as z3 } from 'zod'; +// packages/plugin-js-packages/src/lib/config.ts +import { z as z4 } from 'zod'; +import { issueSeveritySchema } from '@code-pushup/models'; +import { DEFAULT_PERSIST_OUTPUT_DIR } from '@code-pushup/models'; +// packages/plugin-lighthouse/src/lib/runner/details/opportunity.type.ts +import { tableSchema as tableSchema2 } from '@code-pushup/models'; +// packages/plugin-lighthouse/src/lib/runner/details/table.type.ts +import { tableSchema } from '@code-pushup/models'; +// packages/utils/src/index.ts +import { exists as exists4 } from '@code-pushup/models'; +// packages/utils/src/lib/formatting.ts +import { + MAX_DESCRIPTION_LENGTH, + MAX_ISSUE_MESSAGE_LENGTH, + MAX_TITLE_LENGTH, +} from '@code-pushup/models'; +import { commitSchema } from '@code-pushup/models'; +import { reportSchema } from '@code-pushup/models'; +import { capitalize } from '@code-pushup/utils'; +import { + ProcessError, + ensureDirectoryExists, + executeProcess, + filePathToCliArg, + readJsonFile, + ui as ui2, +} from '@code-pushup/utils'; +import { pluginWorkDir } from '@code-pushup/utils'; +import { exists, readTextFile, toUnixNewlines, ui } from '@code-pushup/utils'; +// packages/plugin-coverage/src/lib/runner/lcov/transform.ts +import { toNumberPrecision, toOrdinal } from '@code-pushup/utils'; +import { importModule, ui as ui3 } from '@code-pushup/utils'; +import { toArray } from '@code-pushup/utils'; +// packages/plugin-eslint/src/lib/meta/groups.ts +import { objectToKeys, slugify as slugify2 } from '@code-pushup/utils'; +import { slugify } from '@code-pushup/utils'; +// packages/plugin-eslint/src/lib/meta/parse.ts +import { toArray as toArray2 } from '@code-pushup/utils'; +import { + exists as exists2, + findNearestFile, + toArray as toArray3, + ui as ui4, +} from '@code-pushup/utils'; +// packages/plugin-eslint/src/lib/meta/versions/legacy.ts +import { + distinct, + exists as exists3, + toArray as toArray4, + ui as ui5, +} from '@code-pushup/utils'; +import { fileExists } from '@code-pushup/utils'; +// packages/plugin-eslint/src/lib/meta/transform.ts +import { truncateDescription, truncateTitle } from '@code-pushup/utils'; +import { + ensureDirectoryExists as ensureDirectoryExists2, + filePathToCliArg as filePathToCliArg3, + pluginWorkDir as pluginWorkDir2, + readJsonFile as readJsonFile2, +} from '@code-pushup/utils'; +import { + distinct as distinct2, + executeProcess as executeProcess2, + filePathToCliArg as filePathToCliArg2, + toArray as toArray5, +} from '@code-pushup/utils'; +// packages/plugin-eslint/src/lib/runner/transform.ts +import { + compareIssueSeverity, + countOccurrences, + objectToEntries, + pluralizeToken, + truncateIssueMessage, + ui as ui6, +} from '@code-pushup/utils'; +import { + fileExists as fileExists2, + toArray as toArray6, +} from '@code-pushup/utils'; +// packages/plugin-js-packages/src/lib/package-managers/npm/npm.ts +import { objectToKeys as objectToKeys3 } from '@code-pushup/utils'; +import { + crawlFileSystem, + objectFromEntries, + objectToKeys as objectToKeys2, + readJsonFile as readJsonFile3, +} from '@code-pushup/utils'; +// packages/plugin-js-packages/src/lib/package-managers/npm/audit-result.ts +import { objectToEntries as objectToEntries2 } from '@code-pushup/utils'; +// packages/plugin-js-packages/src/lib/package-managers/npm/outdated-result.ts +import { objectToEntries as objectToEntries3 } from '@code-pushup/utils'; +// packages/plugin-js-packages/src/lib/package-managers/pnpm/pnpm.ts +import { objectToKeys as objectToKeys4 } from '@code-pushup/utils'; +// packages/plugin-js-packages/src/lib/package-managers/pnpm/outdated-result.ts +import { objectToEntries as objectToEntries4 } from '@code-pushup/utils'; +// packages/plugin-js-packages/src/lib/package-managers/yarn-classic/audit-result.ts +import { fromJsonLines } from '@code-pushup/utils'; +// packages/plugin-js-packages/src/lib/package-managers/yarn-classic/outdated-result.ts +import { + fromJsonLines as fromJsonLines2, + objectFromEntries as objectFromEntries2, + objectToEntries as objectToEntries5, + objectToKeys as objectToKeys5, +} from '@code-pushup/utils'; +import { + ensureDirectoryExists as ensureDirectoryExists3, + executeProcess as executeProcess3, + filePathToCliArg as filePathToCliArg4, + isPromiseFulfilledResult, + isPromiseRejectedResult, + objectFromEntries as objectFromEntries4, + readJsonFile as readJsonFile4, +} from '@code-pushup/utils'; +import { objectToEntries as objectToEntries6 } from '@code-pushup/utils'; +import { pluginWorkDir as pluginWorkDir3 } from '@code-pushup/utils'; +import { + objectFromEntries as objectFromEntries3, + pluralize, +} from '@code-pushup/utils'; +// packages/plugin-js-packages/src/lib/runner/outdated/constants.ts +import { objectToKeys as objectToKeys6 } from '@code-pushup/utils'; +import { fileExists as fileExists3 } from '@code-pushup/utils'; +// packages/plugin-js-packages/src/lib/package-managers/derive-yarn.ts +import { executeProcess as executeProcess4 } from '@code-pushup/utils'; +import { ui as ui7 } from '@code-pushup/utils'; +import { ensureDirectoryExists as ensureDirectoryExists4 } from '@code-pushup/utils'; +import { + formatReportScore, + importModule as importModule2, + readJsonFile as readJsonFile5, + ui as ui10, +} from '@code-pushup/utils'; +import { ui as ui9 } from '@code-pushup/utils'; +import { + formatBytes as formatBytes2, + formatDuration as formatDuration2, + html as html2, +} from '@code-pushup/utils'; +import { + formatBytes, + formatDuration, + html, + truncateText, + ui as ui8, +} from '@code-pushup/utils'; +// packages/plugin-lighthouse/src/lib/utils.ts +import { filterItemRefsBy, toArray as toArray7 } from '@code-pushup/utils'; + +var coverageTypeSchema = z.enum(['function', 'branch', 'line']); +var coverageResultSchema = z.union([ + z.object({ + resultsPath: z + .string({ + description: 'Path to coverage results for Nx setup.', + }) + .includes('lcov'), + pathToProject: z + .string({ + description: + 'Path from workspace root to project root. Necessary for LCOV reports which provide a relative path.', + }) + .optional(), + }), + z + .string({ + description: 'Path to coverage results for a single project setup.', + }) + .includes('lcov'), +]); +var coveragePluginConfigSchema = z.object({ + coverageToolCommand: z + .object({ + command: z + .string({ description: 'Command to run coverage tool.' }) + .min(1), + args: z + .array(z.string(), { + description: 'Arguments to be passed to the coverage tool.', + }) + .optional(), + }) + .optional(), + coverageTypes: z + .array(coverageTypeSchema, { + description: 'Coverage types measured. Defaults to all available types.', + }) + .min(1) + .default(['function', 'branch', 'line']), + reports: z + .array(coverageResultSchema, { + description: + 'Path to all code coverage report files. Only LCOV format is supported for now.', + }) + .min(1), + perfectScoreThreshold: z + .number({ + description: + 'Score will be 1 (perfect) for this coverage and above. Score range is 0 - 1.', + }) + .gt(0) + .max(1) + .optional(), +}); + +var WORKDIR = pluginWorkDir('coverage'); +var RUNNER_OUTPUT_PATH = path.join(WORKDIR, 'runner-output.json'); +var PLUGIN_CONFIG_PATH = path.join( + process.cwd(), + WORKDIR, + 'plugin-config.json', +); + +var godKnows = parseLcovExport; +var parseLcov = 'default' in godKnows ? godKnows.default : godKnows; + +var docCoveragePluginConfigSchema = z2.object({ + onlyAudits: z2.array(z2.string()).optional(), + sourceGlob: z2 + .array(z2.string()) + .default(['src/**/*.{ts,tsx}', '!**/*.spec.ts', '!**/*.test.ts']), +}); + +// packages/plugin-doc-coverage/src/lib/constants.ts +var PLUGIN_SLUG = 'doc-coverage'; +var AUDITS_MAP = { + 'classes-coverage': { + slug: 'classes-coverage', + title: 'Classes coverage', + description: 'Coverage of classes', + }, + 'methods-coverage': { + slug: 'methods-coverage', + title: 'Methods coverage', + description: 'Coverage of methods', + }, + 'functions-coverage': { + slug: 'functions-coverage', + title: 'Functions coverage', + description: 'Coverage of functions', + }, + 'interfaces-coverage': { + slug: 'interfaces-coverage', + title: 'Interfaces coverage', + description: 'Coverage of interfaces', + }, + 'variables-coverage': { + slug: 'variables-coverage', + title: 'Variables coverage', + description: 'Coverage of variables', + }, + 'properties-coverage': { + slug: 'properties-coverage', + title: 'Properties coverage', + description: 'Coverage of properties', + }, + 'types-coverage': { + slug: 'types-coverage', + title: 'Types coverage', + description: 'Coverage of types', + }, + 'enums-coverage': { + slug: 'enums-coverage', + title: 'Enums coverage', + description: 'Coverage of enums', + }, +}; +var groups = [ + { + slug: 'documentation-coverage', + title: 'Documentation coverage', + description: 'Documentation coverage', + refs: Object.keys(AUDITS_MAP).map(slug => { + switch (slug) { + case 'classes-coverage': + case 'functions-coverage': + case 'methods-coverage': + return { slug, weight: 2 }; + case 'interfaces-coverage': + case 'properties-coverage': + case 'types-coverage': + default: + return { slug, weight: 1 }; + } + }), + }, +]; + +function filterAuditsByPluginConfig(config2) { + const { onlyAudits } = config2; + if (!onlyAudits || onlyAudits.length === 0) { + return Object.values(AUDITS_MAP); + } + return Object.values(AUDITS_MAP).filter(audit => + onlyAudits.includes(audit.slug), + ); +} +function filterGroupsByOnlyAudits(groups2, options) { + const audits2 = filterAuditsByPluginConfig(options); + return groups2 + .map(group => ({ + ...group, + refs: group.refs.filter(ref => + audits2.some(audit => audit.slug === ref.slug), + ), + })) + .filter(group => group.refs.length > 0); +} +function trasformCoverageReportToAudits(coverageResult, options) { + return Object.entries(coverageResult) + .filter( + ([type]) => + !options.onlyAudits?.length || + options.onlyAudits.includes(`${type}-coverage`), + ) + .map(([type, items]) => { + const coverageType = type; + const coverage = items.coverage; + return { + slug: `${coverageType}-coverage`, + value: coverage, + score: coverage / 100, + displayValue: `${coverage} %`, + details: { + issues: items.issues.map(({ file, line }) => ({ + message: 'Missing documentation', + source: { file, position: { startLine: line } }, + severity: 'warning', + })), + }, + }; + }); +} +function getCoverageTypeFromKind(kind) { + switch (kind) { + case SyntaxKind.ClassDeclaration: + return 'classes'; + case SyntaxKind.MethodDeclaration: + return 'methods'; + case SyntaxKind.FunctionDeclaration: + return 'functions'; + case SyntaxKind.InterfaceDeclaration: + return 'interfaces'; + case SyntaxKind.EnumDeclaration: + return 'enums'; + case SyntaxKind.VariableDeclaration: + return 'variables'; + case SyntaxKind.PropertyDeclaration: + return 'properties'; + case SyntaxKind.TypeAliasDeclaration: + return 'types'; + default: + throw new Error(`Unsupported syntax kind: ${kind}`); + } +} + +// packages/plugin-doc-coverage/src/lib/runner/utils.ts +function createEmptyUnprocessedCoverageReport() { + return { + enums: { nodesCount: 0, issues: [] }, + interfaces: { nodesCount: 0, issues: [] }, + types: { nodesCount: 0, issues: [] }, + functions: { nodesCount: 0, issues: [] }, + variables: { nodesCount: 0, issues: [] }, + classes: { nodesCount: 0, issues: [] }, + methods: { nodesCount: 0, issues: [] }, + properties: { nodesCount: 0, issues: [] }, + }; +} +function calculateCoverage2(result) { + return Object.fromEntries( + Object.entries(result).map(([key, value]) => { + const type = key; + return [ + type, + { + coverage: + value.nodesCount === 0 + ? 100 + : (1 - value.issues.length / value.nodesCount) * 100, + issues: value.issues, + nodesCount: value.nodesCount, + }, + ]; + }), + ); +} + +// packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts +function processDocCoverage(config2) { + const project = new Project(); + project.addSourceFilesAtPaths(config2.sourceGlob); + return getUnprocessedCoverageReport(project.getSourceFiles()); +} +function getUnprocessedCoverageReport(sourceFiles) { + const unprocessedCoverageReport = sourceFiles.reduce( + (coverageReportOfAllFiles, sourceFile) => { + const filePath = sourceFile.getFilePath(); + const classes = sourceFile.getClasses(); + const allNodesFromFile = [ + ...sourceFile.getFunctions(), + ...classes, + ...getClassNodes(classes), + ...sourceFile.getTypeAliases(), + ...sourceFile.getEnums(), + ...sourceFile.getInterfaces(), + // ...sourceFile.getVariableStatements().flatMap(statement => statement.getDeclarations()) + ]; + const coverageReportOfCurrentFile = allNodesFromFile.reduce( + (acc, node) => { + const nodeType = getCoverageTypeFromKind(node.getKind()); + acc[nodeType].nodesCount++; + if (node.getJsDocs().length === 0) { + acc[nodeType].issues.push( + getUndocumentedNode( + filePath, + nodeType, + node.getName() || '', + node.getStartLineNumber(), + ), + ); + } + return acc; + }, + createEmptyUnprocessedCoverageReport(), + ); + return mergeCoverageResults( + coverageReportOfAllFiles, + coverageReportOfCurrentFile, + ); + }, + createEmptyUnprocessedCoverageReport(), + ); + return calculateCoverage2(unprocessedCoverageReport); +} +function mergeCoverageResults(results, current) { + return { + ...Object.fromEntries( + Object.entries(results).map(([key, value]) => { + const node = value; + const type = key; + return [ + type, + { + nodesCount: node.nodesCount + current[type].nodesCount, + issues: [...node.issues, ...current[type].issues], + }, + ]; + }), + ), + }; +} +function getClassNodes(classNodes) { + return classNodes.flatMap(classNode => [ + ...classNode.getMethods(), + ...classNode.getProperties(), + ]); +} +function getUndocumentedNode(file, type, name, line) { + return { file, type, name, line }; +} + +// packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts +var PLUGIN_TITLE = 'Documentation coverage'; +var PLUGIN_DESCRIPTION = 'Official Code PushUp documentation coverage plugin.'; +var PLUGIN_DOCS_URL = + 'https://www.npmjs.com/package/@code-pushup/doc-coverage-plugin/'; +async function docCoveragePlugin(config2) { + const docCoverageConfig = docCoveragePluginConfigSchema.parse(config2); + const groupsC = filterGroupsByOnlyAudits(groups, docCoverageConfig); + const auditsC = filterAuditsByPluginConfig(docCoverageConfig); + return { + slug: PLUGIN_SLUG, + title: PLUGIN_TITLE, + icon: 'folder-src', + description: PLUGIN_DESCRIPTION, + docsUrl: PLUGIN_DOCS_URL, + groups: filterGroupsByOnlyAudits(groups, docCoverageConfig), + audits: filterAuditsByPluginConfig(docCoverageConfig), + runner: createRunnerFunction(docCoverageConfig), + }; +} +function createRunnerFunction(config2) { + return () => { + const coverageResult = processDocCoverage(config2); + return trasformCoverageReportToAudits(coverageResult, config2); + }; +} + +// packages/plugin-doc-coverage/src/index.ts +var src_default = docCoveragePlugin; + +var patternsSchema = z3.union([z3.string(), z3.array(z3.string()).min(1)], { + description: + 'Lint target files. May contain file paths, directory paths or glob patterns', +}); +var eslintrcSchema = z3.string({ description: 'Path to ESLint config file' }); +var eslintTargetObjectSchema = z3.object({ + eslintrc: eslintrcSchema.optional(), + patterns: patternsSchema, +}); +var eslintTargetSchema = z3 + .union([patternsSchema, eslintTargetObjectSchema]) + .transform(target => + typeof target === 'string' || Array.isArray(target) + ? { patterns: target } + : target, + ); +var eslintPluginConfigSchema = z3 + .union([eslintTargetSchema, z3.array(eslintTargetSchema).min(1)]) + .transform(toArray); + +// packages/plugin-eslint/src/lib/runner/index.ts +var WORKDIR2 = pluginWorkDir2('eslint'); +var RUNNER_OUTPUT_PATH2 = path7.join(WORKDIR2, 'runner-output.json'); +var PLUGIN_CONFIG_PATH2 = path7.join( + process.cwd(), + WORKDIR2, + 'plugin-config.json', +); + +// packages/plugin-js-packages/src/lib/constants.ts +var defaultAuditLevelMapping = { + critical: 'error', + high: 'error', + moderate: 'warning', + low: 'warning', + info: 'info', +}; + +// packages/plugin-js-packages/src/lib/config.ts +var dependencyGroups = ['prod', 'dev', 'optional']; +var dependencyGroupSchema = z4.enum(dependencyGroups); +var packageCommandSchema = z4.enum(['audit', 'outdated']); +var packageManagerIdSchema = z4.enum([ + 'npm', + 'yarn-classic', + 'yarn-modern', + 'pnpm', +]); +var packageJsonPathSchema = z4 + .union([ + z4.array(z4.string()).min(1), + z4.object({ autoSearch: z4.literal(true) }), + ]) + .describe( + 'File paths to package.json. Looks only at root package.json by default', + ) + .default(['package.json']); +var packageAuditLevels = ['critical', 'high', 'moderate', 'low', 'info']; +var packageAuditLevelSchema = z4.enum(packageAuditLevels); +function fillAuditLevelMapping(mapping) { + return { + critical: mapping.critical ?? defaultAuditLevelMapping.critical, + high: mapping.high ?? defaultAuditLevelMapping.high, + moderate: mapping.moderate ?? defaultAuditLevelMapping.moderate, + low: mapping.low ?? defaultAuditLevelMapping.low, + info: mapping.info ?? defaultAuditLevelMapping.info, + }; +} +var jsPackagesPluginConfigSchema = z4.object({ + checks: z4 + .array(packageCommandSchema, { + description: + 'Package manager commands to be run. Defaults to both audit and outdated.', + }) + .min(1) + .default(['audit', 'outdated']), + packageManager: packageManagerIdSchema + .describe('Package manager to be used.') + .optional(), + dependencyGroups: z4 + .array(dependencyGroupSchema) + .min(1) + .default(['prod', 'dev']), + auditLevelMapping: z4 + .record(packageAuditLevelSchema, issueSeveritySchema, { + description: + 'Mapping of audit levels to issue severity. Custom mapping or overrides may be entered manually, otherwise has a default preset.', + }) + .default(defaultAuditLevelMapping) + .transform(fillAuditLevelMapping), + packageJsonPaths: packageJsonPathSchema, +}); + +function filterAuditResult(result, key, referenceResult) { + if (result.vulnerabilities.length === 0) { + return result; + } + const uniqueResult = result.vulnerabilities.reduce( + (acc, ref) => { + const matchReference = referenceResult ?? acc; + const isMatch = matchReference.vulnerabilities + .map(vulnerability => vulnerability[key]) + .includes(ref[key]); + if (isMatch) { + return { + vulnerabilities: acc.vulnerabilities, + summary: { + ...acc.summary, + [ref.severity]: acc.summary[ref.severity] - 1, + total: acc.summary.total - 1, + }, + }; + } + return { + vulnerabilities: [...acc.vulnerabilities, ref], + summary: acc.summary, + }; + }, + { vulnerabilities: [], summary: result.summary }, + ); + return { + vulnerabilities: uniqueResult.vulnerabilities, + summary: uniqueResult.summary, + }; +} + +// packages/plugin-js-packages/src/lib/package-managers/constants.ts +var COMMON_AUDIT_ARGS = ['audit', '--json']; +var COMMON_OUTDATED_ARGS = ['outdated', '--json']; + +function npmToAuditResult(output) { + const npmAudit = JSON.parse(output); + const vulnerabilities = objectToEntries2(npmAudit.vulnerabilities).map( + ([name, detail]) => { + const advisory = npmToAdvisory(name, npmAudit.vulnerabilities); + return { + name: name.toString(), + severity: detail.severity, + versionRange: detail.range, + directDependency: detail.isDirect ? true : (detail.effects[0] ?? ''), + fixInformation: npmToFixInformation(detail.fixAvailable), + ...(advisory != null && { + title: advisory.title, + url: advisory.url, + }), + }; + }, + ); + return { + vulnerabilities, + summary: npmAudit.metadata.vulnerabilities, + }; +} +function npmToFixInformation(fixAvailable) { + if (typeof fixAvailable === 'boolean') { + return fixAvailable ? 'Fix is available.' : ''; + } + return `Fix available: Update \`${fixAvailable.name}\` to version **${fixAvailable.version}**${fixAvailable.isSemVerMajor ? ' (breaking change).' : '.'}`; +} +function npmToAdvisory( + name, + vulnerabilities, + prevNodes = /* @__PURE__ */ new Set(), +) { + const advisory = vulnerabilities[name]?.via; + if ( + Array.isArray(advisory) && + advisory.length > 0 && + typeof advisory[0] === 'object' + ) { + return { title: advisory[0].title, url: advisory[0].url }; + } + if ( + Array.isArray(advisory) && + advisory.length > 0 && + advisory.every(value => typeof value === 'string') + ) { + let advisoryInfo = null; + let newReferences = []; + let advisoryInfoFound = false; + for (const via of advisory) { + if (!prevNodes.has(via)) { + newReferences.push(via); + } + } + while (newReferences.length > 0 && !advisoryInfoFound) { + const ref = newReferences.pop(); + prevNodes.add(ref); + const result = npmToAdvisory(ref, vulnerabilities, prevNodes); + if (result != null) { + advisoryInfo = { title: result.title, url: result.url }; + advisoryInfoFound = true; + } + } + return advisoryInfo; + } + return null; +} + +function npmToOutdatedResult(output) { + const npmOutdated = JSON.parse(output); + return objectToEntries3(npmOutdated) + .filter(entry => entry[1].current != null) + .map(([name, overview]) => ({ + name, + current: overview.current, + latest: overview.latest, + type: overview.type, + ...(overview.homepage != null && { url: overview.homepage }), + })); +} + +// packages/plugin-js-packages/src/lib/package-managers/npm/npm.ts +var npmDependencyOptions = { + prod: ['--omit=dev', '--omit=optional'], + dev: ['--include=dev', '--omit=optional'], + optional: ['--include=optional', '--omit=dev'], +}; +var npmPackageManager = { + slug: 'npm', + name: 'NPM', + command: 'npm', + icon: 'npm', + docs: { + homepage: 'https://docs.npmjs.com/', + audit: 'https://docs.npmjs.com/cli/commands/npm-audit', + outdated: 'https://docs.npmjs.com/cli/commands/npm-outdated', + }, + audit: { + getCommandArgs: groupDep => [ + ...COMMON_AUDIT_ARGS, + ...npmDependencyOptions[groupDep], + '--audit-level=none', + ], + unifyResult: npmToAuditResult, + // prod dependencies need to be filtered out manually since v10 + postProcessResult: results => { + const depGroups = objectToKeys3(results); + const devFilter = + results.dev && results.prod + ? filterAuditResult(results.dev, 'name', results.prod) + : results.dev; + const optionalFilter = + results.optional && results.prod + ? filterAuditResult(results.optional, 'name', results.prod) + : results.optional; + return { + ...(depGroups.includes('prod') && { prod: results.prod }), + ...(depGroups.includes('dev') && { dev: devFilter }), + ...(depGroups.includes('optional') && { optional: optionalFilter }), + }; + }, + }, + outdated: { + commandArgs: [...COMMON_OUTDATED_ARGS, '--long'], + unifyResult: npmToOutdatedResult, + }, +}; + +var WORKDIR3 = pluginWorkDir3('js-packages'); +var RUNNER_OUTPUT_PATH3 = path11.join(WORKDIR3, 'runner-output.json'); +var PLUGIN_CONFIG_PATH3 = path11.join( + process.cwd(), + WORKDIR3, + 'plugin-config.json', +); + +var outdatedSeverity = { + major: 'error', + premajor: 'info', + minor: 'warning', + preminor: 'info', + patch: 'info', + prepatch: 'info', + prerelease: 'info', +}; +var RELEASE_TYPES = objectToKeys6(outdatedSeverity); + +var DEFAULT_CHROME_FLAGS = [...DEFAULT_FLAGS, '--headless']; +var LIGHTHOUSE_PLUGIN_SLUG = 'lighthouse'; +var LIGHTHOUSE_OUTPUT_PATH = path15.join( + DEFAULT_PERSIST_OUTPUT_DIR, + LIGHTHOUSE_PLUGIN_SLUG, +); + +var { audits, categories } = defaultConfig; +var allRawLighthouseAudits = await Promise.all( + (audits ?? []).map(loadLighthouseAudit), +); +var LIGHTHOUSE_NAVIGATION_AUDITS = allRawLighthouseAudits + .filter( + audit => + audit.meta.supportedModes == null || + (Array.isArray(audit.meta.supportedModes) && + audit.meta.supportedModes.includes('navigation')), + ) + .map(audit => ({ + slug: audit.meta.id, + title: getMetaString(audit.meta.title), + description: getMetaString(audit.meta.description), + })); +var navigationAuditSlugs = new Set( + LIGHTHOUSE_NAVIGATION_AUDITS.map(({ slug }) => slug), +); +var LIGHTHOUSE_GROUPS = Object.entries(categories ?? {}).map( + ([id, category]) => ({ + slug: id, + title: getMetaString(category.title), + ...(category.description && { + description: getMetaString(category.description), + }), + refs: category.auditRefs + .filter(({ id: auditSlug }) => navigationAuditSlugs.has(auditSlug)) + .map(ref => ({ + slug: ref.id, + weight: ref.weight, + })), + }), +); +function getMetaString(value) { + if (typeof value === 'string') { + return value; + } + return value.formattedDefault; +} +async function loadLighthouseAudit(value) { + if (typeof value === 'object' && 'implementation' in value) { + return value.implementation; + } + if (typeof value === 'function') { + return value; + } + const file = typeof value === 'string' ? value : value.path; + const module = await import(`lighthouse/core/audits/${file}.js`); + return module.default; +} +var LIGHTHOUSE_REPORT_NAME = 'lighthouse-report.json'; +var DEFAULT_CLI_FLAGS = { + // default values extracted from + // https://github.com/GoogleChrome/lighthouse/blob/7d80178c37a1b600ea8f092fc0b098029799a659/cli/cli-flags.js#L80 + verbose: false, + saveAssets: false, + chromeFlags: DEFAULT_CHROME_FLAGS, + port: 0, + hostname: '127.0.0.1', + view: false, + channel: 'cli', + // custom overwrites in favour of the plugin + // hide logs by default + quiet: true, + onlyAudits: [], + skipAudits: [], + onlyCategories: [], + output: ['json'], + outputPath: path16.join(LIGHTHOUSE_OUTPUT_PATH, LIGHTHOUSE_REPORT_NAME), +}; + +// packages/plugin-lighthouse/src/lib/normalize-flags.ts +var { onlyCategories, ...originalDefaultCliFlags } = DEFAULT_CLI_FLAGS; +var DEFAULT_LIGHTHOUSE_OPTIONS = { + ...originalDefaultCliFlags, + onlyGroups: onlyCategories, +}; +var lighthouseUnsupportedCliFlags = [ + 'precomputedLanternDataPath', + // Path to the file where precomputed lantern data should be read from. + 'chromeIgnoreDefaultFlags', + // ignore default flags from Lighthouse CLI + // No error reporting implemented as in the source Sentry was involved + // See: https://github.com/GoogleChrome/lighthouse/blob/d8ccf70692216b7fa047a4eaa2d1277b0b7fe947/cli/bin.js#L124 + 'enableErrorReporting', + // enable error reporting + // lighthouse CLI specific debug logs + 'list-all-audits', + // Prints a list of all available audits and exits. + 'list-locales', + // Prints a list of all supported locales and exits. + 'list-trace-categories', + // Prints a list of all required trace categories and exits. +]; +var LIGHTHOUSE_UNSUPPORTED_CLI_FLAGS = new Set(lighthouseUnsupportedCliFlags); + +function lighthouseGroupRef(groupSlug, weight = 1) { + return { + plugin: LIGHTHOUSE_PLUGIN_SLUG, + slug: groupSlug, + type: 'group', + weight, + }; +} + +// code-pushup.preset.ts +var lighthouseCategories = [ + { + slug: 'performance', + title: 'Performance', + refs: [lighthouseGroupRef('performance')], + }, + { + slug: 'a11y', + title: 'Accessibility', + refs: [lighthouseGroupRef('accessibility')], + }, + { + slug: 'best-practices', + title: 'Best Practices', + refs: [lighthouseGroupRef('best-practices')], + }, + { + slug: 'seo', + title: 'SEO', + refs: [lighthouseGroupRef('seo')], + }, +]; +function getDocCoverageCategories(config2) { + return [ + { + slug: 'doc-coverage-cat', + title: 'Documentation coverage', + description: 'Measures how much of your code is **documented**.', + refs: filterGroupsByOnlyAudits(groups, config2).map(group => ({ + weight: 1, + type: 'group', + plugin: PLUGIN_SLUG, + slug: group.slug, + })), + }, + ]; +} +var docCoverageCoreConfig = async config2 => { + return { + plugins: [await src_default(config2)], + categories: getDocCoverageCategories(config2), + }; +}; + +// packages/utils/src/lib/merge-configs.ts +function mergeConfigs(config2, ...configs) { + return configs.reduce( + (acc, obj) => ({ + ...acc, + ...mergeCategories(acc.categories, obj.categories), + ...mergePlugins(acc.plugins, obj.plugins), + ...mergePersist(acc.persist, obj.persist), + ...mergeUpload(acc.upload, obj.upload), + }), + config2, + ); +} +function mergeCategories(a, b) { + if (!a && !b) { + return {}; + } + const mergedMap = /* @__PURE__ */ new Map(); + const addToMap = categories2 => { + categories2.forEach(newObject => { + if (mergedMap.has(newObject.slug)) { + const existingObject = mergedMap.get(newObject.slug); + mergedMap.set(newObject.slug, { + ...existingObject, + ...newObject, + refs: mergeByUniqueCategoryRefCombination( + existingObject?.refs, + newObject.refs, + ), + }); + } else { + mergedMap.set(newObject.slug, newObject); + } + }); + }; + if (a) { + addToMap(a); + } + if (b) { + addToMap(b); + } + return { categories: [...mergedMap.values()] }; +} +function mergePlugins(a, b) { + if (!a && !b) { + return { plugins: [] }; + } + const mergedMap = /* @__PURE__ */ new Map(); + const addToMap = plugins => { + plugins.forEach(newObject => { + mergedMap.set(newObject.slug, newObject); + }); + }; + if (a) { + addToMap(a); + } + if (b) { + addToMap(b); + } + return { plugins: [...mergedMap.values()] }; +} +function mergePersist(a, b) { + if (!a && !b) { + return {}; + } + if (a) { + return b ? { persist: { ...a, ...b } } : {}; + } else { + return { persist: b }; + } +} +function mergeByUniqueCategoryRefCombination(a, b) { + const map = /* @__PURE__ */ new Map(); + const addToMap = refs => { + refs.forEach(ref => { + const uniqueIdentification = `${ref.type}:${ref.plugin}:${ref.slug}`; + if (map.has(uniqueIdentification)) { + map.set(uniqueIdentification, { + ...map.get(uniqueIdentification), + ...ref, + }); + } else { + map.set(uniqueIdentification, ref); + } + }); + }; + if (a) { + addToMap(a); + } + if (b) { + addToMap(b); + } + return [...map.values()]; +} +function mergeUpload(a, b) { + if (!a && !b) { + return {}; + } + if (a) { + return b ? { upload: { ...a, ...b } } : {}; + } else { + return { upload: b }; + } +} + +// code-pushup.config.ts +var envSchema = z5.object({ + CP_SERVER: z5.string().url(), + CP_API_KEY: z5.string().min(1), + CP_ORGANIZATION: z5.string().min(1), + CP_PROJECT: z5.string().min(1), +}); +var { data: env } = await envSchema.safeParseAsync(process.env); +var config = { + ...(env && { + upload: { + server: env.CP_SERVER, + apiKey: env.CP_API_KEY, + organization: env.CP_ORGANIZATION, + project: env.CP_PROJECT, + }, + }), + plugins: [], +}; +var code_pushup_config_default = mergeConfigs( + config, + // await coverageCoreConfigNx(), + // await jsPackagesCoreConfig(), + // await lighthouseCoreConfig( + // 'https://github.com/code-pushup/cli?tab=readme-ov-file#code-pushup-cli/', + // ), + // await eslintCoreConfigNx(), + await docCoverageCoreConfig({ + sourceGlob: ['packages/**/*.ts', '!**/*.spec.ts', '!**/*.test.ts'], + onlyAudits: ['methods-coverage', 'functions-coverage'], + }), +); +export { code_pushup_config_default as default }; +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["code-pushup.config.ts", "packages/plugin-coverage/src/lib/coverage-plugin.ts", "packages/plugin-coverage/src/lib/config.ts", "packages/plugin-coverage/src/lib/runner/index.ts", "packages/plugin-coverage/src/lib/runner/constants.ts", "packages/plugin-coverage/src/lib/runner/lcov/lcov-runner.ts", "packages/plugin-coverage/src/lib/runner/lcov/parse-lcov.ts", "packages/plugin-coverage/src/lib/runner/lcov/transform.ts", "packages/plugin-coverage/src/lib/nx/coverage-paths.ts", "packages/plugin-doc-coverage/src/lib/config.ts", "packages/plugin-doc-coverage/src/lib/constants.ts", "packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts", "packages/plugin-doc-coverage/src/lib/utils.ts", "packages/plugin-doc-coverage/src/lib/runner/utils.ts", "packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts", "packages/plugin-doc-coverage/src/index.ts", "packages/plugin-eslint/src/lib/eslint-plugin.ts", "packages/plugin-eslint/src/lib/config.ts", "packages/plugin-eslint/src/lib/meta/groups.ts", "packages/plugin-eslint/src/lib/meta/hash.ts", "packages/plugin-eslint/src/lib/meta/parse.ts", "packages/plugin-eslint/src/lib/meta/versions/flat.ts", "packages/plugin-eslint/src/lib/meta/versions/legacy.ts", "packages/plugin-eslint/src/lib/setup.ts", "packages/plugin-eslint/src/lib/meta/versions/detect.ts", "packages/plugin-eslint/src/lib/meta/transform.ts", "packages/plugin-eslint/src/lib/runner/index.ts", "packages/plugin-eslint/src/lib/runner/lint.ts", "packages/plugin-eslint/src/lib/runner/transform.ts", "packages/plugin-eslint/src/lib/nx/utils.ts", "packages/plugin-js-packages/src/lib/js-packages-plugin.ts", "packages/plugin-js-packages/src/lib/config.ts", "packages/plugin-js-packages/src/lib/constants.ts", "packages/plugin-js-packages/src/lib/package-managers/npm/npm.ts", "packages/plugin-js-packages/src/lib/runner/utils.ts", "packages/plugin-js-packages/src/lib/package-managers/constants.ts", "packages/plugin-js-packages/src/lib/package-managers/npm/audit-result.ts", "packages/plugin-js-packages/src/lib/package-managers/npm/outdated-result.ts", "packages/plugin-js-packages/src/lib/package-managers/pnpm/pnpm.ts", "packages/plugin-js-packages/src/lib/package-managers/pnpm/outdated-result.ts", "packages/plugin-js-packages/src/lib/package-managers/yarn-classic/audit-result.ts", "packages/plugin-js-packages/src/lib/package-managers/yarn-classic/outdated-result.ts", "packages/plugin-js-packages/src/lib/runner/index.ts", "packages/plugin-js-packages/src/lib/runner/audit/transform.ts", "packages/plugin-js-packages/src/lib/runner/constants.ts", "packages/plugin-js-packages/src/lib/runner/outdated/transform.ts", "packages/plugin-js-packages/src/lib/runner/outdated/constants.ts", "packages/plugin-js-packages/src/lib/package-managers/derive-package-manager.ts", "packages/plugin-js-packages/src/lib/package-managers/derive-yarn.ts", "packages/plugin-lighthouse/src/lib/lighthouse-plugin.ts", "packages/plugin-lighthouse/src/lib/constants.ts", "packages/plugin-lighthouse/src/lib/normalize-flags.ts", "packages/plugin-lighthouse/src/lib/runner/constants.ts", "packages/plugin-lighthouse/src/lib/runner/runner.ts", "packages/plugin-lighthouse/src/lib/runner/utils.ts", "packages/plugin-lighthouse/src/lib/runner/details/details.ts", "packages/plugin-lighthouse/src/lib/runner/details/opportunity.type.ts", "packages/plugin-lighthouse/src/lib/runner/details/table.type.ts", "packages/plugin-lighthouse/src/lib/runner/details/item-value.ts", "packages/plugin-lighthouse/src/lib/runner/details/utils.ts", "packages/plugin-lighthouse/src/lib/utils.ts", "code-pushup.preset.ts", "packages/utils/src/index.ts", "packages/utils/src/lib/execute-process.ts", "packages/utils/src/lib/reports/utils.ts", "packages/utils/src/lib/file-system.ts", "packages/utils/src/lib/formatting.ts", "packages/utils/src/lib/logging.ts", "packages/utils/src/lib/git/git.commits-and-tags.ts", "packages/utils/src/lib/semver.ts", "packages/utils/src/lib/git/git.ts", "packages/utils/src/lib/transform.ts", "packages/utils/src/lib/merge-configs.ts", "packages/utils/src/lib/progress.ts", "packages/utils/src/lib/reports/generate-md-report.ts", "packages/utils/src/lib/reports/formatting.ts", "packages/utils/src/lib/reports/generate-md-report-categoy-section.ts", "packages/utils/src/lib/reports/generate-md-reports-diff.ts", "packages/utils/src/lib/reports/generate-md-reports-diff-utils.ts", "packages/utils/src/lib/reports/load-report.ts", "packages/utils/src/lib/reports/log-stdout-summary.ts", "packages/utils/src/lib/zod-validation.ts"],
  "sourcesContent": ["const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/code-pushup.config.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/code-pushup.config.ts\";import 'dotenv/config';\nimport { z } from 'zod';\nimport { docCoverageCoreConfig } from './code-pushup.preset.js';\nimport type { CoreConfig } from './packages/models/src/index.js';\nimport { mergeConfigs } from './packages/utils/src/index.js';\n// load upload configuration from environment\nconst envSchema = z.object({\n  CP_SERVER: z.string().url(),\n  CP_API_KEY: z.string().min(1),\n  CP_ORGANIZATION: z.string().min(1),\n  CP_PROJECT: z.string().min(1),\n});\nconst { data: env } = await envSchema.safeParseAsync(process.env);\n\nconst config: CoreConfig = {\n  ...(env && {\n    upload: {\n      server: env.CP_SERVER,\n      apiKey: env.CP_API_KEY,\n      organization: env.CP_ORGANIZATION,\n      project: env.CP_PROJECT,\n    },\n  }),\n\n  plugins: [],\n};\n\nexport default mergeConfigs(\n  config,\n  // await coverageCoreConfigNx(),\n  // await jsPackagesCoreConfig(),\n  // await lighthouseCoreConfig(\n  //   'https://github.com/code-pushup/cli?tab=readme-ov-file#code-pushup-cli/',\n  // ),\n  // await eslintCoreConfigNx(),\n  await docCoverageCoreConfig({\n    sourceGlob: ['packages/**/*.ts', '!**/*.spec.ts', '!**/*.test.ts'],\n    onlyAudits: ['methods-coverage', 'functions-coverage']\n  }),\n);\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/coverage-plugin.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/coverage-plugin.ts\";import { createRequire } from 'node:module';\nimport path from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport type { Audit, Group, PluginConfig } from '@code-pushup/models';\nimport { capitalize } from '@code-pushup/utils';\nimport {\n  type CoveragePluginConfig,\n  type CoverageType,\n  coveragePluginConfigSchema,\n} from './config.js';\nimport { createRunnerConfig } from './runner/index.js';\nimport { coverageDescription, coverageTypeWeightMapper } from './utils.js';\n\n/**\n * Instantiates Code PushUp code coverage plugin for core config.\n *\n * @example\n * import coveragePlugin from '@code-pushup/coverage-plugin'\n *\n * export default {\n *   // ... core config ...\n *   plugins: [\n *     // ... other plugins ...\n *     await coveragePlugin({\n *       reports: [{ resultsPath: 'coverage/cli/lcov.info', pathToProject: 'packages/cli' }]\n *     })\n *   ]\n * }\n *\n * @returns Plugin configuration.\n */\nexport async function coveragePlugin(\n  config: CoveragePluginConfig,\n): Promise<PluginConfig> {\n  const coverageConfig = coveragePluginConfigSchema.parse(config);\n\n  const audits = coverageConfig.coverageTypes.map(\n    (type): Audit => ({\n      slug: `${type}-coverage`,\n      title: `${capitalize(type)} coverage`,\n      description: coverageDescription[type],\n    }),\n  );\n\n  const group: Group = {\n    slug: 'coverage',\n    title: 'Code coverage metrics',\n    description: 'Group containing all defined coverage types as audits.',\n    refs: audits.map(audit => ({\n      ...audit,\n      weight:\n        coverageTypeWeightMapper[\n          audit.slug.slice(0, audit.slug.indexOf('-')) as CoverageType\n        ],\n    })),\n  };\n\n  const runnerScriptPath = path.join(\n    fileURLToPath(path.dirname(import.meta.url)),\n    '..',\n    'bin.js',\n  );\n\n  const packageJson = createRequire(import.meta.url)(\n    '../../package.json',\n  ) as typeof import('../../package.json');\n\n  return {\n    slug: 'coverage',\n    title: 'Code coverage',\n    icon: 'folder-coverage-open',\n    description: 'Official Code PushUp code coverage plugin.',\n    docsUrl: 'https://www.npmjs.com/package/@code-pushup/coverage-plugin/',\n    packageName: packageJson.name,\n    version: packageJson.version,\n    audits,\n    groups: [group],\n    runner: await createRunnerConfig(runnerScriptPath, coverageConfig),\n  };\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/config.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/config.ts\";import { z } from 'zod';\n\nexport const coverageTypeSchema = z.enum(['function', 'branch', 'line']);\nexport type CoverageType = z.infer<typeof coverageTypeSchema>;\n\nexport const coverageResultSchema = z.union([\n  z.object({\n    resultsPath: z\n      .string({\n        description: 'Path to coverage results for Nx setup.',\n      })\n      .includes('lcov'),\n    pathToProject: z\n      .string({\n        description:\n          'Path from workspace root to project root. Necessary for LCOV reports which provide a relative path.',\n      })\n      .optional(),\n  }),\n  z\n    .string({\n      description: 'Path to coverage results for a single project setup.',\n    })\n    .includes('lcov'),\n]);\nexport type CoverageResult = z.infer<typeof coverageResultSchema>;\n\nexport const coveragePluginConfigSchema = z.object({\n  coverageToolCommand: z\n    .object({\n      command: z\n        .string({ description: 'Command to run coverage tool.' })\n        .min(1),\n      args: z\n        .array(z.string(), {\n          description: 'Arguments to be passed to the coverage tool.',\n        })\n        .optional(),\n    })\n    .optional(),\n  coverageTypes: z\n    .array(coverageTypeSchema, {\n      description: 'Coverage types measured. Defaults to all available types.',\n    })\n    .min(1)\n    .default(['function', 'branch', 'line']),\n  reports: z\n    .array(coverageResultSchema, {\n      description:\n        'Path to all code coverage report files. Only LCOV format is supported for now.',\n    })\n    .min(1),\n  perfectScoreThreshold: z\n    .number({\n      description:\n        'Score will be 1 (perfect) for this coverage and above. Score range is 0 - 1.',\n    })\n    .gt(0)\n    .max(1)\n    .optional(),\n});\nexport type CoveragePluginConfig = z.input<typeof coveragePluginConfigSchema>;\nexport type FinalCoveragePluginConfig = z.infer<\n  typeof coveragePluginConfigSchema\n>;\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner/index.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner/index.ts\";import { bold } from 'ansis';\nimport { writeFile } from 'node:fs/promises';\nimport path from 'node:path';\nimport type { AuditOutputs, RunnerConfig } from '@code-pushup/models';\nimport {\n  ProcessError,\n  ensureDirectoryExists,\n  executeProcess,\n  filePathToCliArg,\n  readJsonFile,\n  ui,\n} from '@code-pushup/utils';\nimport type { FinalCoveragePluginConfig } from '../config.js';\nimport { applyMaxScoreAboveThreshold } from '../utils.js';\nimport { PLUGIN_CONFIG_PATH, RUNNER_OUTPUT_PATH } from './constants.js';\nimport { lcovResultsToAuditOutputs } from './lcov/lcov-runner.js';\n\nexport async function executeRunner(): Promise<void> {\n  const { reports, coverageToolCommand, coverageTypes } =\n    await readJsonFile<FinalCoveragePluginConfig>(PLUGIN_CONFIG_PATH);\n\n  // Run coverage tool if provided\n  if (coverageToolCommand != null) {\n    const { command, args } = coverageToolCommand;\n    try {\n      await executeProcess({ command, args });\n    } catch (error) {\n      if (error instanceof ProcessError) {\n        ui().logger.error(bold('stdout from failed coverage tool process:'));\n        ui().logger.error(error.stdout);\n        ui().logger.error(bold('stderr from failed coverage tool process:'));\n        ui().logger.error(error.stderr);\n      }\n\n      throw new Error(\n        'Coverage plugin: Running coverage tool failed. Make sure all your provided tests are passing.',\n      );\n    }\n  }\n\n  // Calculate coverage from LCOV results\n  const auditOutputs = await lcovResultsToAuditOutputs(reports, coverageTypes);\n\n  await ensureDirectoryExists(path.dirname(RUNNER_OUTPUT_PATH));\n  await writeFile(RUNNER_OUTPUT_PATH, JSON.stringify(auditOutputs));\n}\n\nexport async function createRunnerConfig(\n  scriptPath: string,\n  config: FinalCoveragePluginConfig,\n): Promise<RunnerConfig> {\n  // Create JSON config for executeRunner\n  await ensureDirectoryExists(path.dirname(PLUGIN_CONFIG_PATH));\n  await writeFile(PLUGIN_CONFIG_PATH, JSON.stringify(config));\n\n  const threshold = config.perfectScoreThreshold;\n\n  return {\n    command: 'node',\n    args: [filePathToCliArg(scriptPath)],\n    outputFile: RUNNER_OUTPUT_PATH,\n    ...(threshold != null && {\n      outputTransform: outputs =>\n        applyMaxScoreAboveThreshold(outputs as AuditOutputs, threshold),\n    }),\n  };\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner/constants.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner/constants.ts\";import path from 'node:path';\nimport { pluginWorkDir } from '@code-pushup/utils';\n\nexport const WORKDIR = pluginWorkDir('coverage');\nexport const RUNNER_OUTPUT_PATH = path.join(WORKDIR, 'runner-output.json');\nexport const PLUGIN_CONFIG_PATH = path.join(\n  process.cwd(),\n  WORKDIR,\n  'plugin-config.json',\n);\n\nexport const INVALID_FUNCTION_NAME = '(empty-report)';\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner/lcov/lcov-runner.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner/lcov\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner/lcov/lcov-runner.ts\";import path from 'node:path';\nimport type { LCOVRecord } from 'parse-lcov';\nimport type { AuditOutputs } from '@code-pushup/models';\nimport { exists, readTextFile, toUnixNewlines, ui } from '@code-pushup/utils';\nimport type { CoverageResult, CoverageType } from '../../config.js';\nimport { mergeLcovResults } from './merge-lcov.js';\nimport { parseLcov } from './parse-lcov.js';\nimport {\n  lcovCoverageToAuditOutput,\n  recordToStatFunctionMapper,\n} from './transform.js';\nimport type { LCOVStat, LCOVStats } from './types.js';\n\n// Note: condition or statement coverage is not supported in LCOV\n// https://stackoverflow.com/questions/48260434/is-it-possible-to-check-condition-coverage-with-gcov\n\n/**\n *\n * @param results Paths to LCOV results\n * @param coverageTypes types of coverage to be considered\n * @returns Audit outputs with complete coverage data.\n */\nexport async function lcovResultsToAuditOutputs(\n  results: CoverageResult[],\n  coverageTypes: CoverageType[],\n): Promise<AuditOutputs> {\n  // Parse lcov files\n  const lcovResults = await parseLcovFiles(results);\n\n  // Merge multiple coverage reports for the same file\n  const mergedResults = mergeLcovResults(lcovResults);\n\n  // Calculate code coverage from all coverage results\n  const totalCoverageStats = getTotalCoverageFromLcovRecords(\n    mergedResults,\n    coverageTypes,\n  );\n\n  return coverageTypes\n    .map(coverageType => {\n      const stats = totalCoverageStats[coverageType];\n      if (!stats) {\n        return null;\n      }\n      return lcovCoverageToAuditOutput(stats, coverageType);\n    })\n    .filter(exists);\n}\n\n/**\n *\n * @param results Paths to LCOV results\n * @returns Array of parsed LCOVRecords.\n */\nexport async function parseLcovFiles(\n  results: CoverageResult[],\n): Promise<LCOVRecord[]> {\n  const parsedResults = await Promise.all(\n    results.map(async result => {\n      const resultsPath =\n        typeof result === 'string' ? result : result.resultsPath;\n      const lcovFileContent = await readTextFile(resultsPath);\n      if (lcovFileContent.trim() === '') {\n        ui().logger.warning(\n          `Coverage plugin: Empty lcov report file detected at ${resultsPath}.`,\n        );\n      }\n      const parsedRecords = parseLcov(toUnixNewlines(lcovFileContent));\n      return parsedRecords.map<LCOVRecord>(record => ({\n        ...record,\n        file:\n          typeof result === 'string' || result.pathToProject == null\n            ? record.file\n            : path.join(result.pathToProject, record.file),\n      }));\n    }),\n  );\n  if (parsedResults.length !== results.length) {\n    throw new Error('Some provided LCOV results were not valid.');\n  }\n\n  const flatResults = parsedResults.flat();\n\n  if (flatResults.length === 0) {\n    throw new Error('All provided results are empty.');\n  }\n\n  return flatResults;\n}\n\n/**\n *\n * @param records This function aggregates coverage stats from all coverage files\n * @param coverageTypes Types of coverage to be gathered\n * @returns Complete coverage stats for all defined types of coverage.\n */\nfunction getTotalCoverageFromLcovRecords(\n  records: LCOVRecord[],\n  coverageTypes: CoverageType[],\n): LCOVStats {\n  return records.reduce<LCOVStats>(\n    (acc, report) =>\n      Object.fromEntries([\n        ...Object.entries(acc),\n        ...(\n          Object.entries(\n            getCoverageStatsFromLcovRecord(report, coverageTypes),\n          ) as [CoverageType, LCOVStat][]\n        ).map(([type, stats]): [CoverageType, LCOVStat] => [\n          type,\n          {\n            totalFound: (acc[type]?.totalFound ?? 0) + stats.totalFound,\n            totalHit: (acc[type]?.totalHit ?? 0) + stats.totalHit,\n            issues: [...(acc[type]?.issues ?? []), ...stats.issues],\n          },\n        ]),\n      ]),\n    {},\n  );\n}\n\n/**\n * @param record record file data\n * @param coverageTypes types of coverage to be gathered\n * @returns Relevant coverage data from one lcov record file.\n */\nfunction getCoverageStatsFromLcovRecord(\n  record: LCOVRecord,\n  coverageTypes: CoverageType[],\n): LCOVStats {\n  return Object.fromEntries(\n    coverageTypes.map((coverageType): [CoverageType, LCOVStat] => [\n      coverageType,\n      recordToStatFunctionMapper[coverageType](record),\n    ]),\n  );\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner/lcov/parse-lcov.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner/lcov\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner/lcov/parse-lcov.ts\";import parseLcovExport from 'parse-lcov';\n\ntype ParseLcovFn = typeof parseLcovExport;\n\n// the parse-lcov export is inconsistent (sometimes it's .default, sometimes it's .default.default)\nconst godKnows = parseLcovExport as unknown as\n  | ParseLcovFn\n  | { default: ParseLcovFn };\n\nexport const parseLcov: ParseLcovFn =\n  'default' in godKnows ? godKnows.default : godKnows;\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner/lcov/transform.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner/lcov\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner/lcov/transform.ts\";import type { LCOVRecord } from 'parse-lcov';\nimport type { AuditOutput, Issue } from '@code-pushup/models';\nimport { toNumberPrecision, toOrdinal } from '@code-pushup/utils';\nimport type { CoverageType } from '../../config.js';\nimport { INVALID_FUNCTION_NAME } from '../constants.js';\nimport type { LCOVStat } from './types.js';\nimport { calculateCoverage, mergeConsecutiveNumbers } from './utils.js';\n\nexport function lcovReportToFunctionStat(record: LCOVRecord): LCOVStat {\n  const validRecord = removeEmptyReport(record);\n\n  return {\n    totalFound: validRecord.functions.found,\n    totalHit: validRecord.functions.hit,\n    issues:\n      validRecord.functions.hit < validRecord.functions.found\n        ? validRecord.functions.details\n            .filter(detail => !detail.hit)\n            .map(\n              (detail): Issue => ({\n                message: `Function ${detail.name} is not called in any test case.`,\n                severity: 'error',\n                source: {\n                  file: validRecord.file,\n                  position: { startLine: detail.line },\n                },\n              }),\n            )\n        : [],\n  };\n}\n\nfunction removeEmptyReport(record: LCOVRecord): LCOVRecord {\n  const validFunctions = record.functions.details.filter(\n    detail => detail.name !== INVALID_FUNCTION_NAME,\n  );\n\n  if (validFunctions.length === record.functions.found) {\n    return record;\n  }\n\n  return {\n    ...record,\n    functions: {\n      details: validFunctions,\n      found: validFunctions.length,\n      hit: validFunctions.reduce(\n        (acc, fn) => acc + (fn.hit != null && fn.hit > 0 ? 1 : 0),\n        0,\n      ),\n    },\n  };\n}\n\nexport function lcovReportToLineStat(record: LCOVRecord): LCOVStat {\n  const missingCoverage = record.lines.hit < record.lines.found;\n  const lines = missingCoverage\n    ? record.lines.details\n        .filter(detail => !detail.hit)\n        .map(detail => detail.line)\n    : [];\n\n  const linePositions = mergeConsecutiveNumbers(lines);\n\n  return {\n    totalFound: record.lines.found,\n    totalHit: record.lines.hit,\n    issues: missingCoverage\n      ? linePositions.map((linePosition): Issue => {\n          const lineReference =\n            linePosition.end == null\n              ? `Line ${linePosition.start} is`\n              : `Lines ${linePosition.start}-${linePosition.end} are`;\n\n          return {\n            message: `${lineReference} not covered in any test case.`,\n            severity: 'warning',\n            source: {\n              file: record.file,\n              position: {\n                startLine: linePosition.start,\n                endLine: linePosition.end,\n              },\n            },\n          };\n        })\n      : [],\n  };\n}\n\nexport function lcovReportToBranchStat(record: LCOVRecord): LCOVStat {\n  return {\n    totalFound: record.branches.found,\n    totalHit: record.branches.hit,\n    issues:\n      record.branches.hit < record.branches.found\n        ? record.branches.details\n            .filter(detail => !detail.taken)\n            .map(\n              (detail): Issue => ({\n                message: `${toOrdinal(\n                  detail.branch + 1,\n                )} branch is not taken in any test case.`,\n                severity: 'error',\n                source: {\n                  file: record.file,\n                  position: { startLine: detail.line },\n                },\n              }),\n            )\n        : [],\n  };\n}\n\nexport const recordToStatFunctionMapper = {\n  branch: lcovReportToBranchStat,\n  line: lcovReportToLineStat,\n  function: lcovReportToFunctionStat,\n};\n\n/**\n *\n * @param stat code coverage result for a given type\n * @param coverageType code coverage type\n * @returns Result of complete code ccoverage data coverted to AuditOutput\n */\nexport function lcovCoverageToAuditOutput(\n  stat: LCOVStat,\n  coverageType: CoverageType,\n): AuditOutput {\n  const coverage = calculateCoverage(stat.totalHit, stat.totalFound);\n  const MAX_DECIMAL_PLACES = 4;\n  const coveragePercentage = coverage * 100;\n\n  return {\n    slug: `${coverageType}-coverage`,\n    score: toNumberPrecision(coverage, MAX_DECIMAL_PLACES),\n    value: coveragePercentage,\n    displayValue: `${toNumberPrecision(coveragePercentage, 1)} %`,\n    details: {\n      issues: stat.issues,\n    },\n  };\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/nx/coverage-paths.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/nx\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/nx/coverage-paths.ts\";/// <reference types=\"vitest\" />\nimport type {\n  ProjectConfiguration,\n  ProjectGraphProjectNode,\n  Tree,\n} from '@nx/devkit';\nimport type { JestExecutorOptions } from '@nx/jest/src/executors/jest/schema';\nimport type { VitestExecutorOptions } from '@nx/vite/executors';\nimport { bold } from 'ansis';\nimport path from 'node:path';\nimport { importModule, ui } from '@code-pushup/utils';\nimport type { CoverageResult } from '../config.js';\n\n/**\n * @param targets nx targets to be used for measuring coverage, test by default\n * @returns An array of coverage result information for the coverage plugin.\n */\nexport async function getNxCoveragePaths(\n  targets: string[] = ['test'],\n  verbose?: boolean,\n): Promise<CoverageResult[]> {\n  if (verbose) {\n    ui().logger.info(\n      bold('\uD83D\uDCA1 Gathering coverage from the following nx projects:'),\n    );\n  }\n\n  const { createProjectGraphAsync } = await import('@nx/devkit');\n  const { nodes } = await createProjectGraphAsync({ exitOnError: false });\n\n  const coverageResults = await Promise.all(\n    targets.map(async target => {\n      const relevantNodes = Object.values(nodes).filter(graph =>\n        hasNxTarget(graph, target),\n      );\n\n      return await Promise.all(\n        relevantNodes.map<Promise<CoverageResult>>(async ({ name, data }) => {\n          const coveragePaths = await getCoveragePathsForTarget(data, target);\n          if (verbose) {\n            ui().logger.info(`- ${name}: ${target}`);\n          }\n          return coveragePaths;\n        }),\n      );\n    }),\n  );\n\n  if (verbose) {\n    ui().logger.info('\\n');\n  }\n\n  return coverageResults.flat();\n}\n\nfunction hasNxTarget(\n  project: ProjectGraphProjectNode,\n  target: string,\n): boolean {\n  return project.data.targets != null && target in project.data.targets;\n}\n\nexport type VitestCoverageConfig = {\n  test: {\n    coverage?: {\n      reporter?: string[];\n      reportsDirectory?: string;\n    };\n  };\n};\n\nexport type JestCoverageConfig = {\n  coverageDirectory?: string;\n  coverageReporters?: string[];\n};\n\nexport async function getCoveragePathsForTarget(\n  project: ProjectConfiguration,\n  target: string,\n): Promise<CoverageResult> {\n  const targetConfig = project.targets?.[target];\n\n  if (!targetConfig) {\n    throw new Error(\n      `No configuration found for target ${target} in project ${project.name}`,\n    );\n  }\n\n  if (targetConfig.executor?.includes('@nx/vite')) {\n    return getCoveragePathForVitest(\n      targetConfig.options as VitestExecutorOptions,\n      project,\n      target,\n    );\n  }\n\n  if (targetConfig.executor?.includes('@nx/jest')) {\n    return getCoveragePathForJest(\n      targetConfig.options as JestExecutorOptions,\n      project,\n      target,\n    );\n  }\n\n  throw new Error(\n    `Unsupported executor ${targetConfig.executor}. Only @nx/vite and @nx/jest are currently supported.`,\n  );\n}\n\nexport async function getCoveragePathForVitest(\n  options: VitestExecutorOptions,\n  project: ProjectConfiguration,\n  target: string,\n) {\n  const {\n    default: { normalizeViteConfigFilePathWithTree },\n  } = await import('@nx/vite');\n  const config = normalizeViteConfigFilePathWithTree(\n    // HACK: only tree.exists is called, so injecting existSync from node:fs instead\n    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n    { exists: (await import('node:fs')).existsSync } as Tree,\n    project.root,\n    options.configFile,\n  );\n  if (!config) {\n    throw new Error(\n      `Could not find Vitest config file for target ${target} in project ${project.name}`,\n    );\n  }\n\n  const vitestConfig = await importModule<VitestCoverageConfig>({\n    filepath: config,\n    format: 'esm',\n  });\n\n  const reportsDirectory =\n    options.reportsDirectory ?? vitestConfig.test.coverage?.reportsDirectory;\n  const reporter = vitestConfig.test.coverage?.reporter;\n\n  if (reportsDirectory == null) {\n    throw new Error(\n      `Vitest coverage configuration at ${config} does not include coverage path for target ${target} in project ${project.name}. Add the path under coverage > reportsDirectory.`,\n    );\n  }\n\n  if (!reporter?.includes('lcov')) {\n    throw new Error(\n      `Vitest coverage configuration at ${config} does not include LCOV report format for target ${target} in project ${project.name}. Add 'lcov' format under coverage > reporter.`,\n    );\n  }\n\n  if (path.isAbsolute(reportsDirectory)) {\n    return path.join(reportsDirectory, 'lcov.info');\n  }\n  return {\n    pathToProject: project.root,\n    resultsPath: path.join(project.root, reportsDirectory, 'lcov.info'),\n  };\n}\n\nexport async function getCoveragePathForJest(\n  options: JestExecutorOptions,\n  project: ProjectConfiguration,\n  target: string,\n) {\n  const { jestConfig } = options;\n\n  const testConfig = await importModule<JestCoverageConfig>({\n    filepath: jestConfig,\n  });\n  const { coverageDirectory, coverageReporters } = {\n    ...testConfig,\n    ...options,\n  };\n\n  if (coverageDirectory == null) {\n    throw new Error(\n      `Jest coverage configuration at ${jestConfig} does not include coverage path for target ${target} in ${project.name}. Add the path under coverageDirectory.`,\n    );\n  }\n\n  if (!coverageReporters?.includes('lcov') && !('preset' in testConfig)) {\n    throw new Error(\n      `Jest coverage configuration at ${jestConfig} does not include LCOV report format for target ${target} in ${project.name}. Add 'lcov' format under coverageReporters.`,\n    );\n  }\n\n  if (path.isAbsolute(coverageDirectory)) {\n    return path.join(coverageDirectory, 'lcov.info');\n  }\n  return path.join(project.root, coverageDirectory, 'lcov.info');\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/config.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/config.ts\";import { z } from 'zod';\n\nexport const docCoveragePluginConfigSchema = z.object({\n  onlyAudits: z.array(z.string()).optional(),\n  sourceGlob: z\n    .array(z.string())\n    .default(['src/**/*.{ts,tsx}', '!**/*.spec.ts', '!**/*.test.ts']),\n});\n\nexport type DocCoveragePluginConfig = z.infer<\n  typeof docCoveragePluginConfigSchema\n>;", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/constants.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/constants.ts\";import type { Audit, Group } from \"@code-pushup/models\";\nimport type { AuditSlug } from \"./models\";\n\nexport const PLUGIN_SLUG = 'doc-coverage';\n\nexport const AUDITS_MAP: Record<AuditSlug, Audit> = {\n    'classes-coverage': {\n        slug: 'classes-coverage',\n        title: 'Classes coverage',\n        description: 'Coverage of classes',\n    },\n    'methods-coverage': {\n        slug: 'methods-coverage',\n        title: 'Methods coverage',\n        description: 'Coverage of methods',\n    },\n    'functions-coverage': {\n        slug: 'functions-coverage',\n        title: 'Functions coverage',\n        description: 'Coverage of functions',\n    },\n    'interfaces-coverage': {\n        slug: 'interfaces-coverage',\n        title: 'Interfaces coverage',\n        description: 'Coverage of interfaces',\n    },\n    'variables-coverage': {\n        slug: 'variables-coverage',\n        title: 'Variables coverage',\n        description: 'Coverage of variables',\n    },\n    'properties-coverage': {\n        slug: 'properties-coverage',\n        title: 'Properties coverage',\n        description: 'Coverage of properties',\n    },\n    'types-coverage': {\n        slug: 'types-coverage',\n        title: 'Types coverage',\n        description: 'Coverage of types',\n    },\n    'enums-coverage': {\n        slug: 'enums-coverage',\n        title: 'Enums coverage',\n        description: 'Coverage of enums',\n    },\n} as const;\n\nexport const groups: Group[] = [\n    {\n        slug: 'documentation-coverage',\n        title: 'Documentation coverage',\n        description: 'Documentation coverage',\n        refs: Object.keys(AUDITS_MAP).map(slug => {\n            switch (slug as AuditSlug) {\n                case 'classes-coverage':\n                case 'functions-coverage':\n                case 'methods-coverage':\n                    return { slug, weight: 2 }\n                case 'interfaces-coverage':\n                case 'properties-coverage':\n                case 'types-coverage':\n                default:\n                    return { slug, weight: 1 }\n            }\n        }),\n    }];", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/runner\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts\";import { ClassDeclaration, Project, SourceFile } from 'ts-morph';\nimport type { DocCoveragePluginConfig } from '../config.js';\nimport type {\n  CoverageResult,\n  CoverageType,\n  UndocumentedNode,\n  UnprocessedCoverageResult\n} from '../models.js';\nimport { getCoverageTypeFromKind } from '../utils.js';\nimport { calculateCoverage, createEmptyUnprocessedCoverageReport } from './utils.js';\n\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable functional/immutable-data */\n/* eslint-disable @typescript-eslint/max-params */\n/* eslint-disable functional/no-let */\n\n\n/**\n * Processes documentation coverage for TypeScript files in the specified path\n * @param toInclude - The file path pattern to include for documentation analysis\n * @returns {CoverageResult} Object containing coverage statistics and undocumented items\n */\nexport function processDocCoverage(config: DocCoveragePluginConfig): CoverageResult {\n  const project = new Project();\n  project.addSourceFilesAtPaths(config.sourceGlob);\n\n  return getUnprocessedCoverageReport(project.getSourceFiles());\n\n}\n\nexport function getUnprocessedCoverageReport(sourceFiles: SourceFile[]) {\n  const unprocessedCoverageReport = sourceFiles\n    .reduce((coverageReportOfAllFiles, sourceFile) => {\n\n      // Info of the file\n      const filePath = sourceFile.getFilePath();\n      const classes = sourceFile.getClasses();\n\n      // All nodes of the file\n      const allNodesFromFile = [\n        ...sourceFile.getFunctions(),\n        ...classes,\n        ...getClassNodes(classes),\n        ...sourceFile.getTypeAliases(),\n        ...sourceFile.getEnums(),\n        ...sourceFile.getInterfaces(),\n        // ...sourceFile.getVariableStatements().flatMap(statement => statement.getDeclarations())\n      ];\n\n      const coverageReportOfCurrentFile = allNodesFromFile.reduce((acc, node) => {\n        const nodeType = getCoverageTypeFromKind(node.getKind());\n        acc[nodeType].nodesCount++;\n        if (node.getJsDocs().length === 0) {\n          acc[nodeType].issues.push(\n            getUndocumentedNode(filePath, nodeType, node.getName() || '', node.getStartLineNumber())\n          );\n        }\n        return acc;\n      }, createEmptyUnprocessedCoverageReport());\n\n      return mergeCoverageResults(coverageReportOfAllFiles, coverageReportOfCurrentFile);\n    }, createEmptyUnprocessedCoverageReport());\n\n  return calculateCoverage(unprocessedCoverageReport);\n\n}\n\nfunction mergeCoverageResults(results: UnprocessedCoverageResult, current: UnprocessedCoverageResult) {\n  return {\n    ...Object.fromEntries(Object.entries(results).map(([key, value]) => {\n      const node = value as CoverageResult[CoverageType];\n      const type = key as CoverageType;\n      return [type, {\n        nodesCount: node.nodesCount + current[type].nodesCount,\n        issues: [...node.issues, ...current[type].issues],\n      }]\n    }))\n  } as UnprocessedCoverageResult;\n}\n\nfunction getClassNodes(classNodes: ClassDeclaration[]) {\n  return classNodes.flatMap(classNode => [...classNode.getMethods(), ...classNode.getProperties()])\n}\n\n/**\n * Creates an undocumented item entry\n * @param file - The file path where the item was found\n * @param type - The type of the undocumented item\n * @param name - The name of the undocumented item\n * @param line - The line number where the item appears\n * @returns {UndocumentedNode} The undocumented item entry\n */\nfunction getUndocumentedNode(file: string, type: CoverageType, name: string, line: number): UndocumentedNode {\n  return { file, type, name, line };\n}\n\n\n\n\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/utils.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/utils.ts\";import type { Audit, AuditOutputs, Group } from \"@code-pushup/models\";\nimport { SyntaxKind } from \"typescript\";\nimport type { DocCoveragePluginConfig } from \"./config\";\nimport { AUDITS_MAP } from \"./constants\";\nimport type { CoverageResult, CoverageType } from \"./models\";\n\n/**\n * Get audits based on the configuration.\n * If no audits are specified, return all audits.\n * If audits are specified, return only the specified audits.\n * @param config - The configuration object.\n * @returns The audits.\n */\nexport function filterAuditsByPluginConfig(config: Pick<DocCoveragePluginConfig, 'onlyAudits'>): Audit[] {\n    const { onlyAudits } = config\n\n    if (!onlyAudits || onlyAudits.length === 0) {\n        return Object.values(AUDITS_MAP);\n    }\n\n    return Object.values(AUDITS_MAP).filter(audit => onlyAudits.includes(audit.slug));\n\n}\n\n// return groups.filter(group => group.refs.some(ref => audits.some(audit => audit.slug === ref.slug)));\n\n/**\n * Filter groups by the audits that are specified in the configuration.\n * The groups refs are filtered to only include the audits that are specified in the configuration.\n * @param groups - The groups to filter.\n * @param options - The configuration object.\n * @returns The filtered groups.\n */\nexport function filterGroupsByOnlyAudits(groups: Group[], options: Pick<DocCoveragePluginConfig, 'onlyAudits'>): Group[] {\n    const audits = filterAuditsByPluginConfig(options);\n    return groups\n        .map(group => ({\n            ...group,\n            refs: group.refs.filter(ref => audits.some(audit => audit.slug === ref.slug))\n        }))\n        .filter(group => group.refs.length > 0);;\n}\n\n\n/**\n * Transforms the coverage report into audit outputs.\n * @param coverageResult - The coverage result containing undocumented items and coverage statistics\n * @param options - Configuration options specifying which audits to include\n * @returns Audit outputs with coverage scores and details about undocumented items\n */\nexport function trasformCoverageReportToAudits(coverageResult: CoverageResult, options: Pick<DocCoveragePluginConfig, 'onlyAudits'>): AuditOutputs {\n\n    return Object.entries(coverageResult)\n        .filter(([type]) => !options.onlyAudits?.length || options.onlyAudits.includes(`${type}-coverage`))\n        .map(([type, items]) => {\n            const coverageType = type as CoverageType;\n            const coverage = items.coverage;\n\n            return {\n                slug: `${coverageType}-coverage`,\n                value: coverage,\n                score: coverage / 100,\n                displayValue: `${coverage} %`,\n                details: {\n                    issues: items.issues.map(({ file, line }) => ({\n                        message: 'Missing documentation',\n                        source: { file, position: { startLine: line } },\n                        severity: 'warning',\n                    })),\n                },\n            };\n        });\n}\n\nexport function getCoverageTypeFromKind(kind: SyntaxKind): CoverageType {\n    switch (kind) {\n        case SyntaxKind.ClassDeclaration:\n            return 'classes';\n        case SyntaxKind.MethodDeclaration:\n            return 'methods';\n        case SyntaxKind.FunctionDeclaration:\n            return 'functions';\n        case SyntaxKind.InterfaceDeclaration:\n            return 'interfaces';\n        case SyntaxKind.EnumDeclaration:\n            return 'enums';\n        case SyntaxKind.VariableDeclaration:\n            return 'variables';\n        case SyntaxKind.PropertyDeclaration:\n            return 'properties';\n        case SyntaxKind.TypeAliasDeclaration:\n            return 'types';\n        default:\n            throw new Error(`Unsupported syntax kind: ${kind}`);\n    }\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/runner/utils.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/runner\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/runner/utils.ts\";import type { CoverageResult, CoverageType, UnprocessedCoverageResult } from \"../models\";\n\nexport function createEmptyUnprocessedCoverageReport(): UnprocessedCoverageResult {\n    return {\n        enums: { nodesCount: 0, issues: [] },\n        interfaces: { nodesCount: 0, issues: [] },\n        types: { nodesCount: 0, issues: [] },\n        functions: { nodesCount: 0, issues: [] },\n        variables: { nodesCount: 0, issues: [] },\n        classes: { nodesCount: 0, issues: [] },\n        methods: { nodesCount: 0, issues: [] },\n        properties: { nodesCount: 0, issues: [] },\n    }\n}\n\nexport function calculateCoverage(result: UnprocessedCoverageResult) {\n    return Object.fromEntries(Object.entries(result).map(([key, value]) => {\n        const type = key as CoverageType;\n        return [type, {\n            coverage: value.nodesCount === 0 ? 100 : (1 - value.issues.length / value.nodesCount) * 100,\n            issues: value.issues,\n            nodesCount: value.nodesCount\n        }]\n    })) as CoverageResult;\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts\";import type { AuditOutputs, PluginConfig, RunnerFunction } from '@code-pushup/models';\nimport {\n  type DocCoveragePluginConfig,\n  docCoveragePluginConfigSchema,\n} from './config.js';\nimport { groups, PLUGIN_SLUG } from './constants.js';\nimport { processDocCoverage } from './runner/doc-processer.js';\nimport { filterAuditsByPluginConfig, filterGroupsByOnlyAudits, trasformCoverageReportToAudits } from './utils.js';\n\nconst PLUGIN_TITLE = 'Documentation coverage';\n\nconst PLUGIN_DESCRIPTION = 'Official Code PushUp documentation coverage plugin.';\n\nconst PLUGIN_DOCS_URL = 'https://www.npmjs.com/package/@code-pushup/doc-coverage-plugin/';\n\n/**\n * Instantiates Code PushUp documentation coverage plugin for core config.\n *\n * @example\n * import docCoveragePlugin from '@code-pushup/doc-coverage-plugin'\n *\n * export default {\n *   // ... core config ...\n *   plugins: [\n *     // ... other plugins ...\n *     await docCoveragePlugin({\n *       sourceGlob: 'src&#47;**&#47;*.{ts,tsx}'\n *     })\n *   ]\n * }\n *\n * @returns Plugin configuration.\n */\n\n\nexport async function docCoveragePlugin(config: DocCoveragePluginConfig): Promise<PluginConfig> {\n\n\n  const docCoverageConfig = docCoveragePluginConfigSchema.parse(config);\n\n\n  const groupsC = filterGroupsByOnlyAudits(groups, docCoverageConfig);\n  const auditsC = filterAuditsByPluginConfig(docCoverageConfig);\n\n  return {\n    slug: PLUGIN_SLUG,\n    title: PLUGIN_TITLE,\n    icon: 'folder-src',\n    description: PLUGIN_DESCRIPTION,\n    docsUrl: PLUGIN_DOCS_URL,\n    groups: filterGroupsByOnlyAudits(groups, docCoverageConfig),\n    audits: filterAuditsByPluginConfig(docCoverageConfig),\n    runner: createRunnerFunction(docCoverageConfig),\n  };\n}\n\nexport function createRunnerFunction(config: DocCoveragePluginConfig): RunnerFunction {\n  return (): AuditOutputs => {\n    const coverageResult = processDocCoverage(config)\n    return trasformCoverageReportToAudits(coverageResult, config);\n  };\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/index.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/index.ts\";import { docCoveragePlugin } from './lib/doc-coverage-plugin.js';\n\nexport default docCoveragePlugin;\nexport type { DocCoveragePluginConfig } from './lib/config.js';\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/eslint-plugin.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/eslint-plugin.ts\";import { createRequire } from 'node:module';\nimport path from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport type { PluginConfig } from '@code-pushup/models';\nimport { type ESLintPluginConfig, eslintPluginConfigSchema } from './config.js';\nimport { listAuditsAndGroups } from './meta/index.js';\nimport { createRunnerConfig } from './runner/index.js';\n\n/**\n * Instantiates Code PushUp ESLint plugin for use in core config.\n *\n * @example\n * import eslintPlugin from '@code-pushup/eslint-plugin'\n *\n * export default {\n *   // ... core config ...\n *   plugins: [\n *     // ... other plugins ...\n *     await eslintPlugin({\n *       eslintrc: '.eslintrc.json',\n *       patterns: ['src', 'test/*.spec.js']\n *     })\n *   ]\n * }\n *\n * @param config Configuration options.\n * @returns Plugin configuration as a promise.\n */\nexport async function eslintPlugin(\n  config: ESLintPluginConfig,\n): Promise<PluginConfig> {\n  const targets = eslintPluginConfigSchema.parse(config);\n\n  const { audits, groups } = await listAuditsAndGroups(targets);\n\n  const runnerScriptPath = path.join(\n    fileURLToPath(path.dirname(import.meta.url)),\n    '..',\n    'bin.js',\n  );\n\n  const packageJson = createRequire(import.meta.url)(\n    '../../package.json',\n  ) as typeof import('../../package.json');\n\n  return {\n    slug: 'eslint',\n    title: 'ESLint',\n    icon: 'eslint',\n    description: 'Official Code PushUp ESLint plugin',\n    docsUrl: 'https://www.npmjs.com/package/@code-pushup/eslint-plugin',\n    packageName: packageJson.name,\n    version: packageJson.version,\n\n    audits,\n    groups,\n\n    runner: await createRunnerConfig(runnerScriptPath, audits, targets),\n  };\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/config.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/config.ts\";import { z } from 'zod';\nimport { toArray } from '@code-pushup/utils';\n\nconst patternsSchema = z.union([z.string(), z.array(z.string()).min(1)], {\n  description:\n    'Lint target files. May contain file paths, directory paths or glob patterns',\n});\n\nconst eslintrcSchema = z.string({ description: 'Path to ESLint config file' });\n\nconst eslintTargetObjectSchema = z.object({\n  eslintrc: eslintrcSchema.optional(),\n  patterns: patternsSchema,\n});\ntype ESLintTargetObject = z.infer<typeof eslintTargetObjectSchema>;\n\nexport const eslintTargetSchema = z\n  .union([patternsSchema, eslintTargetObjectSchema])\n  .transform(\n    (target): ESLintTargetObject =>\n      typeof target === 'string' || Array.isArray(target)\n        ? { patterns: target }\n        : target,\n  );\nexport type ESLintTarget = z.infer<typeof eslintTargetSchema>;\n\nexport const eslintPluginConfigSchema = z\n  .union([eslintTargetSchema, z.array(eslintTargetSchema).min(1)])\n  .transform(toArray);\nexport type ESLintPluginConfig = z.input<typeof eslintPluginConfigSchema>;\n\nexport type ESLintPluginRunnerConfig = {\n  targets: ESLintTarget[];\n  slugs: string[];\n};\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/groups.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/groups.ts\";import type { Rule } from 'eslint';\nimport type { Group, GroupRef } from '@code-pushup/models';\nimport { objectToKeys, slugify } from '@code-pushup/utils';\nimport { ruleToSlug } from './hash.js';\nimport { type RuleData, parseRuleId } from './parse.js';\n\ntype RuleType = NonNullable<Rule.RuleMetaData['type']>;\n\n// docs on meta.type: https://eslint.org/docs/latest/extend/custom-rules#rule-structure\nconst typeGroups: Record<RuleType, Omit<Group, 'refs'>> = {\n  problem: {\n    slug: 'problems',\n    title: 'Problems',\n    description:\n      'Code that either will cause an error or may cause confusing behavior. Developers should consider this a high priority to resolve.',\n  },\n  suggestion: {\n    slug: 'suggestions',\n    title: 'Suggestions',\n    description:\n      \"Something that could be done in a better way but no errors will occur if the code isn't changed.\",\n  },\n  layout: {\n    slug: 'formatting',\n    title: 'Formatting',\n    description:\n      'Primarily about whitespace, semicolons, commas, and parentheses, all the parts of the program that determine how the code looks rather than how it executes.',\n  },\n};\n\nexport function groupsFromRuleTypes(rules: RuleData[]): Group[] {\n  const allTypes = objectToKeys(typeGroups);\n\n  const auditSlugsMap = rules.reduce<Partial<Record<RuleType, string[]>>>(\n    (acc, rule) =>\n      rule.meta.type == null\n        ? acc\n        : {\n            ...acc,\n            [rule.meta.type]: [\n              ...(acc[rule.meta.type] ?? []),\n              ruleToSlug(rule),\n            ],\n          },\n    {},\n  );\n\n  return allTypes\n    .map(type => ({\n      ...typeGroups[type],\n      refs:\n        auditSlugsMap[type]?.map((slug): GroupRef => ({ slug, weight: 1 })) ??\n        [],\n    }))\n    .filter(group => group.refs.length);\n}\n\nexport function groupsFromRuleCategories(rules: RuleData[]): Group[] {\n  const categoriesMap = rules.reduce<Record<string, Record<string, string[]>>>(\n    (acc, rule) => {\n      // meta.docs.category still used by some popular plugins (e.g. import, react, functional)\n      const category = rule.meta.docs?.category;\n      if (!category) {\n        return acc;\n      }\n      const { plugin = '' } = parseRuleId(rule.id);\n      return {\n        ...acc,\n        [plugin]: {\n          ...acc[plugin],\n          [category]: [...(acc[plugin]?.[category] ?? []), ruleToSlug(rule)],\n        },\n      };\n    },\n    {},\n  );\n\n  const groups = Object.entries(categoriesMap).flatMap(([plugin, categories]) =>\n    Object.entries(categories).map(\n      ([category, slugs]): Group => ({\n        slug: `${slugify(plugin)}-${slugify(category)}`,\n        title: `${category} (${plugin})`,\n        refs: slugs.map(slug => ({ slug, weight: 1 })),\n      }),\n    ),\n  );\n\n  return groups.toSorted((a, b) => a.slug.localeCompare(b.slug));\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/hash.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/hash.ts\";import { createHash } from 'node:crypto';\nimport { slugify } from '@code-pushup/utils';\nimport { type RuleData, resolveRuleOptions } from './parse.js';\n\nexport function ruleToSlug(rule: RuleData): string {\n  return ruleIdToSlug(rule.id, resolveRuleOptions(rule));\n}\n\nexport function ruleIdToSlug(\n  ruleId: string,\n  options: unknown[] | undefined,\n): string {\n  const slug = slugify(ruleId);\n  if (!options?.length) {\n    return slug;\n  }\n  return `${slug}-${jsonHash(options)}`;\n}\n\nexport function jsonHash(data: unknown, bytes = 8): string {\n  return createHash('shake256', { outputLength: bytes })\n    .update(JSON.stringify(data) || 'null')\n    .digest('hex');\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/parse.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/parse.ts\";import type { Linter, Rule } from 'eslint';\nimport { toArray } from '@code-pushup/utils';\n\nexport type RuleData = {\n  id: string;\n  meta: Rule.RuleMetaData;\n  options: unknown[] | undefined;\n};\n\nexport function parseRuleId(ruleId: string): { plugin?: string; name: string } {\n  const i = ruleId.startsWith('@')\n    ? ruleId.lastIndexOf('/')\n    : ruleId.indexOf('/');\n  if (i === -1) {\n    return { name: ruleId };\n  }\n  return {\n    plugin: ruleId.slice(0, i),\n    name: ruleId.slice(i + 1),\n  };\n}\n\nexport function isRuleOff(entry: Linter.RuleEntry<unknown[]>): boolean {\n  const level = Array.isArray(entry) ? entry[0] : entry;\n\n  switch (level) {\n    case 0:\n    case 'off':\n      return true;\n    case 1:\n    case 2:\n    case 'warn':\n    case 'error':\n      return false;\n  }\n}\n\nexport function optionsFromRuleEntry(\n  entry: Linter.RuleEntry<unknown[]>,\n): unknown[] {\n  return toArray(entry).slice(1);\n}\n\nexport function resolveRuleOptions(rule: RuleData): unknown[] | undefined {\n  if (rule.options?.length) {\n    return rule.options;\n  }\n  return rule.meta.defaultOptions;\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/versions/flat.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/versions\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/versions/flat.ts\";import type { Linter, Rule } from 'eslint';\nimport { builtinRules } from 'eslint/use-at-your-own-risk';\nimport path from 'node:path';\nimport { pathToFileURL } from 'node:url';\nimport { exists, findNearestFile, toArray, ui } from '@code-pushup/utils';\nimport type { ESLintTarget } from '../../config.js';\nimport { jsonHash } from '../hash.js';\nimport {\n  type RuleData,\n  isRuleOff,\n  optionsFromRuleEntry,\n  parseRuleId,\n} from '../parse.js';\n\nexport async function loadRulesForFlatConfig({\n  eslintrc,\n}: Pick<ESLintTarget, 'eslintrc'>): Promise<RuleData[]> {\n  const config = eslintrc\n    ? await loadConfigByPath(eslintrc)\n    : await loadConfigByDefaultLocation();\n  const configs = toArray(config);\n\n  const rules = findEnabledRulesWithOptions(configs);\n  return rules\n    .map(rule => {\n      const meta = findRuleMeta(rule.id, configs);\n      if (!meta) {\n        ui().logger.warning(`Cannot find metadata for rule ${rule.id}`);\n        return null;\n      }\n      return { ...rule, meta };\n    })\n    .filter(exists);\n}\n\ntype FlatConfig = Linter.Config | Linter.Config[];\n\nasync function loadConfigByDefaultLocation(): Promise<FlatConfig> {\n  const flatConfigFileNames = [\n    'eslint.config.js',\n    'eslint.config.mjs',\n    'eslint.config.cjs',\n  ];\n  const configPath = await findNearestFile(flatConfigFileNames);\n  if (configPath) {\n    return loadConfigByPath(configPath);\n  }\n  throw new Error(\n    [\n      `ESLint config file not found - expected ${flatConfigFileNames.join('/')} in ${process.cwd()} or some parent directory`,\n      'If your ESLint config is in a non-standard location, use the `eslintrc` parameter to specify the path.',\n    ].join('\\n'),\n  );\n}\n\nasync function loadConfigByPath(configPath: string): Promise<FlatConfig> {\n  const absolutePath = path.isAbsolute(configPath)\n    ? configPath\n    : path.join(process.cwd(), configPath);\n  const url = pathToFileURL(absolutePath).toString();\n  const mod = (await import(url)) as FlatConfig | { default: FlatConfig };\n  return 'default' in mod ? mod.default : mod;\n}\n\nfunction findEnabledRulesWithOptions(\n  configs: Linter.Config[],\n): Omit<RuleData, 'meta'>[] {\n  const enabledRules = configs\n    .flatMap(({ rules }) => Object.entries(rules ?? {}))\n    .filter(([, entry]) => entry != null && !isRuleOff(entry))\n    .map(([id, entry]) => ({\n      id,\n      options: entry ? optionsFromRuleEntry(entry) : [],\n    }));\n  const uniqueRulesMap = new Map(\n    enabledRules.map(({ id, options }) => [\n      `${id}::${jsonHash(options)}`,\n      { id, options },\n    ]),\n  );\n  return [...uniqueRulesMap.values()];\n}\n\nfunction findRuleMeta(\n  ruleId: string,\n  configs: Linter.Config[],\n): Rule.RuleMetaData | undefined {\n  const { plugin, name } = parseRuleId(ruleId);\n  if (!plugin) {\n    return findBuiltinRuleMeta(name);\n  }\n  return findPluginRuleMeta(plugin, name, configs);\n}\n\nfunction findBuiltinRuleMeta(name: string): Rule.RuleMetaData | undefined {\n  const rule = builtinRules.get(name);\n  return rule?.meta;\n}\n\nfunction findPluginRuleMeta(\n  plugin: string,\n  name: string,\n  configs: Linter.Config[],\n): Rule.RuleMetaData | undefined {\n  const config = configs.find(({ plugins = {} }) => plugin in plugins);\n  const rule = config?.plugins?.[plugin]?.rules?.[name];\n\n  if (typeof rule === 'function') {\n    ui().logger.warning(\n      `Cannot parse metadata for rule ${plugin}/${name}, plugin registers it as a function`,\n    );\n    return undefined;\n  }\n\n  return rule?.meta;\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/versions/legacy.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/versions\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/versions/legacy.ts\";import type { ESLint, Linter } from 'eslint';\nimport { distinct, exists, toArray, ui } from '@code-pushup/utils';\nimport type { ESLintTarget } from '../../config.js';\nimport { setupESLint } from '../../setup.js';\nimport { type RuleData, isRuleOff, optionsFromRuleEntry } from '../parse.js';\n\nexport async function loadRulesForLegacyConfig({\n  eslintrc,\n  patterns,\n}: ESLintTarget): Promise<RuleData[]> {\n  const eslint = await setupESLint(eslintrc);\n\n  const configs = await toArray(patterns).reduce(\n    async (acc, pattern) => [\n      ...(await acc),\n      (await eslint.calculateConfigForFile(pattern)) as Linter.LegacyConfig,\n    ],\n    Promise.resolve<Linter.LegacyConfig[]>([]),\n  );\n\n  const rulesIds = distinct(\n    configs.flatMap(config => Object.keys(config.rules ?? {})),\n  );\n  const rulesMeta = eslint.getRulesMetaForResults([\n    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n    {\n      messages: rulesIds.map(ruleId => ({ ruleId })),\n      suppressedMessages: [] as Linter.SuppressedLintMessage[],\n    } as ESLint.LintResult,\n  ]);\n\n  return configs\n    .flatMap(config => Object.entries(config.rules ?? {}))\n    .map(([id, entry]): RuleData | null => {\n      if (entry == null || isRuleOff(entry)) {\n        return null;\n      }\n      const ruleMeta = rulesMeta[id];\n      if (!ruleMeta) {\n        ui().logger.warning(`Metadata not found for ESLint rule ${id}`);\n        return null;\n      }\n      // ignoring meta.defaultOptions to match legacy config handling in calculateConfigForFile\n      const { defaultOptions: _, ...meta } = ruleMeta;\n      const options = optionsFromRuleEntry(entry);\n      return { id, meta, options };\n    })\n    .filter(exists);\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/setup.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/setup.ts\";import { ESLint } from 'eslint';\nimport type { ESLintTarget } from './config.js';\n\nexport async function setupESLint(eslintrc: ESLintTarget['eslintrc']) {\n  const eslintConstructor = await loadESLint();\n  return new eslintConstructor({\n    overrideConfigFile: eslintrc,\n    errorOnUnmatchedPattern: false,\n  });\n}\n\nasync function loadESLint() {\n  const eslint = await import('eslint');\n  // loadESLint added to public API in v9, selects ESLint or LegacyESLint based on environment\n  if ('loadESLint' in eslint && typeof eslint.loadESLint === 'function') {\n    return (await eslint.loadESLint()) as typeof ESLint;\n  }\n  return ESLint;\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/versions/detect.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/versions\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/versions/detect.ts\";import { ESLint } from 'eslint';\nimport { fileExists } from '@code-pushup/utils';\nimport type { ConfigFormat } from './formats.js';\n\n// relevant ESLint docs:\n// - https://eslint.org/docs/latest/use/configure/configuration-files\n// - https://eslint.org/docs/latest/use/configure/configuration-files-deprecated\n// - https://eslint.org/docs/v8.x/use/configure/configuration-files-new\n\nexport async function detectConfigVersion(): Promise<ConfigFormat> {\n  if (process.env['ESLINT_USE_FLAT_CONFIG'] === 'true') {\n    return 'flat';\n  }\n  if (process.env['ESLINT_USE_FLAT_CONFIG'] === 'false') {\n    return 'legacy';\n  }\n  if (ESLint.version.startsWith('8.')) {\n    if (await fileExists('eslint.config.js')) {\n      return 'flat';\n    }\n    return 'legacy';\n  }\n  return 'flat';\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/transform.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/transform.ts\";import type { Audit } from '@code-pushup/models';\nimport { truncateDescription, truncateTitle } from '@code-pushup/utils';\nimport { ruleToSlug } from './hash.js';\nimport type { RuleData } from './parse.js';\n\nexport function ruleToAudit(rule: RuleData): Audit {\n  const name = rule.id.split('/').at(-1) ?? rule.id;\n  const plugin =\n    name === rule.id ? null : rule.id.slice(0, rule.id.lastIndexOf('/'));\n  const pluginContext = plugin ? `, from _${plugin}_ plugin` : '';\n\n  const lines: string[] = [\n    `ESLint rule **${name}**${pluginContext}.`,\n    ...(rule.options?.length ? ['Custom options:'] : []),\n    ...(rule.options?.map(option =>\n      ['```json', JSON.stringify(option, null, 2), '```'].join('\\n'),\n    ) ?? []),\n  ];\n\n  return {\n    slug: ruleToSlug(rule),\n    title: truncateTitle(rule.meta.docs?.description ?? name),\n    description: truncateDescription(lines.join('\\n\\n')),\n    ...(rule.meta.docs?.url && {\n      docsUrl: rule.meta.docs.url,\n    }),\n  };\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/runner/index.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/runner\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/runner/index.ts\";import { writeFile } from 'node:fs/promises';\nimport path from 'node:path';\nimport type { Audit, AuditOutput, RunnerConfig } from '@code-pushup/models';\nimport {\n  ensureDirectoryExists,\n  filePathToCliArg,\n  pluginWorkDir,\n  readJsonFile,\n} from '@code-pushup/utils';\nimport type { ESLintPluginRunnerConfig, ESLintTarget } from '../config.js';\nimport { lint } from './lint.js';\nimport { lintResultsToAudits, mergeLinterOutputs } from './transform.js';\nimport type { LinterOutput } from './types.js';\n\nexport const WORKDIR = pluginWorkDir('eslint');\nexport const RUNNER_OUTPUT_PATH = path.join(WORKDIR, 'runner-output.json');\nexport const PLUGIN_CONFIG_PATH = path.join(\n  process.cwd(),\n  WORKDIR,\n  'plugin-config.json',\n);\n\nexport async function executeRunner(): Promise<void> {\n  const { slugs, targets } =\n    await readJsonFile<ESLintPluginRunnerConfig>(PLUGIN_CONFIG_PATH);\n\n  const linterOutputs = await targets.reduce(\n    async (acc, target) => [...(await acc), await lint(target)],\n    Promise.resolve<LinterOutput[]>([]),\n  );\n  const lintResults = mergeLinterOutputs(linterOutputs);\n  const failedAudits = lintResultsToAudits(lintResults);\n\n  const audits = slugs.map(\n    (slug): AuditOutput =>\n      failedAudits.find(audit => audit.slug === slug) ?? {\n        slug,\n        score: 1,\n        value: 0,\n        displayValue: 'passed',\n        details: { issues: [] },\n      },\n  );\n\n  await ensureDirectoryExists(path.dirname(RUNNER_OUTPUT_PATH));\n  await writeFile(RUNNER_OUTPUT_PATH, JSON.stringify(audits));\n}\n\nexport async function createRunnerConfig(\n  scriptPath: string,\n  audits: Audit[],\n  targets: ESLintTarget[],\n): Promise<RunnerConfig> {\n  const config: ESLintPluginRunnerConfig = {\n    targets,\n    slugs: audits.map(audit => audit.slug),\n  };\n  await ensureDirectoryExists(path.dirname(PLUGIN_CONFIG_PATH));\n  await writeFile(PLUGIN_CONFIG_PATH, JSON.stringify(config));\n\n  return {\n    command: 'node',\n    args: [filePathToCliArg(scriptPath)],\n    outputFile: RUNNER_OUTPUT_PATH,\n  };\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/runner/lint.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/runner\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/runner/lint.ts\";import type { ESLint, Linter } from 'eslint';\nimport { platform } from 'node:os';\nimport {\n  distinct,\n  executeProcess,\n  filePathToCliArg,\n  toArray,\n} from '@code-pushup/utils';\nimport type { ESLintTarget } from '../config.js';\nimport { setupESLint } from '../setup.js';\nimport type { LinterOutput, RuleOptionsPerFile } from './types.js';\n\nexport async function lint({\n  eslintrc,\n  patterns,\n}: ESLintTarget): Promise<LinterOutput> {\n  const results = await executeLint({ eslintrc, patterns });\n  const eslint = await setupESLint(eslintrc);\n  const ruleOptionsPerFile = await loadRuleOptionsPerFile(eslint, results);\n  return { results, ruleOptionsPerFile };\n}\n\nasync function executeLint({\n  eslintrc,\n  patterns,\n}: ESLintTarget): Promise<ESLint.LintResult[]> {\n  // running as CLI because ESLint#lintFiles() runs out of memory\n  const { stdout } = await executeProcess({\n    command: 'npx',\n    args: [\n      'eslint',\n      ...(eslintrc ? [`--config=${filePathToCliArg(eslintrc)}`] : []),\n      ...(typeof eslintrc === 'object' ? ['--no-eslintrc'] : []),\n      '--no-error-on-unmatched-pattern',\n      '--format=json',\n      ...toArray(patterns).map(pattern =>\n        // globs need to be escaped on Unix\n        platform() === 'win32' ? pattern : `'${pattern}'`,\n      ),\n    ],\n    ignoreExitCode: true,\n    cwd: process.cwd(),\n  });\n\n  return JSON.parse(stdout) as ESLint.LintResult[];\n}\n\nfunction loadRuleOptionsPerFile(\n  eslint: ESLint,\n  results: ESLint.LintResult[],\n): Promise<RuleOptionsPerFile> {\n  return results.reduce(async (acc, { filePath, messages }) => {\n    const filesMap = await acc;\n    const config = (await eslint.calculateConfigForFile(\n      filePath,\n    )) as Linter.Config;\n    const ruleIds = distinct(\n      messages\n        .map(({ ruleId }) => ruleId)\n        .filter((ruleId): ruleId is string => ruleId != null),\n    );\n    const rulesMap = Object.fromEntries(\n      ruleIds.map(ruleId => [\n        ruleId,\n        toArray(config.rules?.[ruleId] ?? []).slice(1),\n      ]),\n    );\n    return {\n      ...filesMap,\n      [filePath]: {\n        ...filesMap[filePath],\n        ...rulesMap,\n      },\n    };\n  }, Promise.resolve<RuleOptionsPerFile>({}));\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/runner/transform.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/runner\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/runner/transform.ts\";import type { Linter } from 'eslint';\nimport type { AuditOutput, Issue, IssueSeverity } from '@code-pushup/models';\nimport {\n  compareIssueSeverity,\n  countOccurrences,\n  objectToEntries,\n  pluralizeToken,\n  truncateIssueMessage,\n  ui,\n} from '@code-pushup/utils';\nimport { ruleIdToSlug } from '../meta/index.js';\nimport type { LinterOutput } from './types.js';\n\ntype LintIssue = Linter.LintMessage & {\n  filePath: string;\n};\n\nexport function mergeLinterOutputs(outputs: LinterOutput[]): LinterOutput {\n  return outputs.reduce<LinterOutput>(\n    (acc, { results, ruleOptionsPerFile }) => ({\n      results: [...acc.results, ...results],\n      ruleOptionsPerFile: { ...acc.ruleOptionsPerFile, ...ruleOptionsPerFile },\n    }),\n    { results: [], ruleOptionsPerFile: {} },\n  );\n}\n\nexport function lintResultsToAudits({\n  results,\n  ruleOptionsPerFile,\n}: LinterOutput): AuditOutput[] {\n  const issuesPerAudit = results\n    .flatMap(({ messages, filePath }) =>\n      messages.map((message): LintIssue => ({ ...message, filePath })),\n    )\n    .reduce<Record<string, LintIssue[]>>((acc, issue) => {\n      const { ruleId, message, filePath } = issue;\n      if (!ruleId) {\n        ui().logger.warning(\n          `ESLint core error - ${message} (file: ${filePath})`,\n        );\n        return acc;\n      }\n      const options = ruleOptionsPerFile[filePath]?.[ruleId] ?? [];\n      const auditSlug = ruleIdToSlug(ruleId, options);\n      return { ...acc, [auditSlug]: [...(acc[auditSlug] ?? []), issue] };\n    }, {});\n\n  return Object.entries(issuesPerAudit).map(entry => toAudit(...entry));\n}\n\nfunction toAudit(slug: string, issues: LintIssue[]): AuditOutput {\n  const auditIssues = issues.map(convertIssue);\n  const severityCounts = countOccurrences(\n    auditIssues.map(({ severity }) => severity),\n  );\n  const severities = objectToEntries(severityCounts);\n  const summaryText = severities\n    .toSorted((a, b) => -compareIssueSeverity(a[0], b[0]))\n    .map(([severity, count = 0]) => pluralizeToken(severity, count))\n    .join(', ');\n\n  return {\n    slug,\n    score: Number(auditIssues.length === 0),\n    value: auditIssues.length,\n    displayValue: summaryText,\n    details: {\n      issues: auditIssues,\n    },\n  };\n}\n\nfunction convertIssue(issue: LintIssue): Issue {\n  return {\n    message: truncateIssueMessage(issue.message),\n    severity: convertSeverity(issue.severity),\n    source: {\n      file: issue.filePath,\n      ...(issue.line > 0 && {\n        position: {\n          startLine: issue.line,\n          ...(issue.column > 0 && { startColumn: issue.column }),\n          ...(issue.endLine &&\n            issue.endLine > 0 && {\n              endLine: issue.endLine,\n            }),\n          ...(issue.endColumn &&\n            issue.endColumn > 0 && { endColumn: issue.endColumn }),\n        },\n      }),\n    },\n  };\n}\n\nfunction convertSeverity(severity: Linter.Severity): IssueSeverity {\n  switch (severity) {\n    case 2:\n      return 'error';\n    case 1:\n      return 'warning';\n    case 0:\n      // shouldn't happen\n      throw new Error(`Unexpected severity ${severity} in ESLint results`);\n  }\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/nx/utils.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/nx\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/nx/utils.ts\";import type { ProjectConfiguration } from '@nx/devkit';\nimport path from 'node:path';\nimport { fileExists, toArray } from '@code-pushup/utils';\nimport type { ConfigFormat } from '../meta/index.js';\n\nconst ESLINT_CONFIG_EXTENSIONS: Record<ConfigFormat, string[]> = {\n  // https://eslint.org/docs/latest/use/configure/configuration-files#configuration-file-formats\n  flat: ['js', 'mjs', 'cjs'],\n  // https://eslint.org/docs/latest/use/configure/configuration-files-deprecated\n  legacy: ['json', 'js', 'cjs', 'yml', 'yaml'],\n};\nconst ESLINT_CONFIG_NAMES: Record<ConfigFormat, string[]> = {\n  // https://eslint.org/docs/latest/use/configure/configuration-files#configuration-file-formats\n  flat: ['eslint.config'],\n  // https://eslint.org/docs/latest/use/configure/configuration-files-deprecated\n  legacy: ['.eslintrc'],\n};\n\nconst CP_ESLINT_CONFIG_NAMES: Record<ConfigFormat, string[]> = {\n  flat: [\n    'code-pushup.eslint.config',\n    'eslint.code-pushup.config',\n    'eslint.config.code-pushup',\n    'eslint.strict.config',\n    'eslint.config.strict',\n  ],\n  legacy: ['code-pushup.eslintrc', '.eslintrc.code-pushup', '.eslintrc.strict'],\n};\n\nexport async function findCodePushupEslintConfig(\n  project: ProjectConfiguration,\n  format: ConfigFormat,\n): Promise<string | undefined> {\n  return findProjectFile(project, {\n    names: CP_ESLINT_CONFIG_NAMES[format],\n    extensions: ESLINT_CONFIG_EXTENSIONS[format],\n  });\n}\n\nexport async function findEslintConfig(\n  project: ProjectConfiguration,\n  format: ConfigFormat,\n): Promise<string | undefined> {\n  const options = project.targets?.['lint']?.options as\n    | { eslintConfig?: string }\n    | undefined;\n  return (\n    options?.eslintConfig ??\n    (await findProjectFile(project, {\n      names: ESLINT_CONFIG_NAMES[format],\n      extensions: ESLINT_CONFIG_EXTENSIONS[format],\n    }))\n  );\n}\n\nexport function getLintFilePatterns(\n  project: ProjectConfiguration,\n  format: ConfigFormat,\n): string[] {\n  const options = project.targets?.['lint']?.options as\n    | { lintFilePatterns?: string | string[] }\n    | undefined;\n  // lintFilePatterns defaults to [\"{projectRoot}\"] - https://github.com/nrwl/nx/pull/20313\n  const defaultPatterns =\n    format === 'legacy'\n      ? `${project.root}/**/*` // files not folder needed for legacy because rules detected with ESLint.calculateConfigForFile\n      : project.root;\n  const patterns =\n    options?.lintFilePatterns == null\n      ? [defaultPatterns]\n      : toArray(options.lintFilePatterns);\n  if (format === 'legacy') {\n    return [\n      ...patterns,\n      // HACK: ESLint.calculateConfigForFile won't find rules included only for subsets of *.ts when globs used\n      // so we explicitly provide additional patterns used by @code-pushup/eslint-config to ensure those rules are included\n      // this workaround is only necessary for legacy configs (rules are detected more reliably in flat configs)\n      `${project.root}/*.spec.ts`, // jest/* and vitest/* rules\n      `${project.root}/*.cy.ts`, // cypress/* rules\n      `${project.root}/*.stories.ts`, // storybook/* rules\n      `${project.root}/.storybook/main.ts`, // storybook/no-uninstalled-addons rule\n    ];\n  }\n  return patterns;\n}\n\nasync function findProjectFile(\n  project: ProjectConfiguration,\n  file: {\n    names: string[];\n    extensions: string[];\n  },\n): Promise<string | undefined> {\n  // eslint-disable-next-line functional/no-loop-statements\n  for (const name of file.names) {\n    // eslint-disable-next-line functional/no-loop-statements\n    for (const ext of file.extensions) {\n      const filename = `./${project.root}/${name}.${ext}`;\n      if (await fileExists(path.join(process.cwd(), filename))) {\n        return filename;\n      }\n    }\n  }\n  return undefined;\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/js-packages-plugin.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/js-packages-plugin.ts\";import { createRequire } from 'node:module';\nimport path from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport type { Audit, Group, PluginConfig } from '@code-pushup/models';\nimport {\n  type DependencyGroup,\n  type JSPackagesPluginConfig,\n  type PackageCommand,\n  type PackageManagerId,\n  dependencyGroups,\n} from './config.js';\nimport { dependencyDocs, dependencyGroupWeights } from './constants.js';\nimport { packageManagers } from './package-managers/package-managers.js';\nimport { createRunnerConfig } from './runner/index.js';\nimport { normalizeConfig } from './utils.js';\n\n/**\n * Instantiates Code PushUp JS packages plugin for core config.\n *\n * @example\n * import jsPackagesPlugin from '@code-pushup/js-packages-plugin'\n *\n * export default {\n *   // ... core config ...\n *   plugins: [\n *     // ... other plugins ...\n *     await jsPackagesPlugin({ packageManager: 'npm' })\n *   ]\n * }\n *\n * @returns Plugin configuration.\n */\n\nexport async function jsPackagesPlugin(\n  config?: JSPackagesPluginConfig,\n): Promise<PluginConfig> {\n  const { packageManager, checks, depGroups, ...jsPackagesPluginConfigRest } =\n    await normalizeConfig(config);\n\n  const runnerScriptPath = path.join(\n    fileURLToPath(path.dirname(import.meta.url)),\n    '..',\n    'bin.js',\n  );\n\n  const packageJson = createRequire(import.meta.url)(\n    '../../package.json',\n  ) as typeof import('../../package.json');\n\n  return {\n    slug: 'js-packages',\n    title: 'JS Packages',\n    icon: packageManager.icon,\n    description:\n      'This plugin runs audit to uncover vulnerabilities and lists outdated dependencies. It supports npm, yarn classic, yarn modern, and pnpm package managers.',\n    docsUrl: packageManager.docs.homepage,\n    packageName: packageJson.name,\n    version: packageJson.version,\n    audits: createAudits(packageManager.slug, checks, depGroups),\n    groups: createGroups(packageManager.slug, checks, depGroups),\n    runner: await createRunnerConfig(runnerScriptPath, {\n      ...jsPackagesPluginConfigRest,\n      checks,\n      packageManager: packageManager.slug,\n      dependencyGroups: depGroups,\n    }),\n  };\n}\n\nfunction createGroups(\n  id: PackageManagerId,\n  checks: PackageCommand[],\n  depGroups: DependencyGroup[],\n): Group[] {\n  const pm = packageManagers[id];\n  const supportedAuditDepGroups =\n    pm.audit.supportedDepGroups ?? dependencyGroups;\n  const compatibleAuditDepGroups = depGroups.filter(group =>\n    supportedAuditDepGroups.includes(group),\n  );\n\n  const groups: Record<PackageCommand, Group> = {\n    audit: {\n      slug: `${pm.slug}-audit`,\n      title: `${pm.name} audit`,\n      description: `Group containing ${pm.name} vulnerabilities.`,\n      docsUrl: pm.docs.audit,\n      refs: compatibleAuditDepGroups.map(depGroup => ({\n        slug: `${pm.slug}-audit-${depGroup}`,\n        weight: dependencyGroupWeights[depGroup],\n      })),\n    },\n    outdated: {\n      slug: `${pm.slug}-outdated`,\n      title: `${pm.name} outdated dependencies`,\n      description: `Group containing outdated ${pm.name} dependencies.`,\n      docsUrl: pm.docs.outdated,\n      refs: depGroups.map(depGroup => ({\n        slug: `${pm.slug}-outdated-${depGroup}`,\n        weight: dependencyGroupWeights[depGroup],\n      })),\n    },\n  };\n\n  return checks.map(check => groups[check]);\n}\n\nfunction createAudits(\n  id: PackageManagerId,\n  checks: PackageCommand[],\n  depGroups: DependencyGroup[],\n): Audit[] {\n  const { slug } = packageManagers[id];\n  return checks.flatMap(check => {\n    const supportedAuditDepGroups =\n      packageManagers[id].audit.supportedDepGroups ?? dependencyGroups;\n\n    const compatibleDepGroups =\n      check === 'audit'\n        ? depGroups.filter(group => supportedAuditDepGroups.includes(group))\n        : depGroups;\n\n    return compatibleDepGroups.map(depGroup => ({\n      slug: `${slug}-${check}-${depGroup}`,\n      title: getAuditTitle(slug, check, depGroup),\n      description: getAuditDescription(check, depGroup),\n      docsUrl: dependencyDocs[depGroup],\n    }));\n  });\n}\n\nfunction getAuditTitle(\n  id: PackageManagerId,\n  check: PackageCommand,\n  depGroup: DependencyGroup,\n) {\n  const pm = packageManagers[id];\n  return check === 'audit'\n    ? `Vulnerabilities for ${pm.name} ${depGroup} dependencies.`\n    : `Outdated ${pm.name} ${depGroup} dependencies.`;\n}\n\nfunction getAuditDescription(check: PackageCommand, depGroup: DependencyGroup) {\n  return check === 'audit'\n    ? `Runs security audit on ${depGroup} dependencies.`\n    : `Checks for outdated ${depGroup} dependencies`;\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/config.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/config.ts\";import { z } from 'zod';\nimport { type IssueSeverity, issueSeveritySchema } from '@code-pushup/models';\nimport { defaultAuditLevelMapping } from './constants.js';\n\nexport const dependencyGroups = ['prod', 'dev', 'optional'] as const;\nconst dependencyGroupSchema = z.enum(dependencyGroups);\nexport type DependencyGroup = (typeof dependencyGroups)[number];\n\nconst packageCommandSchema = z.enum(['audit', 'outdated']);\nexport type PackageCommand = z.infer<typeof packageCommandSchema>;\n\nconst packageManagerIdSchema = z.enum([\n  'npm',\n  'yarn-classic',\n  'yarn-modern',\n  'pnpm',\n]);\nexport type PackageManagerId = z.infer<typeof packageManagerIdSchema>;\n\nconst packageJsonPathSchema = z\n  .union([\n    z.array(z.string()).min(1),\n    z.object({ autoSearch: z.literal(true) }),\n  ])\n  .describe(\n    'File paths to package.json. Looks only at root package.json by default',\n  )\n  .default(['package.json']);\n\nexport type PackageJsonPaths = z.infer<typeof packageJsonPathSchema>;\n\nexport const packageAuditLevels = [\n  'critical',\n  'high',\n  'moderate',\n  'low',\n  'info',\n] as const;\nconst packageAuditLevelSchema = z.enum(packageAuditLevels);\nexport type PackageAuditLevel = z.infer<typeof packageAuditLevelSchema>;\n\nexport type AuditSeverity = Record<PackageAuditLevel, IssueSeverity>;\n\nexport function fillAuditLevelMapping(\n  mapping: Partial<AuditSeverity>,\n): AuditSeverity {\n  return {\n    critical: mapping.critical ?? defaultAuditLevelMapping.critical,\n    high: mapping.high ?? defaultAuditLevelMapping.high,\n    moderate: mapping.moderate ?? defaultAuditLevelMapping.moderate,\n    low: mapping.low ?? defaultAuditLevelMapping.low,\n    info: mapping.info ?? defaultAuditLevelMapping.info,\n  };\n}\n\nexport const jsPackagesPluginConfigSchema = z.object({\n  checks: z\n    .array(packageCommandSchema, {\n      description:\n        'Package manager commands to be run. Defaults to both audit and outdated.',\n    })\n    .min(1)\n    .default(['audit', 'outdated']),\n  packageManager: packageManagerIdSchema\n    .describe('Package manager to be used.')\n    .optional(),\n  dependencyGroups: z\n    .array(dependencyGroupSchema)\n    .min(1)\n    .default(['prod', 'dev']),\n  auditLevelMapping: z\n    .record(packageAuditLevelSchema, issueSeveritySchema, {\n      description:\n        'Mapping of audit levels to issue severity. Custom mapping or overrides may be entered manually, otherwise has a default preset.',\n    })\n    .default(defaultAuditLevelMapping)\n    .transform(fillAuditLevelMapping),\n  packageJsonPaths: packageJsonPathSchema,\n});\n\nexport type JSPackagesPluginConfig = z.input<\n  typeof jsPackagesPluginConfigSchema\n>;\n\nexport type FinalJSPackagesPluginConfig = Required<\n  z.infer<typeof jsPackagesPluginConfigSchema>\n>;\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/constants.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/constants.ts\";import type { IssueSeverity } from '@code-pushup/models';\nimport type { DependencyGroup, PackageAuditLevel } from './config.js';\nimport type { DependencyGroupLong } from './runner/outdated/types.js';\n\nexport const defaultAuditLevelMapping: Record<\n  PackageAuditLevel,\n  IssueSeverity\n> = {\n  critical: 'error',\n  high: 'error',\n  moderate: 'warning',\n  low: 'warning',\n  info: 'info',\n};\n\nexport const dependencyGroupToLong: Record<\n  DependencyGroup,\n  DependencyGroupLong\n> = {\n  prod: 'dependencies',\n  dev: 'devDependencies',\n  optional: 'optionalDependencies',\n};\n\nexport const dependencyGroupWeights: Record<DependencyGroup, number> = {\n  /* eslint-disable @typescript-eslint/no-magic-numbers */\n  prod: 80,\n  dev: 15,\n  optional: 5,\n  /* eslint-enable @typescript-eslint/no-magic-numbers */\n};\n\nexport const dependencyDocs: Record<DependencyGroup, string> = {\n  prod: 'https://classic.yarnpkg.com/docs/dependency-types#toc-dependencies',\n  dev: 'https://classic.yarnpkg.com/docs/dependency-types#toc-devdependencies',\n  optional:\n    'https://classic.yarnpkg.com/docs/dependency-types#toc-optionaldependencies',\n};\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/npm/npm.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/npm\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/npm/npm.ts\";import { objectToKeys } from '@code-pushup/utils';\nimport type { DependencyGroup } from '../../config.js';\nimport { filterAuditResult } from '../../runner/utils.js';\nimport { COMMON_AUDIT_ARGS, COMMON_OUTDATED_ARGS } from '../constants.js';\nimport type { AuditResults, PackageManager } from '../types.js';\nimport { npmToAuditResult } from './audit-result.js';\nimport { npmToOutdatedResult } from './outdated-result.js';\n\nconst npmDependencyOptions: Record<DependencyGroup, string[]> = {\n  prod: ['--omit=dev', '--omit=optional'],\n  dev: ['--include=dev', '--omit=optional'],\n  optional: ['--include=optional', '--omit=dev'],\n};\n\nexport const npmPackageManager: PackageManager = {\n  slug: 'npm',\n  name: 'NPM',\n  command: 'npm',\n  icon: 'npm',\n  docs: {\n    homepage: 'https://docs.npmjs.com/',\n    audit: 'https://docs.npmjs.com/cli/commands/npm-audit',\n    outdated: 'https://docs.npmjs.com/cli/commands/npm-outdated',\n  },\n  audit: {\n    getCommandArgs: groupDep => [\n      ...COMMON_AUDIT_ARGS,\n      ...npmDependencyOptions[groupDep],\n      '--audit-level=none',\n    ],\n    unifyResult: npmToAuditResult,\n    // prod dependencies need to be filtered out manually since v10\n    postProcessResult: (results: AuditResults) => {\n      const depGroups = objectToKeys(results);\n      const devFilter =\n        results.dev && results.prod\n          ? filterAuditResult(results.dev, 'name', results.prod)\n          : results.dev;\n      const optionalFilter =\n        results.optional && results.prod\n          ? filterAuditResult(results.optional, 'name', results.prod)\n          : results.optional;\n\n      return {\n        ...(depGroups.includes('prod') && { prod: results.prod }),\n        ...(depGroups.includes('dev') && { dev: devFilter }),\n        ...(depGroups.includes('optional') && { optional: optionalFilter }),\n      };\n    },\n  },\n  outdated: {\n    commandArgs: [...COMMON_OUTDATED_ARGS, '--long'],\n    unifyResult: npmToOutdatedResult,\n  },\n};\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/utils.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/utils.ts\";import path from 'node:path';\nimport {\n  crawlFileSystem,\n  objectFromEntries,\n  objectToKeys,\n  readJsonFile,\n} from '@code-pushup/utils';\nimport type { AuditResult, Vulnerability } from './audit/types.js';\nimport {\n  type DependencyGroupLong,\n  type DependencyTotals,\n  type PackageJson,\n  dependencyGroupLong,\n} from './outdated/types.js';\n\nexport function filterAuditResult(\n  result: AuditResult,\n  key: keyof Vulnerability,\n  referenceResult?: AuditResult,\n): AuditResult {\n  if (result.vulnerabilities.length === 0) {\n    return result;\n  }\n\n  const uniqueResult = result.vulnerabilities.reduce<AuditResult>(\n    (acc, ref) => {\n      const matchReference = referenceResult ?? acc;\n      const isMatch = matchReference.vulnerabilities\n        .map(vulnerability => vulnerability[key])\n        .includes(ref[key]);\n\n      if (isMatch) {\n        return {\n          vulnerabilities: acc.vulnerabilities,\n          summary: {\n            ...acc.summary,\n            [ref.severity]: acc.summary[ref.severity] - 1,\n            total: acc.summary.total - 1,\n          },\n        };\n      }\n\n      return {\n        vulnerabilities: [...acc.vulnerabilities, ref],\n        summary: acc.summary,\n      };\n    },\n    { vulnerabilities: [], summary: result.summary },\n  );\n\n  return {\n    vulnerabilities: uniqueResult.vulnerabilities,\n    summary: uniqueResult.summary,\n  };\n}\n\n// TODO: use .gitignore\nexport async function findAllPackageJson(): Promise<string[]> {\n  return (\n    await crawlFileSystem({\n      directory: '.',\n      pattern: /(^|[\\\\/])package\\.json$/,\n    })\n  ).filter(\n    filePath =>\n      !filePath.startsWith(`node_modules${path.sep}`) &&\n      !filePath.includes(`${path.sep}node_modules${path.sep}`) &&\n      !filePath.startsWith(`.nx${path.sep}`),\n  );\n}\n\nexport async function getTotalDependencies(\n  packageJsonPaths: string[],\n): Promise<DependencyTotals> {\n  const parsedDeps = await Promise.all(\n    packageJsonPaths.map(readJsonFile<PackageJson>),\n  );\n\n  const mergedDeps = parsedDeps.reduce<Record<DependencyGroupLong, string[]>>(\n    (acc, depMapper) =>\n      objectFromEntries(\n        dependencyGroupLong.map(group => {\n          const deps = depMapper[group];\n          return [\n            group,\n            [...acc[group], ...(deps == null ? [] : objectToKeys(deps))],\n          ];\n        }),\n      ),\n    { dependencies: [], devDependencies: [], optionalDependencies: [] },\n  );\n  return objectFromEntries(\n    objectToKeys(mergedDeps).map(deps => [\n      deps,\n      new Set(mergedDeps[deps]).size,\n    ]),\n  );\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/constants.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/constants.ts\";export const COMMON_AUDIT_ARGS = ['audit', '--json'];\nexport const COMMON_OUTDATED_ARGS = ['outdated', '--json'];\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/npm/audit-result.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/npm\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/npm/audit-result.ts\";import { objectToEntries } from '@code-pushup/utils';\nimport type { AuditResult, Vulnerability } from '../../runner/audit/types.js';\nimport type {\n  NpmAdvisory,\n  NpmAuditResultJson,\n  NpmFixInformation,\n  NpmVulnerabilities,\n} from './types.js';\n\nexport function npmToAuditResult(output: string): AuditResult {\n  const npmAudit = JSON.parse(output) as NpmAuditResultJson;\n\n  const vulnerabilities = objectToEntries(npmAudit.vulnerabilities).map(\n    ([name, detail]): Vulnerability => {\n      const advisory = npmToAdvisory(name, npmAudit.vulnerabilities);\n      return {\n        name: name.toString(),\n        severity: detail.severity,\n        versionRange: detail.range,\n        directDependency: detail.isDirect ? true : (detail.effects[0] ?? ''),\n        fixInformation: npmToFixInformation(detail.fixAvailable),\n        ...(advisory != null && {\n          title: advisory.title,\n          url: advisory.url,\n        }),\n      };\n    },\n  );\n\n  return {\n    vulnerabilities,\n    summary: npmAudit.metadata.vulnerabilities,\n  };\n}\n\nexport function npmToFixInformation(\n  fixAvailable: boolean | NpmFixInformation,\n): string {\n  if (typeof fixAvailable === 'boolean') {\n    return fixAvailable ? 'Fix is available.' : '';\n  }\n\n  return `Fix available: Update \\`${fixAvailable.name}\\` to version **${\n    fixAvailable.version\n  }**${fixAvailable.isSemVerMajor ? ' (breaking change).' : '.'}`;\n}\n\nexport function npmToAdvisory(\n  name: string,\n  vulnerabilities: NpmVulnerabilities,\n  prevNodes = new Set<string>(),\n): NpmAdvisory | null {\n  const advisory = vulnerabilities[name]?.via;\n\n  if (\n    Array.isArray(advisory) &&\n    advisory.length > 0 &&\n    typeof advisory[0] === 'object'\n  ) {\n    return { title: advisory[0].title, url: advisory[0].url };\n  }\n\n  // Cross-references another vulnerability\n  if (\n    Array.isArray(advisory) &&\n    advisory.length > 0 &&\n    advisory.every((value): value is string => typeof value === 'string')\n  ) {\n    /* eslint-disable functional/no-let, functional/immutable-data, functional/no-loop-statements, prefer-const */\n    let advisoryInfo: NpmAdvisory | null = null;\n    let newReferences: string[] = [];\n    let advisoryInfoFound = false;\n    /* eslint-enable functional/no-let, prefer-const */\n\n    for (const via of advisory) {\n      if (!prevNodes.has(via)) {\n        newReferences.push(via);\n      }\n    }\n\n    while (newReferences.length > 0 && !advisoryInfoFound) {\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      const ref = newReferences.pop()!;\n      prevNodes.add(ref);\n      const result = npmToAdvisory(ref, vulnerabilities, prevNodes);\n\n      if (result != null) {\n        advisoryInfo = { title: result.title, url: result.url };\n        advisoryInfoFound = true;\n      }\n    }\n    /* eslint-enable functional/immutable-data, functional/no-loop-statements */\n\n    return advisoryInfo;\n  }\n\n  return null;\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/npm/outdated-result.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/npm\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/npm/outdated-result.ts\";import { objectToEntries } from '@code-pushup/utils';\nimport type { OutdatedResult } from '../../runner/outdated/types.js';\nimport type { NpmNormalizedOverview, NpmOutdatedResultJson } from './types.js';\n\nexport function npmToOutdatedResult(output: string): OutdatedResult {\n  const npmOutdated = JSON.parse(output) as NpmOutdatedResultJson;\n  // current might be missing in some cases\n  // https://stackoverflow.com/questions/42267101/npm-outdated-command-shows-missing-in-current-version\n  return objectToEntries(npmOutdated)\n    .filter(\n      (entry): entry is [string, NpmNormalizedOverview] =>\n        entry[1].current != null,\n    )\n    .map(([name, overview]) => ({\n      name,\n      current: overview.current,\n      latest: overview.latest,\n      type: overview.type,\n      ...(overview.homepage != null && { url: overview.homepage }),\n    }));\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/pnpm/pnpm.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/pnpm\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/pnpm/pnpm.ts\";import { objectToKeys } from '@code-pushup/utils';\nimport type { DependencyGroup } from '../../config.js';\nimport { filterAuditResult } from '../../runner/utils.js';\nimport { COMMON_AUDIT_ARGS, COMMON_OUTDATED_ARGS } from '../constants.js';\nimport type { AuditResults, PackageManager } from '../types.js';\nimport { pnpmToAuditResult } from './audit-result.js';\nimport { pnpmToOutdatedResult } from './outdated-result.js';\n\nconst pnpmDependencyOptions: Record<DependencyGroup, string[]> = {\n  prod: ['--prod', '--no-optional'],\n  dev: ['--dev', '--no-optional'],\n  optional: [],\n};\n\nexport const pnpmPackageManager: PackageManager = {\n  slug: 'pnpm',\n  name: 'pnpm',\n  command: 'pnpm',\n  icon: 'pnpm',\n  docs: {\n    homepage: 'https://pnpm.io/pnpm-cli',\n    audit: 'https://pnpm.io/cli/audit/',\n    outdated: 'https://pnpm.io/cli/outdated',\n  },\n  audit: {\n    getCommandArgs: groupDep => [\n      ...COMMON_AUDIT_ARGS,\n      ...pnpmDependencyOptions[groupDep],\n    ],\n    ignoreExitCode: true,\n    unifyResult: pnpmToAuditResult,\n    // optional dependencies don't have an exclusive option so they need duplicates filtered out\n    postProcessResult: (results: AuditResults) => {\n      const depGroups = objectToKeys(results);\n      const prodFilter =\n        results.optional && results.prod\n          ? filterAuditResult(results.optional, 'id', results.prod)\n          : results.optional;\n      const devFilter =\n        prodFilter && results.dev\n          ? filterAuditResult(prodFilter, 'id', results.dev)\n          : results.optional;\n\n      return {\n        ...(depGroups.includes('prod') && { prod: results.prod }),\n        ...(depGroups.includes('dev') && { dev: results.dev }),\n        ...(results.optional && { optional: devFilter }),\n      };\n    },\n  },\n  outdated: {\n    commandArgs: COMMON_OUTDATED_ARGS,\n    unifyResult: pnpmToOutdatedResult,\n  },\n};\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/pnpm/outdated-result.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/pnpm\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/pnpm/outdated-result.ts\";import { objectToEntries } from '@code-pushup/utils';\nimport type { OutdatedResult } from '../../runner/outdated/types.js';\nimport type { PnpmOutdatedResultJson } from './types.js';\nimport { filterOutWarnings } from './utils.js';\n\nexport function pnpmToOutdatedResult(output: string): OutdatedResult {\n  const pnpmOutdated = JSON.parse(\n    filterOutWarnings(output),\n  ) as PnpmOutdatedResultJson;\n\n  return objectToEntries(pnpmOutdated).map(\n    ([name, { current, latest, dependencyType: type }]) => ({\n      name,\n      current,\n      latest,\n      type,\n    }),\n  );\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/yarn-classic/audit-result.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/yarn-classic\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/yarn-classic/audit-result.ts\";import { fromJsonLines } from '@code-pushup/utils';\nimport type { AuditResult, Vulnerability } from '../../runner/audit/types.js';\nimport { filterAuditResult } from '../../runner/utils.js';\nimport type {\n  Yarnv1AuditAdvisory,\n  Yarnv1AuditResultJson,\n  Yarnv1AuditSummary,\n} from './types.js';\n\nexport function yarnv1ToAuditResult(output: string): AuditResult {\n  const yarnv1Result = fromJsonLines<Yarnv1AuditResultJson>(output);\n  const [yarnv1Advisory, yarnv1Summary] = validateYarnv1Result(yarnv1Result);\n\n  const vulnerabilities = yarnv1Advisory.map(\n    ({ data: { resolution, advisory } }): Vulnerability => {\n      const { id, path } = resolution;\n      const directDependency = path.slice(0, path.indexOf('>'));\n\n      const {\n        module_name: name,\n        title,\n        url,\n        severity,\n        vulnerable_versions: versionRange,\n        recommendation: fixInformation,\n      } = advisory;\n\n      return {\n        name,\n        title,\n        id,\n        url,\n        severity,\n        versionRange,\n        directDependency: name === directDependency ? true : directDependency,\n        fixInformation,\n      };\n    },\n  );\n\n  const summary = {\n    ...yarnv1Summary.data.vulnerabilities,\n    total: Object.values(yarnv1Summary.data.vulnerabilities).reduce(\n      (acc, amount) => acc + amount,\n      0,\n    ),\n  };\n\n  // duplicates are filtered out based on their ID\n  return filterAuditResult({ vulnerabilities, summary }, 'id');\n}\n\nfunction validateYarnv1Result(\n  result: Yarnv1AuditResultJson,\n): [Yarnv1AuditAdvisory[], Yarnv1AuditSummary] {\n  const summary = result.at(-1);\n  if (summary?.type !== 'auditSummary') {\n    throw new Error('Invalid Yarn v1 audit result - no summary found.');\n  }\n\n  const vulnerabilities = result.filter(\n    (item): item is Yarnv1AuditAdvisory => item.type === 'auditAdvisory',\n  );\n\n  return [vulnerabilities, summary];\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/yarn-classic/outdated-result.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/yarn-classic\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/yarn-classic/outdated-result.ts\";import {\n  fromJsonLines,\n  objectFromEntries,\n  objectToEntries,\n  objectToKeys,\n} from '@code-pushup/utils';\nimport type {\n  OutdatedDependency,\n  OutdatedResult,\n} from '../../runner/outdated/types.js';\nimport {\n  REQUIRED_OUTDATED_FIELDS,\n  outdatedtoFieldMapper,\n} from './constants.js';\nimport {\n  type Yarnv1FieldName,\n  type Yarnv1OutdatedResultJson,\n  yarnv1FieldNames,\n} from './types.js';\n\nexport function yarnv1ToOutdatedResult(output: string): OutdatedResult {\n  const yarnv1Outdated = fromJsonLines<Yarnv1OutdatedResultJson>(output);\n  const fields = yarnv1Outdated[1].data.head;\n  const dependencies = yarnv1Outdated[1].data.body;\n\n  // no outdated dependencies\n  if (dependencies.length === 0) {\n    return [];\n  }\n\n  // map dynamic fields\n  validateOutdatedFields(fields);\n  const indexMapping = getOutdatedFieldIndexes(fields);\n\n  return dependencies.map(\n    dep =>\n      objectFromEntries(\n        objectToKeys(indexMapping)\n          .map(field => [field, dep[indexMapping[field]]] as const)\n          .filter(\n            (entry): entry is [keyof OutdatedDependency, string] =>\n              entry[1] != null,\n          ),\n      ) as OutdatedDependency,\n  );\n}\n\nexport function validateOutdatedFields(head: string[]) {\n  const relevantFields = head.filter(isYarnv1FieldName);\n  if (hasAllRequiredFields(relevantFields)) {\n    return true;\n  }\n\n  throw new Error(\n    `Yarn v1 outdated: Template [${head.join(\n      ', ',\n    )}] does not contain all required fields [${yarnv1FieldNames.join(', ')}]`,\n  );\n}\n\nfunction isYarnv1FieldName(value: string): value is Yarnv1FieldName {\n  const names: readonly string[] = yarnv1FieldNames;\n  return names.includes(value);\n}\n\nfunction hasAllRequiredFields(head: Yarnv1FieldName[]) {\n  return REQUIRED_OUTDATED_FIELDS.every(field => head.includes(field));\n}\n\nexport function getOutdatedFieldIndexes(all: string[]) {\n  return objectFromEntries(\n    objectToEntries(outdatedtoFieldMapper).map(([outdatedField, yarnField]) => [\n      outdatedField,\n      all.indexOf(yarnField),\n    ]),\n  );\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/index.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/index.ts\";import { writeFile } from 'node:fs/promises';\nimport path from 'node:path';\nimport type { RunnerConfig } from '@code-pushup/models';\nimport {\n  ensureDirectoryExists,\n  executeProcess,\n  filePathToCliArg,\n  isPromiseFulfilledResult,\n  isPromiseRejectedResult,\n  objectFromEntries,\n  readJsonFile,\n} from '@code-pushup/utils';\nimport {\n  type AuditSeverity,\n  type DependencyGroup,\n  type FinalJSPackagesPluginConfig,\n  type PackageJsonPaths,\n  type PackageManagerId,\n  dependencyGroups,\n} from '../config.js';\nimport { dependencyGroupToLong } from '../constants.js';\nimport { packageManagers } from '../package-managers/package-managers.js';\nimport { auditResultToAuditOutput } from './audit/transform.js';\nimport type { AuditResult } from './audit/types.js';\nimport { PLUGIN_CONFIG_PATH, RUNNER_OUTPUT_PATH } from './constants.js';\nimport { outdatedResultToAuditOutput } from './outdated/transform.js';\nimport { findAllPackageJson, getTotalDependencies } from './utils.js';\n\nexport async function createRunnerConfig(\n  scriptPath: string,\n  config: FinalJSPackagesPluginConfig,\n): Promise<RunnerConfig> {\n  await ensureDirectoryExists(path.dirname(PLUGIN_CONFIG_PATH));\n  await writeFile(PLUGIN_CONFIG_PATH, JSON.stringify(config));\n\n  return {\n    command: 'node',\n    args: [filePathToCliArg(scriptPath)],\n    outputFile: RUNNER_OUTPUT_PATH,\n  };\n}\n\nexport async function executeRunner(): Promise<void> {\n  const {\n    packageManager,\n    checks,\n    auditLevelMapping,\n    packageJsonPaths,\n    dependencyGroups: depGroups,\n  } = await readJsonFile<FinalJSPackagesPluginConfig>(PLUGIN_CONFIG_PATH);\n\n  const auditResults = checks.includes('audit')\n    ? await processAudit(packageManager, depGroups, auditLevelMapping)\n    : [];\n\n  const outdatedResults = checks.includes('outdated')\n    ? await processOutdated(packageManager, depGroups, packageJsonPaths)\n    : [];\n  const checkResults = [...auditResults, ...outdatedResults];\n\n  await ensureDirectoryExists(path.dirname(RUNNER_OUTPUT_PATH));\n  await writeFile(RUNNER_OUTPUT_PATH, JSON.stringify(checkResults));\n}\n\nasync function processOutdated(\n  id: PackageManagerId,\n  depGroups: DependencyGroup[],\n  packageJsonPaths: PackageJsonPaths,\n) {\n  const pm = packageManagers[id];\n  const { stdout, stderr } = await executeProcess({\n    command: pm.command,\n    args: pm.outdated.commandArgs,\n    cwd: process.cwd(),\n    ignoreExitCode: true, // outdated returns exit code 1 when outdated dependencies are found\n  });\n\n  // Successful outdated check has empty stderr\n  if (stderr) {\n    throw new Error(`JS packages plugin: outdated error: ${stderr}`);\n  }\n\n  // Locate all package.json files in the repository if not provided\n  const finalPaths = Array.isArray(packageJsonPaths)\n    ? packageJsonPaths\n    : await findAllPackageJson();\n  const depTotals = await getTotalDependencies(finalPaths);\n\n  const normalizedResult = pm.outdated.unifyResult(stdout);\n  return depGroups.map(depGroup =>\n    outdatedResultToAuditOutput(\n      normalizedResult,\n      id,\n      depGroup,\n      depTotals[dependencyGroupToLong[depGroup]],\n    ),\n  );\n}\n\nasync function processAudit(\n  id: PackageManagerId,\n  depGroups: DependencyGroup[],\n  auditLevelMapping: AuditSeverity,\n) {\n  const pm = packageManagers[id];\n  const supportedAuditDepGroups =\n    pm.audit.supportedDepGroups ?? dependencyGroups;\n  const compatibleAuditDepGroups = depGroups.filter(group =>\n    supportedAuditDepGroups.includes(group),\n  );\n\n  const auditResults = await Promise.allSettled(\n    compatibleAuditDepGroups.map(\n      async (depGroup): Promise<[DependencyGroup, AuditResult]> => {\n        const { stdout, stderr } = await executeProcess({\n          command: pm.command,\n          args: pm.audit.getCommandArgs(depGroup),\n          cwd: process.cwd(),\n          ignoreExitCode: pm.audit.ignoreExitCode,\n        });\n        // Successful audit check has empty stderr\n        if (stderr) {\n          throw new Error(`JS packages plugin: audit error: ${stderr}`);\n        }\n        return [depGroup, pm.audit.unifyResult(stdout)];\n      },\n    ),\n  );\n\n  const rejected = auditResults.filter(isPromiseRejectedResult);\n  if (rejected.length > 0) {\n    rejected.forEach(result => {\n      console.error(result.reason);\n    });\n\n    throw new Error(`JS Packages plugin: Running ${pm.name} audit failed.`);\n  }\n\n  const fulfilled = objectFromEntries(\n    auditResults.filter(isPromiseFulfilledResult).map(x => x.value),\n  );\n\n  const uniqueResults = pm.audit.postProcessResult?.(fulfilled) ?? fulfilled;\n\n  return compatibleAuditDepGroups.map(depGroup =>\n    auditResultToAuditOutput(\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      uniqueResults[depGroup]!,\n      id,\n      depGroup,\n      auditLevelMapping,\n    ),\n  );\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/audit/transform.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/audit\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/audit/transform.ts\";import { md } from 'build-md';\nimport type { AuditOutput, Issue } from '@code-pushup/models';\nimport { objectToEntries } from '@code-pushup/utils';\nimport {\n  type AuditSeverity,\n  type DependencyGroup,\n  type PackageManagerId,\n  packageAuditLevels,\n} from '../../config.js';\nimport { auditScoreModifiers } from './constants.js';\nimport type { AuditResult, AuditSummary, Vulnerability } from './types.js';\n\nexport function auditResultToAuditOutput(\n  result: AuditResult,\n  id: PackageManagerId,\n  depGroup: DependencyGroup,\n  auditLevelMapping: AuditSeverity,\n): AuditOutput {\n  const issues = vulnerabilitiesToIssues(\n    result.vulnerabilities,\n    auditLevelMapping,\n  );\n\n  return {\n    slug: `${id}-audit-${depGroup}`,\n    score: calculateAuditScore(result.summary),\n    value: result.summary.total,\n    displayValue: summaryToDisplayValue(result.summary),\n    details: { issues },\n  };\n}\n\nexport function calculateAuditScore(stats: AuditSummary) {\n  if (stats.total === 0) {\n    return 1;\n  }\n\n  return objectToEntries(stats).reduce<number>(\n    (score, [level, vulnerabilities]) => {\n      if (level === 'total') {\n        return score;\n      }\n\n      const reducedScore = score - auditScoreModifiers[level] * vulnerabilities;\n      return Math.max(reducedScore, 0);\n    },\n    1,\n  );\n}\n\nexport function summaryToDisplayValue(summary: AuditSummary): string {\n  if (summary.total === 0) {\n    return '0 vulnerabilities';\n  }\n\n  const vulnerabilityStats = packageAuditLevels\n    .map(level => (summary[level] > 0 ? `${summary[level]} ${level}` : ''))\n    .filter(text => text !== '')\n    .join(', ');\n  return `${summary.total} ${\n    summary.total === 1 ? 'vulnerability' : 'vulnerabilities'\n  } (${vulnerabilityStats})`;\n}\n\nexport function vulnerabilitiesToIssues(\n  vulnerabilities: Vulnerability[],\n  auditLevelMapping: AuditSeverity,\n): Issue[] {\n  if (vulnerabilities.length === 0) {\n    return [];\n  }\n\n  return vulnerabilities.map((detail): Issue => {\n    const versionRange =\n      detail.versionRange === '*'\n        ? md`${md.bold('all')} versions`\n        : md`versions ${md.bold(detail.versionRange)}`;\n    const directDependency =\n      typeof detail.directDependency === 'string' &&\n      detail.directDependency !== ''\n        ? md.code(detail.directDependency)\n        : '';\n    const depHierarchy = directDependency\n      ? md`${directDependency}'s dependency ${md.code(detail.name)}`\n      : md`${md.code(detail.name)} dependency`;\n\n    const vulnerabilitySummary = md`has a ${md.bold(\n      detail.severity,\n    )} vulnerability in ${versionRange}.`;\n    const fixInfo = detail.fixInformation ? ` ${detail.fixInformation}` : '';\n    const additionalInfo =\n      detail.title != null && detail.url != null\n        ? md` More information: ${md.link(detail.url, detail.title)}`\n        : '';\n\n    return {\n      message:\n        md`${depHierarchy} ${vulnerabilitySummary}${fixInfo}${additionalInfo}`.toString(),\n      severity: auditLevelMapping[detail.severity],\n    };\n  });\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/constants.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/constants.ts\";import path from 'node:path';\nimport { pluginWorkDir } from '@code-pushup/utils';\n\nexport const WORKDIR = pluginWorkDir('js-packages');\nexport const RUNNER_OUTPUT_PATH = path.join(WORKDIR, 'runner-output.json');\nexport const PLUGIN_CONFIG_PATH = path.join(\n  process.cwd(),\n  WORKDIR,\n  'plugin-config.json',\n);\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/outdated/transform.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/outdated\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/outdated/transform.ts\";import { md } from 'build-md';\nimport { clean, diff, neq } from 'semver';\nimport type { AuditOutput, Issue } from '@code-pushup/models';\nimport { objectFromEntries, pluralize } from '@code-pushup/utils';\nimport type { DependencyGroup, PackageManagerId } from '../../config.js';\nimport { dependencyGroupToLong } from '../../constants.js';\nimport { RELEASE_TYPES, outdatedSeverity } from './constants.js';\nimport type { OutdatedResult, PackageVersion } from './types.js';\n\nexport function outdatedResultToAuditOutput(\n  result: OutdatedResult,\n  packageManager: PackageManagerId,\n  depGroup: DependencyGroup,\n  totalDeps: number,\n): AuditOutput {\n  const relevantDependencies: OutdatedResult = result.filter(\n    dep => dep.type === dependencyGroupToLong[depGroup],\n  );\n\n  const validDependencies = relevantDependencies\n    .map(dep => ({\n      ...dep,\n      current: clean(dep.current),\n      latest: clean(dep.latest),\n    }))\n    .filter(\n      (dep): dep is OutdatedResult[number] =>\n        dep.current != null && dep.latest != null,\n    );\n\n  const outdatedDependencies = validDependencies.filter(dep =>\n    neq(dep.current, dep.latest),\n  );\n\n  const outdatedStats = outdatedDependencies.reduce(\n    (acc, dep) => {\n      const outdatedLevel = diff(dep.current, dep.latest);\n      if (outdatedLevel == null) {\n        return acc;\n      }\n      return { ...acc, [outdatedLevel]: acc[outdatedLevel] + 1 };\n    },\n    objectFromEntries(RELEASE_TYPES.map(versionType => [versionType, 0])),\n  );\n\n  const issues =\n    outdatedDependencies.length === 0\n      ? []\n      : outdatedToIssues(outdatedDependencies);\n\n  return {\n    slug: `${packageManager}-outdated-${depGroup}`,\n    score: calculateOutdatedScore(outdatedStats.major, totalDeps),\n    value: outdatedDependencies.length,\n    displayValue: outdatedToDisplayValue(outdatedStats),\n    details: { issues },\n  };\n}\n\nexport function calculateOutdatedScore(\n  majorOutdated: number,\n  totalDeps: number,\n) {\n  return totalDeps > 0 ? (totalDeps - majorOutdated) / totalDeps : 1;\n}\n\nexport function outdatedToDisplayValue(stats: PackageVersion) {\n  const total = Object.values(stats).reduce((acc, value) => acc + value, 0);\n\n  const versionBreakdown = RELEASE_TYPES.map(version =>\n    stats[version] > 0 ? `${stats[version]} ${version}` : '',\n  ).filter(text => text !== '');\n\n  if (versionBreakdown.length === 0) {\n    return 'all dependencies are up to date';\n  }\n\n  if (versionBreakdown.length > 1) {\n    return `${total} outdated package versions (${versionBreakdown.join(\n      ', ',\n    )})`;\n  }\n\n  return `${versionBreakdown[0]} outdated package ${pluralize(\n    'version',\n    total,\n  )}`;\n}\n\nexport function outdatedToIssues(dependencies: OutdatedResult): Issue[] {\n  return dependencies.map<Issue>(dep => {\n    const { name, current, latest, url } = dep;\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const outdatedLevel = diff(current, latest)!;\n    const packageReference =\n      url == null ? md.code(name) : md.link(url, md.code(name));\n\n    return {\n      message: md`Package ${packageReference} requires a ${md.bold(\n        outdatedLevel,\n      )} update from ${md.bold(current)} to ${md.bold(latest)}.`.toString(),\n      severity: outdatedSeverity[outdatedLevel],\n    };\n  });\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/outdated/constants.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/outdated\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/outdated/constants.ts\";import type { ReleaseType } from 'semver';\nimport type { IssueSeverity } from '@code-pushup/models';\nimport { objectToKeys } from '@code-pushup/utils';\n\nexport const outdatedSeverity: Record<ReleaseType, IssueSeverity> = {\n  major: 'error',\n  premajor: 'info',\n  minor: 'warning',\n  preminor: 'info',\n  patch: 'info',\n  prepatch: 'info',\n  prerelease: 'info',\n};\n\n// RELEASE_TYPES directly exported from semver don't work out of the box\nexport const RELEASE_TYPES = objectToKeys(outdatedSeverity);\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/derive-package-manager.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/derive-package-manager.ts\";import { readFile } from 'node:fs/promises';\nimport path from 'node:path';\nimport { fileExists } from '@code-pushup/utils';\nimport type { PackageManagerId } from '../config.js';\nimport { deriveYarnVersion } from './derive-yarn.js';\n\nexport async function derivePackageManagerInPackageJson(\n  currentDir = process.cwd(),\n) {\n  if (await fileExists(path.join(currentDir, 'package.json'))) {\n    const content = JSON.parse(\n      (await readFile(path.join('package.json'))).toString(),\n    ) as { packageManager?: string };\n    const { packageManager: packageManagerData = '' } = content;\n\n    const [manager = '', version = ''] = packageManagerData.split('@');\n\n    if (manager === 'npm') {\n      return manager;\n    }\n    if (manager === 'pnpm') {\n      return manager;\n    }\n    if (manager === 'yarn') {\n      const majorVersion = Number(version.split('.')[0]);\n      return majorVersion > 1 ? 'yarn-modern' : 'yarn-classic';\n    }\n  }\n  return false;\n}\n\nexport async function derivePackageManager(\n  currentDir = process.cwd(),\n): Promise<PackageManagerId> {\n  const pkgManagerFromPackageJson =\n    await derivePackageManagerInPackageJson(currentDir);\n  if (pkgManagerFromPackageJson) {\n    return pkgManagerFromPackageJson;\n  }\n\n  // Check for lock files\n  if (await fileExists(path.join(currentDir, 'package-lock.json'))) {\n    return 'npm';\n  } else if (await fileExists(path.join(currentDir, 'pnpm-lock.yaml'))) {\n    return 'pnpm';\n  } else if (await fileExists(path.join(currentDir, 'yarn.lock'))) {\n    const yarnVersion = await deriveYarnVersion();\n    if (yarnVersion) {\n      return yarnVersion;\n    }\n  }\n\n  throw new Error(\n    'Could not detect package manager. Please provide it in the js-packages plugin config.',\n  );\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/derive-yarn.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/derive-yarn.ts\";import { executeProcess } from '@code-pushup/utils';\n\nexport async function deriveYarnVersion() {\n  const { stdout } = await executeProcess({\n    command: 'yarn',\n    args: ['-v'],\n  });\n\n  const yarnVersion = Number.parseInt(stdout.toString().trim().at(0) ?? '', 10);\n  if (yarnVersion >= 2) {\n    return 'yarn-modern';\n  } else if (yarnVersion === 1) {\n    return 'yarn-classic';\n  }\n  return false;\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/lighthouse-plugin.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/lighthouse-plugin.ts\";import { createRequire } from 'node:module';\nimport type { PluginConfig } from '@code-pushup/models';\nimport { LIGHTHOUSE_PLUGIN_SLUG } from './constants.js';\nimport { normalizeFlags } from './normalize-flags.js';\nimport {\n  LIGHTHOUSE_GROUPS,\n  LIGHTHOUSE_NAVIGATION_AUDITS,\n} from './runner/constants.js';\nimport { createRunnerFunction } from './runner/runner.js';\nimport type { LighthouseOptions } from './types.js';\nimport { filterAuditsAndGroupsByOnlyOptions } from './utils.js';\n\nexport function lighthousePlugin(\n  url: string,\n  flags?: LighthouseOptions,\n): PluginConfig {\n  const { skipAudits, onlyAudits, onlyCategories, ...unparsedFlags } =\n    normalizeFlags(flags ?? {});\n\n  const { audits, groups } = filterAuditsAndGroupsByOnlyOptions(\n    LIGHTHOUSE_NAVIGATION_AUDITS,\n    LIGHTHOUSE_GROUPS,\n    { skipAudits, onlyAudits, onlyCategories },\n  );\n\n  const packageJson = createRequire(import.meta.url)(\n    '../../package.json',\n  ) as typeof import('../../package.json');\n\n  return {\n    slug: LIGHTHOUSE_PLUGIN_SLUG,\n    packageName: packageJson.name,\n    version: packageJson.version,\n    title: 'Lighthouse',\n    icon: 'lighthouse',\n    audits,\n    groups,\n    runner: createRunnerFunction(url, {\n      skipAudits,\n      onlyAudits,\n      onlyCategories,\n      ...unparsedFlags,\n    }),\n  };\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/constants.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/constants.ts\";import { DEFAULT_FLAGS } from 'chrome-launcher/dist/flags.js';\nimport path from 'node:path';\nimport { DEFAULT_PERSIST_OUTPUT_DIR } from '@code-pushup/models';\n\n// headless is needed to pass CI on Linux and Windows (locally it works without headless too)\nexport const DEFAULT_CHROME_FLAGS = [...DEFAULT_FLAGS, '--headless'];\n\nexport const LIGHTHOUSE_PLUGIN_SLUG = 'lighthouse';\nexport const LIGHTHOUSE_OUTPUT_PATH = path.join(\n  DEFAULT_PERSIST_OUTPUT_DIR,\n  LIGHTHOUSE_PLUGIN_SLUG,\n);\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/normalize-flags.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/normalize-flags.ts\";import { bold, yellow } from 'ansis';\nimport { ui } from '@code-pushup/utils';\nimport { LIGHTHOUSE_PLUGIN_SLUG } from './constants.js';\nimport { DEFAULT_CLI_FLAGS } from './runner/constants.js';\nimport type { LighthouseCliFlags } from './runner/types.js';\nimport type { LighthouseOptions } from './types.js';\n\nconst { onlyCategories, ...originalDefaultCliFlags } = DEFAULT_CLI_FLAGS;\nexport const DEFAULT_LIGHTHOUSE_OPTIONS = {\n  ...originalDefaultCliFlags,\n  onlyGroups: onlyCategories,\n} satisfies LighthouseOptions;\n\n// NOTE:\n// This is an intermediate variable to get `UnsupportedCliFlags`. For unknown reasons `typescript@5.3.3` doesn't work otherwise.\nconst lighthouseUnsupportedCliFlags = [\n  'precomputedLanternDataPath', // Path to the file where precomputed lantern data should be read from.\n  'chromeIgnoreDefaultFlags', // ignore default flags from Lighthouse CLI\n  // No error reporting implemented as in the source Sentry was involved\n  // See: https://github.com/GoogleChrome/lighthouse/blob/d8ccf70692216b7fa047a4eaa2d1277b0b7fe947/cli/bin.js#L124\n  'enableErrorReporting', // enable error reporting\n  // lighthouse CLI specific debug logs\n  'list-all-audits', // Prints a list of all available audits and exits.\n  'list-locales', // Prints a list of all supported locales and exits.\n  'list-trace-categories', // Prints a list of all required trace categories and exits.\n] as const;\ntype UnsupportedCliFlags = (typeof lighthouseUnsupportedCliFlags)[number];\n\nconst LIGHTHOUSE_UNSUPPORTED_CLI_FLAGS = new Set(lighthouseUnsupportedCliFlags);\n\nconst REFINED_STRING_OR_STRING_ARRAY = new Set([\n  'onlyAudits',\n  'onlyCategories',\n  'skipAudits',\n  'budgets',\n  'chromeFlags',\n]);\n\nexport function normalizeFlags(flags?: LighthouseOptions): LighthouseCliFlags {\n  const prefilledFlags = { ...DEFAULT_LIGHTHOUSE_OPTIONS, ...flags };\n\n  logUnsupportedFlagsInUse(prefilledFlags);\n\n  return Object.fromEntries(\n    Object.entries(prefilledFlags)\n      .filter(\n        ([flagName]) =>\n          !LIGHTHOUSE_UNSUPPORTED_CLI_FLAGS.has(\n            flagName as UnsupportedCliFlags,\n          ),\n      )\n      // in code-pushup lighthouse categories are mapped as groups, therefor we had to rename \"onlyCategories\" to \"onlyGroups\" for the user of the plugin as it was confusing\n      .map(([key, v]) => [key === 'onlyGroups' ? 'onlyCategories' : key, v])\n      // onlyAudits and onlyCategories cannot be empty arrays, otherwise skipAudits is ignored by lighthouse\n      .filter(([_, v]) => !(Array.isArray(v) && v.length === 0))\n      // undefined | string | string[] => string[] (empty for undefined)\n      .map(([key, v]) => {\n        if (!REFINED_STRING_OR_STRING_ARRAY.has(key as never)) {\n          return [key, v];\n        }\n        return [key, Array.isArray(v) ? v : v == null ? [] : [v]];\n      }),\n  ) as LighthouseCliFlags;\n}\n\nexport function logUnsupportedFlagsInUse(\n  flags: LighthouseOptions,\n  displayCount = 3,\n) {\n  const unsupportedFlagsInUse = Object.keys(flags).filter(flag =>\n    LIGHTHOUSE_UNSUPPORTED_CLI_FLAGS.has(flag as UnsupportedCliFlags),\n  );\n  if (unsupportedFlagsInUse.length > 0) {\n    const postFix = (count: number) =>\n      count > displayCount ? ` and ${count - displayCount} more.` : '';\n    ui().logger.debug(\n      `${yellow('\u26A0')} Plugin ${bold(\n        LIGHTHOUSE_PLUGIN_SLUG,\n      )} used unsupported flags: ${bold(\n        unsupportedFlagsInUse.slice(0, displayCount).join(', '),\n      )}${postFix(unsupportedFlagsInUse.length)}`,\n    );\n  }\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/constants.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/constants.ts\";import {\n  type CliFlags,\n  type Config,\n  type IcuMessage,\n  type Audit as LHAudit,\n  defaultConfig,\n} from 'lighthouse';\nimport path from 'node:path';\nimport type { Audit, Group } from '@code-pushup/models';\nimport { DEFAULT_CHROME_FLAGS, LIGHTHOUSE_OUTPUT_PATH } from '../constants.js';\n\nconst { audits, categories } = defaultConfig;\n\n// internal intermediate variable to derive the relevant audits\nconst allRawLighthouseAudits = await Promise.all(\n  (audits ?? []).map(loadLighthouseAudit),\n);\n\nexport const PLUGIN_SLUG = 'lighthouse';\nexport const LIGHTHOUSE_NAVIGATION_AUDITS: Audit[] = allRawLighthouseAudits\n  // This plugin only supports the \"navigation\" mode of Lighthouse in the current implementation\n  // If we don't exclude other audits we throw in the plugin output validation as some of the provided audits are not included in `lighthouse-report.json`\n  .filter(\n    audit =>\n      audit.meta.supportedModes == null ||\n      (Array.isArray(audit.meta.supportedModes) &&\n        audit.meta.supportedModes.includes('navigation')),\n  )\n  .map(audit => ({\n    slug: audit.meta.id,\n    title: getMetaString(audit.meta.title),\n    description: getMetaString(audit.meta.description),\n  }));\n\nconst navigationAuditSlugs = new Set(\n  LIGHTHOUSE_NAVIGATION_AUDITS.map(({ slug }) => slug),\n);\nexport const LIGHTHOUSE_GROUPS: Group[] = Object.entries(categories ?? {}).map(\n  ([id, category]) => ({\n    slug: id,\n    title: getMetaString(category.title),\n    ...(category.description && {\n      description: getMetaString(category.description),\n    }),\n    refs: category.auditRefs\n      .filter(({ id: auditSlug }) => navigationAuditSlugs.has(auditSlug))\n      .map(ref => ({\n        slug: ref.id,\n        weight: ref.weight,\n      })),\n  }),\n);\n\nfunction getMetaString(value: string | IcuMessage): string {\n  if (typeof value === 'string') {\n    return value;\n  }\n  return value.formattedDefault;\n}\n\nasync function loadLighthouseAudit(\n  value: Config.AuditJson,\n): Promise<typeof LHAudit> {\n  // the passed value directly includes the implementation as JS object\n  //   shape: { implementation: typeof LHAudit; options?: {}; }\n  if (typeof value === 'object' && 'implementation' in value) {\n    return value.implementation;\n  }\n  // the passed value is a `LH.Audit` class instance\n  //   shape: LHAudit\n  if (typeof value === 'function') {\n    return value;\n  }\n  // the passed value is the path directly\n  //   shape: string\n  // otherwise it is a JS object maintaining a `path` property\n  //   shape: { path: string, options?: {}; }\n  const file = typeof value === 'string' ? value : value.path;\n  const module = (await import(`lighthouse/core/audits/${file}.js`)) as {\n    default: typeof LHAudit;\n  };\n  return module.default;\n}\n\nexport const LIGHTHOUSE_REPORT_NAME = 'lighthouse-report.json';\n\nexport const DEFAULT_CLI_FLAGS = {\n  // default values extracted from\n  // https://github.com/GoogleChrome/lighthouse/blob/7d80178c37a1b600ea8f092fc0b098029799a659/cli/cli-flags.js#L80\n  verbose: false,\n  saveAssets: false,\n  chromeFlags: DEFAULT_CHROME_FLAGS,\n  port: 0,\n  hostname: '127.0.0.1',\n  view: false,\n  channel: 'cli',\n  // custom overwrites in favour of the plugin\n  // hide logs by default\n  quiet: true,\n  onlyAudits: [],\n  skipAudits: [],\n  onlyCategories: [],\n  output: ['json'],\n  outputPath: path.join(LIGHTHOUSE_OUTPUT_PATH, LIGHTHOUSE_REPORT_NAME),\n} satisfies Partial<CliFlags>;\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/runner.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/runner.ts\";import type { RunnerResult } from 'lighthouse';\nimport { runLighthouse } from 'lighthouse/cli/run.js';\nimport path from 'node:path';\nimport type { AuditOutputs, RunnerFunction } from '@code-pushup/models';\nimport { ensureDirectoryExists } from '@code-pushup/utils';\nimport { DEFAULT_CLI_FLAGS } from './constants.js';\nimport type { LighthouseCliFlags } from './types.js';\nimport {\n  determineAndSetLogLevel,\n  getConfig,\n  normalizeAuditOutputs,\n  toAuditOutputs,\n} from './utils.js';\n\nexport function createRunnerFunction(\n  urlUnderTest: string,\n  flags: LighthouseCliFlags = DEFAULT_CLI_FLAGS,\n): RunnerFunction {\n  return async (): Promise<AuditOutputs> => {\n    const {\n      configPath,\n      preset,\n      outputPath,\n      ...parsedFlags\n    }: Partial<LighthouseCliFlags> = flags;\n\n    const logLevel = determineAndSetLogLevel(parsedFlags);\n\n    const config = await getConfig({ configPath, preset });\n    if (outputPath) {\n      await ensureDirectoryExists(path.dirname(outputPath));\n    }\n\n    const enrichedFlags = {\n      ...parsedFlags,\n      logLevel,\n      outputPath,\n    };\n\n    const runnerResult: unknown = await runLighthouse(\n      urlUnderTest,\n      enrichedFlags,\n      config,\n    );\n\n    if (runnerResult == null) {\n      throw new Error('Lighthouse did not produce a result.');\n    }\n\n    const { lhr } = runnerResult as RunnerResult;\n    const auditOutputs = toAuditOutputs(Object.values(lhr.audits), flags);\n\n    return normalizeAuditOutputs(auditOutputs, enrichedFlags);\n  };\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/utils.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/utils.ts\";import { bold } from 'ansis';\nimport type { Config, FormattedIcu } from 'lighthouse';\nimport log from 'lighthouse-logger';\nimport desktopConfig from 'lighthouse/core/config/desktop-config.js';\nimport experimentalConfig from 'lighthouse/core/config/experimental-config.js';\nimport perfConfig from 'lighthouse/core/config/perf-config.js';\nimport type Details from 'lighthouse/types/lhr/audit-details';\nimport type { Result } from 'lighthouse/types/lhr/audit-result';\nimport type { AuditOutput, AuditOutputs } from '@code-pushup/models';\nimport {\n  formatReportScore,\n  importModule,\n  readJsonFile,\n  ui,\n} from '@code-pushup/utils';\nimport type { LighthouseOptions } from '../types.js';\nimport { logUnsupportedDetails, toAuditDetails } from './details/details.js';\nimport type { LighthouseCliFlags } from './types.js';\n\nexport function normalizeAuditOutputs(\n  auditOutputs: AuditOutputs,\n  flags: LighthouseOptions = { skipAudits: [] },\n): AuditOutputs {\n  const toSkip = new Set(flags.skipAudits ?? []);\n  return auditOutputs.filter(({ slug }) => !toSkip.has(slug));\n}\n\nexport class LighthouseAuditParsingError extends Error {\n  constructor(slug: string, error: Error) {\n    super(`\\nAudit ${bold(slug)} failed parsing details: \\n${error.message}`);\n  }\n}\n\nfunction formatBaseAuditOutput(lhrAudit: Result): AuditOutput {\n  const {\n    id: slug,\n    score,\n    numericValue,\n    displayValue,\n    scoreDisplayMode,\n  } = lhrAudit;\n  return {\n    slug,\n    score: score ?? 1,\n    value: numericValue ?? score ?? 0,\n    displayValue:\n      displayValue ??\n      (scoreDisplayMode === 'binary'\n        ? score === 1\n          ? 'passed'\n          : 'failed'\n        : score\n          ? `${formatReportScore(score)}%`\n          : undefined),\n  };\n}\n\nfunction processAuditDetails(\n  auditOutput: AuditOutput,\n  details: FormattedIcu<Details>,\n): AuditOutput {\n  try {\n    const parsedDetails = toAuditDetails(details);\n    return Object.keys(parsedDetails).length > 0\n      ? { ...auditOutput, details: parsedDetails }\n      : auditOutput;\n  } catch (error) {\n    throw new LighthouseAuditParsingError(auditOutput.slug, error as Error);\n  }\n}\n\nexport function toAuditOutputs(\n  lhrAudits: Result[],\n  { verbose = false }: { verbose?: boolean } = {},\n): AuditOutputs {\n  if (verbose) {\n    logUnsupportedDetails(lhrAudits);\n  }\n  return lhrAudits.map(audit => {\n    const auditOutput = formatBaseAuditOutput(audit);\n\n    return audit.details == null\n      ? auditOutput\n      : processAuditDetails(auditOutput, audit.details);\n  });\n}\n\nexport type LighthouseLogLevel =\n  | 'verbose'\n  | 'error'\n  | 'info'\n  | 'silent'\n  | 'warn'\n  | undefined;\nexport function determineAndSetLogLevel({\n  verbose,\n  quiet,\n}: {\n  verbose?: boolean;\n  quiet?: boolean;\n} = {}): LighthouseLogLevel {\n  // eslint-disable-next-line functional/no-let\n  let logLevel: LighthouseLogLevel = 'info';\n  // set logging preferences\n  if (verbose) {\n    logLevel = 'verbose';\n  } else if (quiet) {\n    logLevel = 'silent';\n  }\n\n  log.setLevel(logLevel);\n\n  return logLevel;\n}\n\nexport type ConfigOptions = Partial<\n  Pick<LighthouseCliFlags, 'configPath' | 'preset'>\n>;\n\nexport async function getConfig(\n  options: ConfigOptions = {},\n): Promise<Config | undefined> {\n  const { configPath: filepath, preset } = options;\n\n  if (filepath != null) {\n    if (filepath.endsWith('.json')) {\n      // Resolve the config file path relative to where cli was called.\n      return readJsonFile<Config>(filepath);\n    } else if (/\\.(ts|js|mjs)$/.test(filepath)) {\n      return importModule<Config>({ filepath, format: 'esm' });\n    } else {\n      ui().logger.info(`Format of file ${filepath} not supported`);\n    }\n  } else if (preset != null) {\n    switch (preset) {\n      case 'desktop':\n        return desktopConfig;\n      case 'perf':\n        return perfConfig as Config;\n      case 'experimental':\n        return experimentalConfig as Config;\n      default:\n        // as preset is a string literal the default case here is normally caught by TS and not possible to happen. Now in reality it can happen and preset could be a string not included in the literal.\n        // Therefore, we have to use `as string`. Otherwise, it will consider preset as type never\n        ui().logger.info(`Preset \"${preset as string}\" is not supported`);\n    }\n  }\n  return undefined;\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details/details.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details/details.ts\";import { bold, yellow } from 'ansis';\nimport type { FormattedIcu } from 'lighthouse';\nimport type Details from 'lighthouse/types/lhr/audit-details';\nimport type { Result } from 'lighthouse/types/lhr/audit-result';\nimport type { AuditDetails, Table } from '@code-pushup/models';\nimport { ui } from '@code-pushup/utils';\nimport { PLUGIN_SLUG } from '../constants.js';\nimport { parseOpportunityToAuditDetailsTable } from './opportunity.type.js';\nimport { parseTableToAuditDetailsTable } from './table.type.js';\n\nexport function toAuditDetails<T extends FormattedIcu<Details>>(\n  details: T | undefined,\n): AuditDetails {\n  if (details == null) {\n    return {};\n  }\n\n  const { type } = details;\n\n  switch (type) {\n    case 'table':\n      const table: Table | undefined = parseTableToAuditDetailsTable(details);\n      return table ? { table } : {};\n    case 'opportunity':\n      const opportunity: Table | undefined =\n        parseOpportunityToAuditDetailsTable(details);\n      return opportunity ? { table: opportunity } : {};\n  }\n  return {};\n}\n\n// @TODO implement all details\nexport const unsupportedDetailTypes = new Set([\n  'debugdata',\n  'treemap-data',\n  'screenshot',\n  'filmstrip',\n  'criticalrequestchain',\n]);\n\nexport function logUnsupportedDetails(\n  lhrAudits: Result[],\n  { displayCount = 3 }: { displayCount?: number } = {},\n) {\n  const slugsWithDetailParsingErrors = [\n    ...new Set(\n      lhrAudits\n        .filter(({ details }) =>\n          unsupportedDetailTypes.has(details?.type as string),\n        )\n        .map(({ details }) => details?.type),\n    ),\n  ];\n  if (slugsWithDetailParsingErrors.length > 0) {\n    const postFix = (count: number) =>\n      count > displayCount ? ` and ${count - displayCount} more.` : '';\n    ui().logger.debug(\n      `${yellow('\u26A0')} Plugin ${bold(\n        PLUGIN_SLUG,\n      )} skipped parsing of unsupported audit details: ${bold(\n        slugsWithDetailParsingErrors.slice(0, displayCount).join(', '),\n      )}${postFix(slugsWithDetailParsingErrors.length)}`,\n    );\n  }\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details/opportunity.type.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details/opportunity.type.ts\";import type Details from 'lighthouse/types/lhr/audit-details';\nimport {\n  type Table,\n  type TableRowObject,\n  tableSchema,\n} from '@code-pushup/models';\nimport { formatBytes, formatDuration, html } from '@code-pushup/utils';\nimport { parseTableColumns, parseTableEntry } from './table.type.js';\nimport { LighthouseAuditDetailsParsingError } from './utils.js';\n\nexport function parseOpportunityToAuditDetailsTable(\n  details: Details.Opportunity,\n): Table | undefined {\n  const { headings: rawHeadings, items } = details;\n\n  if (items.length === 0) {\n    return undefined;\n  }\n\n  try {\n    return tableSchema().parse({\n      title: 'Opportunity',\n      columns: parseTableColumns(rawHeadings),\n      rows: items.map(row => parseOpportunityItemToTableRow(row, rawHeadings)),\n    });\n  } catch (error) {\n    throw new LighthouseAuditDetailsParsingError(\n      'opportunity',\n      { items, headings: rawHeadings },\n      (error as Error).message.toString(),\n    );\n  }\n}\n\nexport function parseOpportunityItemToTableRow(\n  opportunityItem: Details.OpportunityItem,\n  headings: Details.TableColumnHeading[],\n): TableRowObject {\n  const keys = new Set(headings.map(({ key }) => key));\n  const valueTypesByKey = new Map(\n    headings.map(({ key, valueType }) => [key, valueType]),\n  );\n\n  return {\n    ...(Object.fromEntries(\n      Object.entries(opportunityItem)\n        // forward only properties with a given value\n        .filter(([key]) => keys.has(key))\n        .map(([key, value]) => {\n          const valueType = valueTypesByKey.get(key) as Details.ItemValueType;\n          return parseOpportunityEntry([key, value], valueType);\n        }),\n    ) as TableRowObject),\n  };\n}\n\nexport function parseOpportunityEntry(\n  [key, value]: [\n    keyof Details.OpportunityItem,\n    Details.OpportunityItem[string],\n  ],\n  valueType: Details.ItemValueType,\n) {\n  switch (key) {\n    case 'url':\n      return [key, html.link(String(value))];\n    case 'wastedPercent':\n      return [key, `${Number(value).toFixed(2)} %`];\n    case 'totalBytes':\n    case 'wastedBytes':\n      return [key, formatBytes(Number(value))];\n    case 'wastedMs':\n      return [key, formatDuration(Number(value))];\n    default:\n      return parseTableEntry([key, value], valueType);\n  }\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details/table.type.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details/table.type.ts\";import type Details from 'lighthouse/types/lhr/audit-details';\nimport {\n  type Table,\n  type TableColumnObject,\n  type TableRowObject,\n  tableSchema,\n} from '@code-pushup/models';\nimport { formatTableItemPropertyValue } from './item-value.js';\nimport { LighthouseAuditDetailsParsingError } from './utils.js';\n\nexport function parseTableToAuditDetailsTable(\n  details: Details.Table,\n): Table | undefined {\n  const { headings: rawHeadings, items } = details;\n\n  if (items.length === 0) {\n    return undefined;\n  }\n\n  try {\n    return tableSchema().parse({\n      columns: parseTableColumns(rawHeadings),\n      rows: items.map(row => parseTableRow(row, rawHeadings)),\n    });\n  } catch (error) {\n    throw new LighthouseAuditDetailsParsingError(\n      'table',\n      { items, headings: rawHeadings },\n      (error as Error).message.toString(),\n    );\n  }\n}\n\nexport function parseTableColumns(\n  rawHeadings: Details.TableColumnHeading[],\n): TableColumnObject[] {\n  return rawHeadings.map(({ key, label }) => ({\n    key: key ?? '',\n    ...(typeof label === 'string' && label.length > 0 ? { label } : {}),\n    align: 'left',\n  }));\n}\n\nexport function parseTableRow(\n  tableItem: Details.TableItem,\n  headings: Details.TableColumnHeading[],\n): TableRowObject {\n  const keys = new Set(headings.map(({ key }) => key));\n  const valueTypesByKey = new Map(\n    headings.map(({ key, valueType }) => [key, valueType]),\n  );\n\n  return Object.fromEntries(\n    Object.entries(tableItem)\n      .filter(([key]) => keys.has(key))\n      .map(([key, value]) => {\n        const valueType = valueTypesByKey.get(key);\n        return parseTableEntry([key, value], valueType);\n      }),\n  ) as TableRowObject;\n}\n\nexport function parseTableEntry<T extends Details.TableItem>(\n  [key, value]: [keyof T, T[keyof T]],\n  valueType?: Details.ItemValueType,\n): [keyof T, Details.ItemValue | undefined] {\n  if (value == null) {\n    return [key, value];\n  }\n\n  return [key, formatTableItemPropertyValue(value, valueType)];\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details/item-value.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details/item-value.ts\";import { bold } from 'ansis';\nimport type { IcuMessage } from 'lighthouse';\nimport type Details from 'lighthouse/types/lhr/audit-details';\nimport {\n  formatBytes,\n  formatDuration,\n  html,\n  truncateText,\n  ui,\n} from '@code-pushup/utils';\n\nexport type PrimitiveItemValue = string | number | boolean;\nexport type ObjectItemValue = Exclude<\n  Details.ItemValue,\n  PrimitiveItemValue | IcuMessage\n>;\nexport type SimpleItemValue =\n  | Extract<\n      ObjectItemValue,\n      Details.NumericValue | Details.CodeValue | Details.UrlValue\n    >\n  | PrimitiveItemValue;\n\nexport function trimSlice(item?: PrimitiveItemValue, maxLength = 0) {\n  const str = String(item).trim();\n  return maxLength > 0 ? str.slice(0, maxLength) : str;\n}\n\nexport function parseNodeValue(node?: Details.NodeValue): string {\n  const { selector = '' } = node ?? {};\n  return selector;\n}\n\n// eslint-disable-next-line max-lines-per-function\nexport function formatTableItemPropertyValue(\n  itemValue?: Details.ItemValue,\n  itemValueFormat?: Details.ItemValueType,\n) {\n  // null\n  if (itemValue == null) {\n    return '';\n  }\n\n  // Primitive Values\n  if (itemValueFormat == null) {\n    if (typeof itemValue === 'string') {\n      return trimSlice(itemValue);\n    }\n\n    if (typeof itemValue === 'number') {\n      return Number(itemValue);\n    }\n\n    if (typeof itemValue === 'boolean') {\n      return itemValue;\n    }\n  }\n\n  const parsedItemValue = parseTableItemPropertyValue(itemValue);\n\n  /* eslint-disable @typescript-eslint/no-magic-numbers */\n  switch (itemValueFormat) {\n    case 'bytes':\n      return formatBytes(Number(parsedItemValue));\n    case 'code':\n      return html.code(trimSlice(parsedItemValue as string));\n    case 'link':\n      const link = parsedItemValue as Details.LinkValue;\n      return html.link(link.url, link.text);\n    case 'url':\n      const url = parsedItemValue as string;\n      return html.link(url);\n    case 'timespanMs':\n    case 'ms':\n      return formatDuration(Number(parsedItemValue));\n    case 'node':\n      return parseNodeValue(itemValue as Details.NodeValue);\n    case 'source-location':\n      return truncateText(String(parsedItemValue), 200);\n    case 'numeric':\n      const num = Number(parsedItemValue);\n      if (num.toFixed(3).toString().endsWith('.000')) {\n        return String(num);\n      }\n      return String(num.toFixed(3));\n    case 'text':\n      return truncateText(String(parsedItemValue), 500);\n    case 'multi': // @TODO\n      // @TODO log verbose first, then implement data type\n      ui().logger.info(`Format type ${bold('multi')} is not implemented`);\n      return '';\n    case 'thumbnail': // @TODO\n      // @TODO log verbose first, then implement data type\n      ui().logger.info(`Format type ${bold('thumbnail')} is not implemented`);\n      return '';\n  }\n  /* eslint-enable @typescript-eslint/no-magic-numbers */\n\n  return itemValue;\n}\n\nexport function parseSimpleItemValue(\n  item: SimpleItemValue,\n): PrimitiveItemValue {\n  if (typeof item === 'object') {\n    const value = item.value;\n    if (typeof value === 'object') {\n      return value.formattedDefault;\n    }\n    return value;\n  }\n  return item;\n}\n\n// @TODO extract Link type from logic\nexport function parseTableItemPropertyValue(\n  itemValue?: Details.ItemValue,\n): PrimitiveItemValue | Details.LinkValue {\n  if (itemValue == null) {\n    return '';\n  }\n\n  // Primitive Values\n  if (\n    typeof itemValue === 'string' ||\n    typeof itemValue === 'number' ||\n    typeof itemValue === 'boolean'\n  ) {\n    return parseSimpleItemValue(itemValue);\n  }\n\n  // Object Values\n  const objectValue = itemValue as ObjectItemValue;\n  const { type } = objectValue;\n  switch (type) {\n    case 'code':\n    case 'url':\n      return String(parseSimpleItemValue(objectValue));\n    case 'node':\n      return parseNodeValue(objectValue);\n    case 'link':\n      return objectValue;\n    case 'numeric':\n      return Number(parseSimpleItemValue(objectValue));\n    case 'source-location':\n      const { url } = objectValue;\n      return String(url);\n    case 'subitems':\n      // @TODO log verbose first, then implement data type\n      ui().logger.info(`Value type ${bold('subitems')} is not implemented`);\n      return '';\n    case 'debugdata':\n      // @TODO log verbose first, then implement data type\n      ui().logger.info(`Value type ${bold('debugdata')} is not implemented`, {\n        silent: true,\n      });\n      return '';\n  }\n  // IcuMessage\n  return parseSimpleItemValue(objectValue as SimpleItemValue);\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details/utils.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details/utils.ts\";import { bold } from 'ansis';\nimport type Details from 'lighthouse/types/lhr/audit-details';\n\nexport class LighthouseAuditDetailsParsingError extends Error {\n  constructor(\n    type: Details['type'],\n    rawTable: Record<string, unknown>,\n    error: string,\n  ) {\n    super(\n      `Parsing lighthouse report details ${bold(\n        type,\n      )} failed: \\nRaw data:\\n ${JSON.stringify(rawTable, null, 2)}\\n${error}`,\n    );\n  }\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/utils.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/utils.ts\";import type { Audit, CategoryRef, Group } from '@code-pushup/models';\nimport { filterItemRefsBy, toArray } from '@code-pushup/utils';\nimport { LIGHTHOUSE_PLUGIN_SLUG } from './constants.js';\nimport type { LighthouseCliFlags } from './runner/types.js';\n\nexport type LighthouseGroupSlugs =\n  | 'performance'\n  | 'accessibility'\n  | 'best-practices'\n  | 'seo'\n  | 'pwa';\n\nexport function lighthouseGroupRef(\n  groupSlug: LighthouseGroupSlugs,\n  weight = 1,\n): CategoryRef {\n  return {\n    plugin: LIGHTHOUSE_PLUGIN_SLUG,\n    slug: groupSlug,\n    type: 'group',\n    weight,\n  };\n}\n\nexport function lighthouseAuditRef(auditSlug: string, weight = 1): CategoryRef {\n  return {\n    plugin: LIGHTHOUSE_PLUGIN_SLUG,\n    slug: auditSlug,\n    type: 'audit',\n    weight,\n  };\n}\n\nexport class AuditsNotImplementedError extends Error {\n  constructor(auditSlugs: string[]) {\n    super(`audits: \"${auditSlugs.join(', ')}\" not implemented`);\n  }\n}\n\nexport function validateAudits(audits: Audit[], onlyAudits: string[]): boolean {\n  const missingAudtis = toArray(onlyAudits).filter(\n    slug => !audits.some(audit => audit.slug === slug),\n  );\n  if (missingAudtis.length > 0) {\n    throw new AuditsNotImplementedError(missingAudtis);\n  }\n  return true;\n}\n\nexport class CategoriesNotImplementedError extends Error {\n  constructor(categorySlugs: string[]) {\n    super(`categories: \"${categorySlugs.join(', ')}\" not implemented`);\n  }\n}\n\nexport function validateOnlyCategories(\n  groups: Group[],\n  onlyCategories: string | string[],\n): boolean {\n  const missingCategories = toArray(onlyCategories).filter(slug =>\n    groups.every(group => group.slug !== slug),\n  );\n  if (missingCategories.length > 0) {\n    throw new CategoriesNotImplementedError(missingCategories);\n  }\n  return true;\n}\n\nexport type FilterOptions = Partial<\n  Pick<LighthouseCliFlags, 'onlyAudits' | 'onlyCategories' | 'skipAudits'>\n>;\n\nexport function filterAuditsAndGroupsByOnlyOptions(\n  audits: Audit[],\n  groups: Group[],\n  options?: FilterOptions,\n): {\n  audits: Audit[];\n  groups: Group[];\n} {\n  const {\n    onlyAudits = [],\n    skipAudits = [],\n    onlyCategories = [],\n  } = options ?? {};\n\n  // category wins over audits\n  if (onlyCategories.length > 0) {\n    validateOnlyCategories(groups, onlyCategories);\n\n    const categorySlugs = new Set(onlyCategories);\n    const filteredGroups: Group[] = groups.filter(({ slug }) =>\n      categorySlugs.has(slug),\n    );\n    const auditSlugsFromRemainingGroups = new Set(\n      filteredGroups.flatMap(({ refs }) => refs.map(({ slug }) => slug)),\n    );\n    return {\n      audits: audits.filter(({ slug }) =>\n        auditSlugsFromRemainingGroups.has(slug),\n      ),\n      groups: filteredGroups,\n    };\n  } else if (onlyAudits.length > 0 || skipAudits.length > 0) {\n    validateAudits(audits, onlyAudits);\n    validateAudits(audits, skipAudits);\n    const onlyAuditSlugs = new Set(onlyAudits);\n    const skipAuditSlugs = new Set(skipAudits);\n    const filterAudits = ({ slug }: Pick<Audit, 'slug'>) =>\n      !(\n        // audit is NOT in given onlyAuditSlugs\n        (\n          (onlyAudits.length > 0 && !onlyAuditSlugs.has(slug)) ||\n          // audit IS in given skipAuditSlugs\n          (skipAudits.length > 0 && skipAuditSlugs.has(slug))\n        )\n      );\n    return {\n      audits: audits.filter(filterAudits),\n      groups: filterItemRefsBy(groups, filterAudits),\n    };\n  }\n  // return unchanged\n  return {\n    audits,\n    groups,\n  };\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/code-pushup.preset.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/code-pushup.preset.ts\";import type {\n  CategoryConfig,\n  CoreConfig,\n} from './packages/models/src/index.js';\nimport coveragePlugin, {\n  getNxCoveragePaths,\n} from './packages/plugin-coverage/src/index.js';\nimport docCoveragePlugin, { DocCoveragePluginConfig } from './packages/plugin-doc-coverage/src/index.js';\nimport { groups, PLUGIN_SLUG } from './packages/plugin-doc-coverage/src/lib/constants.js';\nimport { filterGroupsByOnlyAudits } from './packages/plugin-doc-coverage/src/lib/utils.js';\nimport eslintPlugin, {\n  eslintConfigFromAllNxProjects,\n  eslintConfigFromNxProject,\n} from './packages/plugin-eslint/src/index.js';\nimport jsPackagesPlugin from './packages/plugin-js-packages/src/index.js';\nimport lighthousePlugin, {\n  lighthouseGroupRef,\n} from './packages/plugin-lighthouse/src/index.js';\n\nexport const jsPackagesCategories: CategoryConfig[] = [\n  {\n    slug: 'security',\n    title: 'Security',\n    description: 'Finds known **vulnerabilities** in 3rd-party packages.',\n    refs: [\n      {\n        type: 'group',\n        plugin: 'js-packages',\n        slug: 'npm-audit',\n        weight: 1,\n      },\n    ],\n  },\n  {\n    slug: 'updates',\n    title: 'Updates',\n    description: 'Finds **outdated** 3rd-party packages.',\n    refs: [\n      {\n        type: 'group',\n        plugin: 'js-packages',\n        slug: 'npm-outdated',\n        weight: 1,\n      },\n    ],\n  },\n];\n\nexport const lighthouseCategories: CategoryConfig[] = [\n  {\n    slug: 'performance',\n    title: 'Performance',\n    refs: [lighthouseGroupRef('performance')],\n  },\n  {\n    slug: 'a11y',\n    title: 'Accessibility',\n    refs: [lighthouseGroupRef('accessibility')],\n  },\n  {\n    slug: 'best-practices',\n    title: 'Best Practices',\n    refs: [lighthouseGroupRef('best-practices')],\n  },\n  {\n    slug: 'seo',\n    title: 'SEO',\n    refs: [lighthouseGroupRef('seo')],\n  },\n];\n\nexport const eslintCategories: CategoryConfig[] = [\n  {\n    slug: 'bug-prevention',\n    title: 'Bug prevention',\n    description: 'Lint rules that find **potential bugs** in your code.',\n    refs: [{ type: 'group', plugin: 'eslint', slug: 'problems', weight: 1 }],\n  },\n  {\n    slug: 'code-style',\n    title: 'Code style',\n    description:\n      'Lint rules that promote **good practices** and consistency in your code.',\n    refs: [{ type: 'group', plugin: 'eslint', slug: 'suggestions', weight: 1 }],\n  },\n];\n\nexport function getDocCoverageCategories(config: DocCoveragePluginConfig): CategoryConfig[] {\n  return [{\n    slug: 'doc-coverage-cat',\n    title: 'Documentation coverage',\n    description: 'Measures how much of your code is **documented**.',\n    refs: filterGroupsByOnlyAudits(groups, config).map(group => ({\n      weight: 1,\n      type: 'group',\n      plugin: PLUGIN_SLUG,\n      slug: group.slug,\n    })),\n  }];\n}\n\n\n\nexport const coverageCategories: CategoryConfig[] = [\n  {\n    slug: 'code-coverage',\n    title: 'Code coverage',\n    description: 'Measures how much of your code is **covered by tests**.',\n    refs: [\n      {\n        type: 'group',\n        plugin: 'coverage',\n        slug: 'coverage',\n        weight: 1,\n      },\n    ],\n  },\n];\n\nexport const jsPackagesCoreConfig = async (): Promise<CoreConfig> => {\n  return {\n    plugins: [await jsPackagesPlugin()],\n    categories: jsPackagesCategories,\n  };\n};\n\nexport const lighthouseCoreConfig = async (\n  url: string,\n): Promise<CoreConfig> => {\n  return {\n    plugins: [await lighthousePlugin(url)],\n    categories: lighthouseCategories,\n  };\n};\n\nexport const docCoverageCoreConfig = async (config: DocCoveragePluginConfig): Promise<CoreConfig> => {\n  return {\n    plugins: [await docCoveragePlugin(config)],\n    categories: getDocCoverageCategories(config),\n  };\n};\n\nexport const eslintCoreConfigNx = async (\n  projectName?: string,\n): Promise<CoreConfig> => {\n  return {\n    plugins: [\n      await eslintPlugin(\n        await (projectName\n          ? eslintConfigFromNxProject(projectName)\n          : eslintConfigFromAllNxProjects()),\n      ),\n    ],\n    categories: eslintCategories,\n  };\n};\n\nexport const coverageCoreConfigNx = async (\n  projectName?: string,\n): Promise<CoreConfig> => {\n  if (projectName) {\n    throw new Error('coverageCoreConfigNx for single projects not implemented');\n  }\n  const targetNames = ['unit-test', 'integration-test'];\n  const targetArgs = [\n    '-t',\n    'unit-test',\n    'integration-test',\n    '--coverage.enabled',\n    '--skipNxCache',\n  ];\n  return {\n    plugins: [\n      await coveragePlugin({\n        coverageToolCommand: {\n          command: 'npx',\n          args: [\n            'nx',\n            projectName ? `run --project ${projectName}` : 'run-many',\n            ...targetArgs,\n          ],\n        },\n        reports: await getNxCoveragePaths(targetNames),\n      }),\n    ],\n    categories: coverageCategories,\n  };\n};\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/index.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/index.ts\";export { exists } from '@code-pushup/models';\nexport { comparePairs, matchArrayItemsByKey, type Diff } from './lib/diff.js';\nexport { stringifyError } from './lib/errors.js';\nexport {\n  ProcessError,\n  executeProcess,\n  type ProcessConfig,\n  type ProcessObserver,\n  type ProcessResult,\n} from './lib/execute-process.js';\nexport {\n  crawlFileSystem,\n  directoryExists,\n  ensureDirectoryExists,\n  fileExists,\n  filePathToCliArg,\n  findLineNumberInText,\n  findNearestFile,\n  importModule,\n  logMultipleFileResults,\n  pluginWorkDir,\n  projectToFilename,\n  readJsonFile,\n  readTextFile,\n  removeDirectoryIfExists,\n  type CrawlFileSystemOptions,\n  type FileResult,\n  type MultipleFileResults,\n} from './lib/file-system.js';\nexport { filterItemRefsBy } from './lib/filter.js';\nexport {\n  formatBytes,\n  formatDuration,\n  pluralize,\n  pluralizeToken,\n  slugify,\n  truncateDescription,\n  truncateIssueMessage,\n  truncateText,\n  truncateTitle,\n} from './lib/formatting.js';\nexport {\n  getCurrentBranchOrTag,\n  getHashFromTag,\n  getHashes,\n  getLatestCommit,\n  getSemverTags,\n  type LogResult,\n} from './lib/git/git.commits-and-tags.js';\nexport {\n  formatGitPath,\n  getGitRoot,\n  guardAgainstLocalChanges,\n  safeCheckout,\n  toGitPath,\n} from './lib/git/git.js';\nexport { groupByStatus } from './lib/group-by-status.js';\nexport {\n  isPromiseFulfilledResult,\n  isPromiseRejectedResult,\n  hasNoNullableProps,\n} from './lib/guards.js';\nexport { logMultipleResults } from './lib/log-results.js';\nexport { link, ui, type CliUi, type Column } from './lib/logging.js';\nexport { mergeConfigs } from './lib/merge-configs.js';\nexport { getProgressBar, type ProgressBar } from './lib/progress.js';\nexport {\n  CODE_PUSHUP_DOMAIN,\n  CODE_PUSHUP_UNICODE_LOGO,\n  FOOTER_PREFIX,\n  README_LINK,\n  TERMINAL_WIDTH,\n} from './lib/reports/constants.js';\nexport {\n  listAuditsFromAllPlugins,\n  listGroupsFromAllPlugins,\n} from './lib/reports/flatten-plugins.js';\nexport { generateMdReport } from './lib/reports/generate-md-report.js';\nexport {\n  generateMdReportsDiff,\n  generateMdReportsDiffForMonorepo,\n} from './lib/reports/generate-md-reports-diff.js';\nexport { loadReport } from './lib/reports/load-report.js';\nexport { logStdoutSummary } from './lib/reports/log-stdout-summary.js';\nexport { scoreReport } from './lib/reports/scoring.js';\nexport { sortReport } from './lib/reports/sorting.js';\nexport type {\n  ScoredCategoryConfig,\n  ScoredGroup,\n  ScoredReport,\n} from './lib/reports/types.js';\nexport {\n  calcDuration,\n  compareIssueSeverity,\n  formatReportScore,\n} from './lib/reports/utils.js';\nexport { isSemver, normalizeSemver, sortSemvers } from './lib/semver.js';\nexport * from './lib/text-formats/index.js';\nexport {\n  capitalize,\n  countOccurrences,\n  distinct,\n  factorOf,\n  fromJsonLines,\n  objectFromEntries,\n  objectToCliArgs,\n  objectToEntries,\n  objectToKeys,\n  toArray,\n  toJsonLines,\n  toNumberPrecision,\n  toOrdinal,\n  toUnixNewlines,\n  toUnixPath,\n  type CliArgsObject,\n} from './lib/transform.js';\nexport type {\n  ExcludeNullableProps,\n  ExtractArray,\n  ExtractArrays,\n  ItemOrArray,\n  Prettify,\n  WithRequired,\n} from './lib/types.js';\nexport { verboseUtils } from './lib/verbose-utils.js';\nexport { zodErrorMessageBuilder } from './lib/zod-validation.js';\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/execute-process.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/execute-process.ts\";import {\n  type ChildProcess,\n  type ChildProcessByStdio,\n  type SpawnOptionsWithStdioTuple,\n  type StdioPipe,\n  spawn,\n} from 'node:child_process';\nimport type { Readable, Writable } from 'node:stream';\nimport { calcDuration } from './reports/utils.js';\n\n/**\n * Represents the process result.\n * @category Types\n * @public\n * @property {string} stdout - The stdout of the process.\n * @property {string} stderr - The stderr of the process.\n * @property {number | null} code - The exit code of the process.\n */\nexport type ProcessResult = {\n  stdout: string;\n  stderr: string;\n  code: number | null;\n  date: string;\n  duration: number;\n};\n\n/**\n * Error class for process errors.\n * Contains additional information about the process result.\n * @category Error\n * @public\n * @class\n * @extends Error\n * @example\n * const result = await executeProcess({})\n * .catch((error) => {\n *   if (error instanceof ProcessError) {\n *   console.error(error.code);\n *   console.error(error.stderr);\n *   console.error(error.stdout);\n *   }\n * });\n *\n */\nexport class ProcessError extends Error {\n  code: number | null;\n  stderr: string;\n  stdout: string;\n\n  constructor(result: ProcessResult) {\n    super(result.stderr);\n    this.code = result.code;\n    this.stderr = result.stderr;\n    this.stdout = result.stdout;\n  }\n}\n\n/**\n * Process config object. Contains the command, args and observer.\n * @param cfg - process config object with command, args and observer (optional)\n * @category Types\n * @public\n * @property {string} command - The command to execute.\n * @property {string[]} args - The arguments for the command.\n * @property {ProcessObserver} observer - The observer for the process.\n *\n * @example\n *\n * // bash command\n * const cfg = {\n *   command: 'bash',\n *   args: ['-c', 'echo \"hello world\"']\n * };\n *\n * // node command\n * const cfg = {\n * command: 'node',\n * args: ['--version']\n * };\n *\n * // npx command\n * const cfg = {\n * command: 'npx',\n * args: ['--version']\n *\n */\nexport type ProcessConfig = Omit<\n  SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>,\n  'stdio'\n> & {\n  command: string;\n  args?: string[];\n  observer?: ProcessObserver;\n  ignoreExitCode?: boolean;\n};\n\n/**\n * Process observer object. Contains the onStdout, error and complete function.\n * @category Types\n * @public\n * @property {function} onStdout - The onStdout function of the observer (optional).\n * @property {function} onError - The error function of the observer (optional).\n * @property {function} onComplete - The complete function of the observer (optional).\n *\n * @example\n * const observer = {\n *  onStdout: (stdout) => console.info(stdout)\n *  }\n */\nexport type ProcessObserver = {\n  onStdout?: (stdout: string, sourceProcess?: ChildProcess) => void;\n  onStderr?: (stderr: string, sourceProcess?: ChildProcess) => void;\n  onError?: (error: ProcessError) => void;\n  onComplete?: () => void;\n};\n\n/**\n * Executes a process and returns a promise with the result as `ProcessResult`.\n *\n * @example\n *\n * // sync process execution\n * const result = await executeProcess({\n *  command: 'node',\n *  args: ['--version']\n * });\n *\n * console.info(result);\n *\n * // async process execution\n * const result = await executeProcess({\n *    command: 'node',\n *    args: ['download-data.js'],\n *    observer: {\n *      onStdout: updateProgress,\n *      error: handleError,\n *      complete: cleanLogs,\n *    }\n * });\n *\n * console.info(result);\n *\n * @param cfg - see {@link ProcessConfig}\n */\nexport function executeProcess(cfg: ProcessConfig): Promise<ProcessResult> {\n  const { command, args, observer, ignoreExitCode = false, ...options } = cfg;\n  const { onStdout, onStderr, onError, onComplete } = observer ?? {};\n  const date = new Date().toISOString();\n  const start = performance.now();\n\n  return new Promise((resolve, reject) => {\n    // shell:true tells Windows to use shell command for spawning a child process\n    const spawnedProcess = spawn(command, args ?? [], {\n      shell: true,\n      windowsHide: true,\n      ...options,\n    }) as ChildProcessByStdio<Writable, Readable, Readable>;\n\n    // eslint-disable-next-line functional/no-let\n    let stdout = '';\n    // eslint-disable-next-line functional/no-let\n    let stderr = '';\n\n    spawnedProcess.stdout.on('data', data => {\n      stdout += String(data);\n      onStdout?.(String(data), spawnedProcess);\n    });\n\n    spawnedProcess.stderr.on('data', data => {\n      stderr += String(data);\n      onStderr?.(String(data), spawnedProcess);\n    });\n\n    spawnedProcess.on('error', err => {\n      stderr += err.toString();\n    });\n\n    spawnedProcess.on('close', code => {\n      const timings = { date, duration: calcDuration(start) };\n      if (code === 0 || ignoreExitCode) {\n        onComplete?.();\n        resolve({ code, stdout, stderr, ...timings });\n      } else {\n        const errorMsg = new ProcessError({ code, stdout, stderr, ...timings });\n        onError?.(errorMsg);\n        reject(errorMsg);\n      }\n    });\n  });\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/utils.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/utils.ts\";import ansis, { type Ansis } from 'ansis';\nimport { type InlineText, md } from 'build-md';\nimport type {\n  AuditDiff,\n  AuditReport,\n  CategoryRef,\n  IssueSeverity as CliIssueSeverity,\n  Group,\n  Issue,\n} from '@code-pushup/models';\nimport { SCORE_COLOR_RANGE } from './constants.js';\nimport type {\n  ScoredReport,\n  SortableAuditReport,\n  SortableGroup,\n} from './types.js';\n\nexport function formatReportScore(score: number): string {\n  const scaledScore = score * 100;\n  const roundedScore = Math.round(scaledScore);\n\n  return roundedScore === 100 && score !== 1\n    ? Math.floor(scaledScore).toString()\n    : roundedScore.toString();\n}\n\nexport function formatScoreWithColor(\n  score: number,\n  options?: { skipBold?: boolean },\n): InlineText {\n  const styledNumber = options?.skipBold\n    ? formatReportScore(score)\n    : md.bold(formatReportScore(score));\n  return md`${scoreMarker(score)} ${styledNumber}`;\n}\n\nexport type MarkerShape = 'circle' | 'square';\nexport type ScoreColors = 'red' | 'yellow' | 'green';\nexport const MARKERS: Record<MarkerShape, Record<ScoreColors, string>> = {\n  circle: {\n    red: '\uD83D\uDD34',\n    yellow: '\uD83D\uDFE1',\n    green: '\uD83D\uDFE2',\n  },\n  square: {\n    red: '\uD83D\uDFE5',\n    yellow: '\uD83D\uDFE8',\n    green: '\uD83D\uDFE9',\n  },\n};\n\nexport function scoreMarker(\n  score: number,\n  markerType: MarkerShape = 'circle',\n): string {\n  if (score >= SCORE_COLOR_RANGE.GREEN_MIN) {\n    return MARKERS[markerType].green;\n  }\n  if (score >= SCORE_COLOR_RANGE.YELLOW_MIN) {\n    return MARKERS[markerType].yellow;\n  }\n  return MARKERS[markerType].red;\n}\n\nexport function getDiffMarker(diff: number): string {\n  if (diff > 0) {\n    return '\u2191';\n  }\n  if (diff < 0) {\n    return '\u2193';\n  }\n  return '';\n}\n\nexport function colorByScoreDiff(text: string, diff: number): InlineText {\n  const color = diff > 0 ? 'green' : diff < 0 ? 'red' : 'gray';\n  return shieldsBadge(text, color);\n}\n\nexport function shieldsBadge(text: string, color: string): InlineText {\n  return md.image(\n    `https://img.shields.io/badge/${encodeURIComponent(text)}-${color}`,\n    text,\n  );\n}\n\nexport function formatDiffNumber(diff: number): string {\n  const number =\n    Math.abs(diff) === Number.POSITIVE_INFINITY ? '\u221E' : `${Math.abs(diff)}`;\n  const sign = diff < 0 ? '\u2212' : '+';\n  return `${sign}${number}`;\n}\n\nexport function severityMarker(severity: 'info' | 'warning' | 'error'): string {\n  if (severity === 'error') {\n    return '\uD83D\uDEA8';\n  }\n  if (severity === 'warning') {\n    return '\u26A0\uFE0F';\n  }\n  return '\u2139\uFE0F';\n}\n\nconst MIN_NON_ZERO_RESULT = 0.1;\n\nexport function roundValue(value: number): number {\n  const roundedValue = Math.round(value * 10) / 10; // round with max 1 decimal\n  if (roundedValue === 0 && value !== 0) {\n    return MIN_NON_ZERO_RESULT * Math.sign(value);\n  }\n  return roundedValue;\n}\n\nexport function formatScoreChange(diff: number): InlineText {\n  const marker = getDiffMarker(diff);\n  const text = formatDiffNumber(roundValue(diff * 100));\n  return colorByScoreDiff(`${marker} ${text}`, diff);\n}\n\nexport function formatValueChange({\n  values,\n  scores,\n}: Pick<AuditDiff, 'values' | 'scores'>): InlineText {\n  const marker = getDiffMarker(values.diff);\n  const percentage =\n    values.before === 0\n      ? values.diff > 0\n        ? Number.POSITIVE_INFINITY\n        : Number.NEGATIVE_INFINITY\n      : roundValue((values.diff / values.before) * 100);\n  // eslint-disable-next-line no-irregular-whitespace\n  const text = `${formatDiffNumber(percentage)}\u2009%`;\n  return colorByScoreDiff(`${marker} ${text}`, scores.diff);\n}\n\nexport function calcDuration(start: number, stop?: number): number {\n  return Math.round((stop ?? performance.now()) - start);\n}\n\nexport function countWeightedRefs(refs: CategoryRef[]) {\n  return refs\n    .filter(({ weight }) => weight > 0)\n    .reduce((sum, { weight }) => sum + weight, 0);\n}\n\nexport function countCategoryAudits(\n  refs: CategoryRef[],\n  plugins: ScoredReport['plugins'],\n): number {\n  // Create lookup object for groups within each plugin\n  const groupLookup = plugins.reduce<Record<string, Record<string, Group>>>(\n    (lookup, plugin) => {\n      if (plugin.groups == null || plugin.groups.length === 0) {\n        return lookup;\n      }\n\n      return {\n        ...lookup,\n        [plugin.slug]: Object.fromEntries(\n          plugin.groups.map(group => [group.slug, group]),\n        ),\n      };\n    },\n    {},\n  );\n\n  // Count audits\n  return refs.reduce((acc, ref) => {\n    if (ref.type === 'group') {\n      const groupRefs = groupLookup[ref.plugin]?.[ref.slug]?.refs;\n      return acc + (groupRefs?.length ?? 0);\n    }\n    return acc + 1;\n  }, 0);\n}\n\nexport function compareCategoryAuditsAndGroups(\n  a: SortableAuditReport | SortableGroup,\n  b: SortableAuditReport | SortableGroup,\n): number {\n  if (a.score !== b.score) {\n    return a.score - b.score;\n  }\n\n  if (a.weight !== b.weight) {\n    return b.weight - a.weight;\n  }\n\n  if ('value' in a && 'value' in b && a.value !== b.value) {\n    return b.value - a.value;\n  }\n\n  return a.title.localeCompare(b.title);\n}\n\nexport function compareAudits(a: AuditReport, b: AuditReport): number {\n  if (a.score !== b.score) {\n    return a.score - b.score;\n  }\n\n  if (a.value !== b.value) {\n    return b.value - a.value;\n  }\n\n  return a.title.localeCompare(b.title);\n}\n\nexport function compareIssueSeverity(\n  severity1: CliIssueSeverity,\n  severity2: CliIssueSeverity,\n): number {\n  const levels: Record<CliIssueSeverity, number> = {\n    info: 0,\n    warning: 1,\n    error: 2,\n  };\n  return levels[severity1] - levels[severity2];\n}\n\nexport function throwIsNotPresentError(\n  itemName: string,\n  presentPlace: string,\n): never {\n  throw new Error(`${itemName} is not present in ${presentPlace}`);\n}\n\nexport function getPluginNameFromSlug(\n  slug: string,\n  plugins: ScoredReport['plugins'],\n): string {\n  return (\n    plugins.find(({ slug: pluginSlug }) => pluginSlug === slug)?.title || slug\n  );\n}\n\nexport function compareIssues(a: Issue, b: Issue): number {\n  if (a.severity !== b.severity) {\n    return -compareIssueSeverity(a.severity, b.severity);\n  }\n  if (!a.source && b.source) {\n    return -1;\n  }\n  if (a.source && !b.source) {\n    return 1;\n  }\n  if (a.source?.file !== b.source?.file) {\n    return a.source?.file.localeCompare(b.source?.file || '') ?? 0;\n  }\n  return compareSourceFilePosition(a.source?.position, b.source?.position);\n}\n\nfunction compareSourceFilePosition(\n  a: NonNullable<Issue['source']>['position'],\n  b: NonNullable<Issue['source']>['position'],\n): number {\n  if (!a && b) {\n    return -1;\n  }\n  if (a && !b) {\n    return 1;\n  }\n  if (a?.startLine !== b?.startLine) {\n    return (a?.startLine ?? 0) - (b?.startLine ?? 0);\n  }\n  return 0;\n}\n\n// @TODO rethink implementation\nexport function applyScoreColor(\n  { score, text }: { score: number; text?: string },\n  style: Ansis = ansis,\n) {\n  const formattedScore = text ?? formatReportScore(score);\n\n  if (score >= SCORE_COLOR_RANGE.GREEN_MIN) {\n    return text\n      ? style.green(formattedScore)\n      : style.bold(style.green(formattedScore));\n  }\n\n  if (score >= SCORE_COLOR_RANGE.YELLOW_MIN) {\n    return text\n      ? style.yellow(formattedScore)\n      : style.bold(style.yellow(formattedScore));\n  }\n\n  return text\n    ? style.red(formattedScore)\n    : style.bold(style.red(formattedScore));\n}\n\nexport function targetScoreIcon(\n  score: number,\n  targetScore?: number,\n  options: {\n    passIcon?: string;\n    failIcon?: string;\n    prefix?: string;\n    postfix?: string;\n  } = {},\n): string {\n  if (targetScore != null) {\n    const {\n      passIcon = '\u2705',\n      failIcon = '\u274C',\n      prefix = '',\n      postfix = '',\n    } = options;\n    if (score >= targetScore) {\n      return `${prefix}${passIcon}${postfix}`;\n    }\n    return `${prefix}${failIcon}${postfix}`;\n  }\n  return '';\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/file-system.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/file-system.ts\";import { bold, gray } from 'ansis';\nimport { type Options, bundleRequire } from 'bundle-require';\nimport { mkdir, readFile, readdir, rm, stat } from 'node:fs/promises';\nimport path from 'node:path';\nimport { formatBytes } from './formatting.js';\nimport { logMultipleResults } from './log-results.js';\nimport { ui } from './logging.js';\n\nexport async function readTextFile(filePath: string): Promise<string> {\n  const buffer = await readFile(filePath);\n  return buffer.toString();\n}\n\nexport async function readJsonFile<T = unknown>(filePath: string): Promise<T> {\n  const text = await readTextFile(filePath);\n  return JSON.parse(text) as T;\n}\n\nexport async function fileExists(filePath: string): Promise<boolean> {\n  try {\n    const stats = await stat(filePath);\n    return stats.isFile();\n  } catch {\n    return false;\n  }\n}\n\nexport async function directoryExists(filePath: string): Promise<boolean> {\n  try {\n    const stats = await stat(filePath);\n    return stats.isDirectory();\n  } catch {\n    return false;\n  }\n}\n\nexport async function ensureDirectoryExists(baseDir: string) {\n  try {\n    await mkdir(baseDir, { recursive: true });\n    return;\n  } catch (error) {\n    ui().logger.info((error as { code: string; message: string }).message);\n    if ((error as { code: string }).code !== 'EEXIST') {\n      throw error;\n    }\n  }\n}\n\nexport async function removeDirectoryIfExists(dir: string) {\n  if (await directoryExists(dir)) {\n    await rm(dir, { recursive: true, force: true });\n  }\n}\n\nexport type FileResult = readonly [string] | readonly [string, number];\nexport type MultipleFileResults = PromiseSettledResult<FileResult>[];\n\nexport function logMultipleFileResults(\n  fileResults: MultipleFileResults,\n  messagePrefix: string,\n): void {\n  const succeededTransform = (result: PromiseFulfilledResult<FileResult>) => {\n    const [fileName, size] = result.value;\n    const formattedSize = size ? ` (${gray(formatBytes(size))})` : '';\n    return `- ${bold(fileName)}${formattedSize}`;\n  };\n  const failedTransform = (result: PromiseRejectedResult) =>\n    `- ${bold(result.reason as string)}`;\n\n  logMultipleResults<FileResult>(\n    fileResults,\n    messagePrefix,\n    succeededTransform,\n    failedTransform,\n  );\n}\n\nexport async function importModule<T = unknown>(options: Options): Promise<T> {\n  const { mod } = await bundleRequire<object>(options);\n\n  if (typeof mod === 'object' && 'default' in mod) {\n    return mod.default as T;\n  }\n  return mod as T;\n}\n\nexport function pluginWorkDir(slug: string): string {\n  return path.join('node_modules', '.code-pushup', slug);\n}\n\nexport type CrawlFileSystemOptions<T> = {\n  directory: string;\n  pattern?: string | RegExp;\n  fileTransform?: (filePath: string) => Promise<T> | T;\n};\nexport async function crawlFileSystem<T = string>(\n  options: CrawlFileSystemOptions<T>,\n): Promise<T[]> {\n  const {\n    directory,\n    pattern,\n    fileTransform = (filePath: string) => filePath as T,\n  } = options;\n\n  const files = await readdir(directory);\n  const promises = files.map(async (file): Promise<T | T[]> => {\n    const filePath = path.join(directory, file);\n    const stats = await stat(filePath);\n\n    if (stats.isDirectory()) {\n      return crawlFileSystem({ directory: filePath, pattern, fileTransform });\n    }\n    if (stats.isFile() && (!pattern || new RegExp(pattern).test(file))) {\n      return fileTransform(filePath);\n    }\n    return [];\n  });\n\n  const resultsNestedArray = await Promise.all(promises);\n  return resultsNestedArray.flat() as T[];\n}\n\nexport async function findNearestFile(\n  fileNames: string[],\n  cwd = process.cwd(),\n): Promise<string | undefined> {\n  // eslint-disable-next-line functional/no-loop-statements\n  for (\n    // eslint-disable-next-line functional/no-let\n    let directory = cwd;\n    directory !== path.dirname(directory);\n    directory = path.dirname(directory)\n  ) {\n    // eslint-disable-next-line functional/no-loop-statements\n    for (const file of fileNames) {\n      if (await fileExists(path.join(directory, file))) {\n        return path.join(directory, file);\n      }\n    }\n  }\n  return undefined;\n}\n\nexport function findLineNumberInText(\n  content: string,\n  pattern: string,\n): number | null {\n  const lines = content.split(/\\r?\\n/); // Split lines, handle both Windows and UNIX line endings\n\n  const lineNumber = lines.findIndex(line => line.includes(pattern)) + 1; // +1 because line numbers are 1-based\n  return lineNumber === 0 ? null : lineNumber; // If the package isn't found, return null\n}\n\nexport function filePathToCliArg(filePath: string): string {\n  // needs to be escaped if spaces included\n  return `\"${filePath}\"`;\n}\n\nexport function projectToFilename(project: string): string {\n  return project.replace(/[/\\\\\\s]+/g, '-').replace(/@/g, '');\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/formatting.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/formatting.ts\";import {\n  MAX_DESCRIPTION_LENGTH,\n  MAX_ISSUE_MESSAGE_LENGTH,\n  MAX_TITLE_LENGTH,\n} from '@code-pushup/models';\n\nexport function slugify(text: string): string {\n  return text\n    .trim()\n    .toLowerCase()\n    .replace(/\\s+|\\//g, '-')\n    .replace(/[^a-z\\d-]/g, '');\n}\n\nexport function pluralize(text: string, amount?: number): string {\n  if (amount != null && Math.abs(amount) === 1) {\n    return text;\n  }\n\n  if (text.endsWith('y')) {\n    return `${text.slice(0, -1)}ies`;\n  }\n  if (text.endsWith('s')) {\n    return `${text}es`;\n  }\n  return `${text}s`;\n}\n\nexport function formatBytes(bytes: number, decimals = 2) {\n  const positiveBytes = Math.max(bytes, 0);\n\n  // early exit\n  if (positiveBytes === 0) {\n    return '0 B';\n  }\n\n  const k = 1024;\n  const dm = Math.max(decimals, 0);\n  const sizes = ['B', 'kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];\n\n  const i = Math.floor(Math.log(positiveBytes) / Math.log(k));\n\n  return `${Number.parseFloat((positiveBytes / Math.pow(k, i)).toFixed(dm))} ${\n    sizes[i]\n  }`;\n}\n\nexport function pluralizeToken(token: string, times: number): string {\n  return `${times} ${Math.abs(times) === 1 ? token : pluralize(token)}`;\n}\n\nexport function formatDuration(duration: number, granularity = 0): string {\n  if (duration < 1000) {\n    return `${granularity ? duration.toFixed(granularity) : duration} ms`;\n  }\n  return `${(duration / 1000).toFixed(2)} s`;\n}\n\nexport function formatDate(date: Date): string {\n  const locale = 'en-US'; // fixed locale to ensure consistency across local defaults execution\n  return date\n    .toLocaleString(locale, {\n      weekday: 'short',\n      month: 'short',\n      day: 'numeric',\n      year: 'numeric',\n      hour: 'numeric',\n      minute: '2-digit',\n      timeZoneName: 'short',\n    })\n    .replace(/\\u202F/g, ' '); // see https://github.com/nodejs/node/issues/45171\n}\n\nexport function truncateText(\n  text: string,\n  options:\n    | number\n    | {\n        maxChars: number;\n        position?: 'start' | 'middle' | 'end';\n        ellipsis?: string;\n      },\n): string {\n  const {\n    maxChars,\n    position = 'end',\n    ellipsis = '...',\n  } = typeof options === 'number' ? { maxChars: options } : options;\n  if (text.length <= maxChars) {\n    return text;\n  }\n\n  const maxLength = maxChars - ellipsis.length;\n  switch (position) {\n    case 'start':\n      return ellipsis + text.slice(-maxLength).trim();\n    case 'middle':\n      const halfMaxChars = Math.floor(maxLength / 2);\n      return (\n        text.slice(0, halfMaxChars).trim() +\n        ellipsis +\n        text.slice(-halfMaxChars).trim()\n      );\n    case 'end':\n      return text.slice(0, maxLength).trim() + ellipsis;\n  }\n}\n\nexport function truncateTitle(text: string): string {\n  return truncateText(text, MAX_TITLE_LENGTH);\n}\n\nexport function truncateDescription(text: string): string {\n  return truncateText(text, MAX_DESCRIPTION_LENGTH);\n}\n\nexport function truncateIssueMessage(text: string): string {\n  return truncateText(text, MAX_ISSUE_MESSAGE_LENGTH);\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/logging.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/logging.ts\";import isaacs_cliui from '@isaacs/cliui';\nimport { cliui } from '@poppinss/cliui';\nimport { underline } from 'ansis';\nimport { TERMINAL_WIDTH } from './reports/constants.js';\n\n// eslint-disable-next-line  @typescript-eslint/no-explicit-any\ntype ArgumentsType<T> = T extends (...args: infer U) => any ? U : never;\nexport type CliUiBase = ReturnType<typeof cliui>;\ntype UI = ReturnType<typeof isaacs_cliui>;\ntype CliExtension = {\n  row: (r: ArgumentsType<UI['div']>) => void;\n};\nexport type Column = {\n  text: string;\n  width?: number;\n  align?: 'right' | 'left' | 'center';\n  padding: number[];\n  border?: boolean;\n};\nexport type CliUi = CliUiBase & CliExtension;\n\n// eslint-disable-next-line import/no-mutable-exports,functional/no-let\nexport let singletonUiInstance: CliUiBase | undefined;\n\nexport function ui(): CliUi {\n  if (singletonUiInstance === undefined) {\n    singletonUiInstance = cliui();\n  }\n  return {\n    ...singletonUiInstance,\n    row: args => {\n      logListItem(args);\n    },\n  };\n}\n\n// eslint-disable-next-line functional/no-let\nlet singletonisaacUi: UI | undefined;\nexport function logListItem(args: ArgumentsType<UI['div']>) {\n  if (singletonisaacUi === undefined) {\n    singletonisaacUi = isaacs_cliui({ width: TERMINAL_WIDTH });\n  }\n  singletonisaacUi.div(...args);\n  const content = singletonisaacUi.toString();\n  // eslint-disable-next-line functional/immutable-data\n  singletonisaacUi.rows = [];\n  singletonUiInstance?.logger.log(content);\n}\n\nexport function link(text: string) {\n  return underline.blueBright(text);\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/git/git.commits-and-tags.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/git\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/git/git.commits-and-tags.ts\";import { type LogOptions as SimpleGitLogOptions, simpleGit } from 'simple-git';\nimport { type Commit, commitSchema } from '@code-pushup/models';\nimport { isSemver } from '../semver.js';\n\nexport async function getLatestCommit(\n  git = simpleGit(),\n): Promise<Commit | null> {\n  const log = await git.log({\n    maxCount: 1,\n    // git log -1 --pretty=format:\"%H %s %an %aI\" - See: https://git-scm.com/docs/pretty-formats\n    format: { hash: '%H', message: '%s', author: '%an', date: '%aI' },\n  });\n  return commitSchema.parse(log.latest);\n}\n\nexport async function getCurrentBranchOrTag(\n  git = simpleGit(),\n): Promise<string> {\n  return (\n    (await git.branch().then(r => r.current)) ||\n    // If no current branch, try to get the tag\n    // @TODO use simple git\n    (await git\n      .raw(['describe', '--tags', '--exact-match'])\n      .then(out => out.trim()))\n  );\n}\n\nexport type LogResult = { hash: string; message: string };\n\nfunction validateFilter({ from, to }: LogOptions) {\n  if (to && !from) {\n    // throw more user-friendly error instead of:\n    // fatal: ambiguous argument '...a': unknown revision or path not in the working tree.\n    // Use '--' to separate paths from revisions, like this:\n    // 'git <command> [<revision>...] -- [<file>...]'\n    throw new Error(\n      `filter needs the \"from\" option defined to accept the \"to\" option.\\n`,\n    );\n  }\n}\n\nexport function filterLogs(\n  allTags: string[],\n  opt?: Pick<LogOptions, 'from' | 'to' | 'maxCount'>,\n) {\n  if (!opt) {\n    return allTags;\n  }\n  validateFilter(opt);\n  const { from, to, maxCount } = opt;\n  const finIndex = <T>(tagName?: string, fallback?: T) => {\n    const idx = allTags.indexOf(tagName ?? '');\n    if (idx !== -1) {\n      return idx;\n    }\n    return fallback;\n  };\n  const fromIndex = finIndex(from, 0);\n  const toIndex = finIndex(to, undefined);\n  return allTags\n    .slice(fromIndex, toIndex ? toIndex + 1 : toIndex)\n    .slice(0, maxCount ?? undefined);\n}\n\nexport async function getHashFromTag(\n  tag: string,\n  git = simpleGit(),\n): Promise<LogResult> {\n  const tagDetails = await git.show(['--no-patch', '--format=%H', tag]);\n  const hash = tagDetails.trim(); // Remove quotes and trim whitespace\n  return {\n    hash: hash.split('\\n').at(-1) ?? '',\n    message: tag,\n  };\n}\n\nexport type LogOptions = {\n  targetBranch?: string;\n  from?: string;\n  to?: string;\n  maxCount?: number;\n};\n\nexport async function getSemverTags(\n  opt: LogOptions = {},\n  git = simpleGit(),\n): Promise<LogResult[]> {\n  validateFilter(opt);\n  const { targetBranch, ...options } = opt;\n  // make sure we have a target branch\n  // eslint-disable-next-line functional/no-let\n  let currentBranch;\n  if (targetBranch) {\n    currentBranch = await getCurrentBranchOrTag(git);\n    await git.checkout(targetBranch);\n  }\n\n  // Fetch all tags merged into the target branch\n  const tagsRaw = await git.tag([\n    '--merged',\n    targetBranch ?? (await getCurrentBranchOrTag(git)),\n  ]);\n\n  const allTags = tagsRaw\n    .split(/\\n/)\n    .map(tag => tag.trim())\n    .filter(Boolean)\n    .filter(isSemver);\n\n  const relevantTags = filterLogs(allTags, options);\n\n  const tagsWithHashes: LogResult[] = await Promise.all(\n    relevantTags.map(tag => getHashFromTag(tag, git)),\n  );\n\n  if (currentBranch) {\n    await git.checkout(currentBranch);\n  }\n\n  return tagsWithHashes;\n}\n\n/**\n * `getHashes` returns a list of commit hashes. Internally it uses `git.log()` to determine the commits within a range.\n * The amount can be limited to a maximum number of commits specified by `maxCount`.\n * With `from` and `to`, you can specify a range of commits.\n *\n * **NOTE:**\n * In Git, specifying a range with two dots (`from..to`) selects commits that are reachable from `to` but not from `from`.\n * Essentially, it shows the commits that are in `to` but not in `from`, excluding the commits unique to `from`.\n *\n * Example:\n *\n * Let's consider the following commit history:\n *\n *   A---B---C---D---E (main)\n *\n * Using `git log B..D`, you would get the commits C and D:\n *\n *   C---D\n *\n * This is because these commits are reachable from D but not from B.\n *\n * ASCII Representation:\n *\n *   Main Branch:    A---B---C---D---E\n *                       \\       \\\n *                        \\       +--- Commits included in `git log B..D`\n *                         \\\n *                          +--- Excluded by the `from` parameter\n *\n * With `simple-git`, when you specify a `from` and `to` range like this:\n *\n *   git.log({ from: 'B', to: 'D' });\n *\n * It interprets it similarly, selecting commits between B and D, inclusive of D but exclusive of B.\n * For `git.log({ from: 'B', to: 'D' })` or `git log B..D`, commits C and D are selected.\n *\n * @param options Object containing `from`, `to`, and optionally `maxCount` to specify the commit range and limit.\n * @param git The `simple-git` instance used to execute Git commands.\n */\nexport async function getHashes(\n  options: SimpleGitLogOptions & Pick<LogOptions, 'targetBranch'> = {},\n  git = simpleGit(),\n): Promise<LogResult[]> {\n  const { targetBranch, from, to, maxCount, ...opt } = options;\n\n  validateFilter({ from, to });\n\n  // Ensure you are on the correct branch\n  // eslint-disable-next-line functional/no-let\n  let currentBranch;\n  if (targetBranch) {\n    currentBranch = await getCurrentBranchOrTag(git);\n    await git.checkout(targetBranch);\n  }\n\n  const logs = await git.log({\n    ...opt,\n    format: {\n      hash: '%H',\n      message: '%s',\n    },\n    from,\n    to,\n    maxCount,\n  });\n\n  // Ensure you are back to the initial branch\n  if (targetBranch) {\n    await git.checkout(currentBranch as string);\n  }\n\n  return [...logs.all];\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/semver.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/semver.ts\";import { rcompare, valid } from 'semver';\n\nexport function normalizeSemver(semverString: string): string {\n  if (semverString.startsWith('v') || semverString.startsWith('V')) {\n    return semverString.slice(1);\n  }\n\n  if (semverString.includes('@')) {\n    return semverString.split('@').at(-1) ?? '';\n  }\n\n  return semverString;\n}\n\nexport function isSemver(semverString = ''): boolean {\n  return valid(normalizeSemver(semverString)) != null;\n}\n\nexport function sortSemvers(semverStrings: string[]): string[] {\n  return semverStrings.map(normalizeSemver).filter(isSemver).sort(rcompare);\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/git/git.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/git\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/git/git.ts\";import path from 'node:path';\nimport { type StatusResult, simpleGit } from 'simple-git';\nimport { ui } from '../logging.js';\nimport { toUnixPath } from '../transform.js';\n\nexport function getGitRoot(git = simpleGit()): Promise<string> {\n  return git.revparse('--show-toplevel');\n}\n\nexport function formatGitPath(filePath: string, gitRoot: string): string {\n  const absolutePath = path.isAbsolute(filePath)\n    ? filePath\n    : path.join(process.cwd(), filePath);\n  const relativePath = path.relative(gitRoot, absolutePath);\n  return toUnixPath(relativePath);\n}\n\nexport async function toGitPath(\n  filePath: string,\n  git = simpleGit(),\n): Promise<string> {\n  const gitRoot = await getGitRoot(git);\n  return formatGitPath(filePath, gitRoot);\n}\n\nexport class GitStatusError extends Error {\n  static ignoredProps = new Set(['current', 'tracking']);\n\n  static getReducedStatus(status: StatusResult) {\n    return Object.fromEntries(\n      Object.entries(status)\n        .filter(([key]) => !this.ignoredProps.has(key))\n        .filter(\n          (\n            entry: [\n              string,\n              number | string | boolean | null | undefined | unknown[],\n            ],\n          ) => {\n            const value = entry[1];\n            if (value == null) {\n              return false;\n            }\n            if (Array.isArray(value) && value.length === 0) {\n              return false;\n            }\n            if (typeof value === 'number' && value === 0) {\n              return false;\n            }\n            return !(typeof value === 'boolean' && !value);\n          },\n        ),\n    );\n  }\n\n  constructor(status: StatusResult) {\n    super(\n      `Working directory needs to be clean before we you can proceed. Commit your local changes or stash them: \\n ${JSON.stringify(\n        GitStatusError.getReducedStatus(status),\n        null,\n        2,\n      )}`,\n    );\n  }\n}\n\nexport async function guardAgainstLocalChanges(\n  git = simpleGit(),\n): Promise<void> {\n  const status = await git.status(['-s']);\n  if (status.files.length > 0) {\n    throw new GitStatusError(status);\n  }\n}\n\nexport async function safeCheckout(\n  branchOrHash: string,\n  forceCleanStatus = false,\n  git = simpleGit(),\n): Promise<void> {\n  // git requires a clean history to check out a branch\n  if (forceCleanStatus) {\n    await git.raw(['reset', '--hard']);\n    await git.clean(['f', 'd']);\n    ui().logger.info(`git status cleaned`);\n  }\n  await guardAgainstLocalChanges(git);\n  await git.checkout(branchOrHash);\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/transform.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/transform.ts\";import { platform } from 'node:os';\n\nexport function toArray<T>(val: T | T[]): T[] {\n  return Array.isArray(val) ? val : [val];\n}\n\nexport function objectToKeys<T extends object>(obj: T) {\n  return Object.keys(obj) as (keyof T)[];\n}\n\nexport function objectToEntries<T extends object>(obj: T) {\n  return Object.entries(obj) as [keyof T, T[keyof T]][];\n}\n\nexport function objectFromEntries<K extends PropertyKey, V>(entries: [K, V][]) {\n  return Object.fromEntries(entries) as Record<K, V>;\n}\n\nexport function countOccurrences<T extends PropertyKey>(\n  values: T[],\n): Partial<Record<T, number>> {\n  return values.reduce<Partial<Record<T, number>>>(\n    (acc, value) => ({ ...acc, [value]: (acc[value] ?? 0) + 1 }),\n    {},\n  );\n}\n\nexport function distinct<T extends string | number | boolean>(array: T[]): T[] {\n  return [...new Set(array)];\n}\n\nexport function deepClone<T>(obj: T): T {\n  return obj == null || typeof obj !== 'object' ? obj : structuredClone(obj);\n}\n\nexport function factorOf<T>(items: T[], filterFn: (i: T) => boolean): number {\n  const itemCount = items.length;\n  // early exit for empty rows\n  if (!itemCount) {\n    return 1;\n  }\n  const filterCount = items.filter(filterFn).length;\n  // if no rows result from the filter fn we forward return 1 as factor\n  return filterCount === 0 ? 1 : (itemCount - filterCount) / itemCount;\n}\n\ntype ArgumentValue = number | string | boolean | string[];\nexport type CliArgsObject<T extends object = Record<string, ArgumentValue>> =\n  T extends never\n    ? Record<string, ArgumentValue | undefined> | { _: string }\n    : T;\n\n/**\n * Converts an object with different types of values into an array of command-line arguments.\n *\n * @example\n * const args = objectToProcessArgs({\n *   _: ['node', 'index.js'], // node index.js\n *   name: 'Juanita', // --name=Juanita\n *   formats: ['json', 'md'] // --format=json --format=md\n * });\n */\nexport function objectToCliArgs<\n  T extends object = Record<string, ArgumentValue>,\n>(params?: CliArgsObject<T>): string[] {\n  if (!params) {\n    return [];\n  }\n\n  return Object.entries(params).flatMap(([key, value]) => {\n    // process/file/script\n    if (key === '_') {\n      return Array.isArray(value) ? value : [`${value}`];\n    }\n    const prefix = key.length === 1 ? '-' : '--';\n    // \"-*\" arguments (shorthands)\n    if (Array.isArray(value)) {\n      return value.map(v => `${prefix}${key}=\"${v}\"`);\n    }\n    // \"--*\" arguments ==========\n\n    if (Array.isArray(value)) {\n      return value.map(v => `${prefix}${key}=\"${v}\"`);\n    }\n\n    if (typeof value === 'object') {\n      return Object.entries(value as Record<string, ArgumentValue>).flatMap(\n        // transform nested objects to the dot notation `key.subkey`\n        ([k, v]) => objectToCliArgs({ [`${key}.${k}`]: v }),\n      );\n    }\n\n    if (typeof value === 'string') {\n      return [`${prefix}${key}=\"${value}\"`];\n    }\n\n    if (typeof value === 'number') {\n      return [`${prefix}${key}=${value}`];\n    }\n\n    if (typeof value === 'boolean') {\n      return [`${prefix}${value ? '' : 'no-'}${key}`];\n    }\n\n    throw new Error(`Unsupported type ${typeof value} for key ${key}`);\n  });\n}\n\nexport function toUnixPath(path: string): string {\n  return path.replace(/\\\\/g, '/');\n}\n\nexport function toUnixNewlines(text: string): string {\n  return platform() === 'win32' ? text.replace(/\\r\\n/g, '\\n') : text;\n}\n\nexport function fromJsonLines<T = unknown>(jsonLines: string) {\n  const unifiedNewLines = toUnixNewlines(jsonLines).trim();\n  return JSON.parse(`[${unifiedNewLines.split('\\n').join(',')}]`) as T;\n}\n\nexport function toJsonLines<T>(json: T[]) {\n  return json.map(item => JSON.stringify(item)).join('\\n');\n}\n\nexport function capitalize<T extends string>(text: T): Capitalize<T> {\n  return `${text.charAt(0).toLocaleUpperCase()}${text.slice(\n    1,\n  )}` as Capitalize<T>;\n}\n\nexport function toNumberPrecision(\n  value: number,\n  decimalPlaces: number,\n): number {\n  return Number(\n    `${Math.round(\n      Number.parseFloat(`${value}e${decimalPlaces}`),\n    )}e-${decimalPlaces}`,\n  );\n}\n\nexport function toOrdinal(value: number): string {\n  /* eslint-disable @typescript-eslint/no-magic-numbers */\n  if (value % 10 === 1 && value % 100 !== 11) {\n    return `${value}st`;\n  }\n\n  if (value % 10 === 2 && value % 100 !== 12) {\n    return `${value}nd`;\n  }\n\n  if (value % 10 === 3 && value % 100 !== 13) {\n    return `${value}rd`;\n  }\n  /* eslint-enable @typescript-eslint/no-magic-numbers */\n\n  return `${value}th`;\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/merge-configs.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/merge-configs.ts\";import type {\n  CategoryConfig,\n  CoreConfig,\n  PersistConfig,\n  PluginConfig,\n  UploadConfig,\n} from '@code-pushup/models';\n\nexport function mergeConfigs(\n  config: CoreConfig,\n  ...configs: Partial<CoreConfig>[]\n): Partial<CoreConfig> {\n  return configs.reduce(\n    (acc, obj) => ({\n      ...acc,\n      ...mergeCategories(acc.categories, obj.categories),\n      ...mergePlugins(acc.plugins, obj.plugins),\n      ...mergePersist(acc.persist, obj.persist),\n      ...mergeUpload(acc.upload, obj.upload),\n    }),\n    config,\n  );\n}\n\nfunction mergeCategories(\n  a: CategoryConfig[] | undefined,\n  b: CategoryConfig[] | undefined,\n): Pick<CoreConfig, 'categories'> {\n  if (!a && !b) {\n    return {};\n  }\n\n  const mergedMap = new Map<string, CategoryConfig>();\n\n  const addToMap = (categories: CategoryConfig[]) => {\n    categories.forEach(newObject => {\n      if (mergedMap.has(newObject.slug)) {\n        const existingObject: CategoryConfig | undefined = mergedMap.get(\n          newObject.slug,\n        );\n\n        mergedMap.set(newObject.slug, {\n          ...existingObject,\n          ...newObject,\n\n          refs: mergeByUniqueCategoryRefCombination(\n            existingObject?.refs,\n            newObject.refs,\n          ),\n        });\n      } else {\n        mergedMap.set(newObject.slug, newObject);\n      }\n    });\n  };\n\n  if (a) {\n    addToMap(a);\n  }\n  if (b) {\n    addToMap(b);\n  }\n\n  // Convert the map back to an array\n  return { categories: [...mergedMap.values()] };\n}\n\nfunction mergePlugins(\n  a: PluginConfig[] | undefined,\n  b: PluginConfig[] | undefined,\n): Pick<CoreConfig, 'plugins'> {\n  if (!a && !b) {\n    return { plugins: [] };\n  }\n\n  const mergedMap = new Map<string, PluginConfig>();\n\n  const addToMap = (plugins: PluginConfig[]) => {\n    plugins.forEach(newObject => {\n      mergedMap.set(newObject.slug, newObject);\n    });\n  };\n\n  if (a) {\n    addToMap(a);\n  }\n  if (b) {\n    addToMap(b);\n  }\n\n  return { plugins: [...mergedMap.values()] };\n}\n\nfunction mergePersist(\n  a: PersistConfig | undefined,\n  b: PersistConfig | undefined,\n): Pick<CoreConfig, 'persist'> {\n  if (!a && !b) {\n    return {};\n  }\n\n  if (a) {\n    return b ? { persist: { ...a, ...b } } : {};\n  } else {\n    return { persist: b };\n  }\n}\n\nfunction mergeByUniqueCategoryRefCombination<\n  T extends { slug: string; type: string; plugin: string },\n>(a: T[] | undefined, b: T[] | undefined) {\n  const map = new Map<string, T>();\n\n  const addToMap = (refs: T[]) => {\n    refs.forEach(ref => {\n      const uniqueIdentification = `${ref.type}:${ref.plugin}:${ref.slug}`;\n      if (map.has(uniqueIdentification)) {\n        map.set(uniqueIdentification, {\n          ...map.get(uniqueIdentification),\n          ...ref,\n        });\n      } else {\n        map.set(uniqueIdentification, ref);\n      }\n    });\n  };\n\n  // Add objects from both arrays to the map\n  if (a) {\n    addToMap(a);\n  }\n  if (b) {\n    addToMap(b);\n  }\n\n  return [...map.values()];\n}\n\nfunction mergeUpload(\n  a: UploadConfig | undefined,\n  b: UploadConfig | undefined,\n): Pick<CoreConfig, 'upload'> {\n  if (!a && !b) {\n    return {};\n  }\n\n  if (a) {\n    return b ? { upload: { ...a, ...b } } : {};\n  } else {\n    return { upload: b };\n  }\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/progress.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/progress.ts\";import { black, bold, gray, green } from 'ansis';\nimport { type CtorOptions, MultiProgressBars } from 'multi-progress-bars';\nimport { TERMINAL_WIDTH } from './reports/constants.js';\n\ntype BarStyles = 'active' | 'done' | 'idle';\ntype StatusStyles = Record<BarStyles, (s: string) => string>;\nexport const barStyles: StatusStyles = {\n  active: (s: string) => green(s),\n  done: (s: string) => gray(s),\n  idle: (s: string) => gray(s),\n};\n\nexport const messageStyles: StatusStyles = {\n  active: (s: string) => black(s),\n  done: (s: string) => bold.green(s),\n  idle: (s: string) => gray(s),\n};\n\nexport type ProgressBar = {\n  // @TODO find better naming\n  incrementInSteps: (numSteps: number) => void;\n  updateTitle: (title: string) => void;\n  endProgress: (message?: string) => void;\n};\n\n// eslint-disable-next-line functional/no-let\nlet mpb: MultiProgressBars;\n\nexport function getSingletonProgressBars(\n  options?: Partial<CtorOptions>,\n): MultiProgressBars {\n  if (!mpb) {\n    mpb = new MultiProgressBars({\n      progressWidth: TERMINAL_WIDTH,\n      initMessage: '',\n      border: true,\n      ...options,\n    });\n  }\n  return mpb;\n}\n\nexport function getProgressBar(taskName: string): ProgressBar {\n  const tasks = getSingletonProgressBars();\n\n  // Initialize progress bar if not set\n  tasks.addTask(taskName, {\n    type: 'percentage',\n    percentage: 0,\n    message: '',\n    barTransformFn: barStyles.idle,\n  });\n\n  return {\n    incrementInSteps: (numPlugins: number) => {\n      tasks.incrementTask(taskName, {\n        percentage: 1 / numPlugins,\n        barTransformFn: barStyles.active,\n      });\n    },\n    updateTitle: (title: string) => {\n      tasks.updateTask(taskName, {\n        message: title,\n        barTransformFn: barStyles.active,\n      });\n    },\n    endProgress: (message = '') => {\n      tasks.done(taskName, {\n        message: messageStyles.done(message),\n        barTransformFn: barStyles.done,\n      });\n    },\n  };\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/generate-md-report.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/generate-md-report.ts\";import { type InlineText, MarkdownDocument, md } from 'build-md';\nimport type { AuditReport, Issue, Report } from '@code-pushup/models';\nimport { formatDate, formatDuration } from '../formatting.js';\nimport { HIERARCHY } from '../text-formats/index.js';\nimport {\n  FOOTER_PREFIX,\n  README_LINK,\n  REPORT_HEADLINE_TEXT,\n} from './constants.js';\nimport {\n  formatSourceLine,\n  linkToLocalSourceForIde,\n  metaDescription,\n  tableSection,\n} from './formatting.js';\nimport {\n  categoriesDetailsSection,\n  categoriesOverviewSection,\n} from './generate-md-report-categoy-section.js';\nimport type { MdReportOptions, ScoredReport } from './types.js';\nimport { formatReportScore, scoreMarker, severityMarker } from './utils.js';\n\nexport function auditDetailsAuditValue({\n  score,\n  value,\n  displayValue,\n}: AuditReport): InlineText {\n  return md`${scoreMarker(score, 'square')} ${md.bold(\n    String(displayValue ?? value),\n  )} (score: ${formatReportScore(score)})`;\n}\n\nfunction hasCategories(\n  report: ScoredReport,\n): report is ScoredReport & Required<Pick<ScoredReport, 'categories'>> {\n  return !!report.categories && report.categories.length > 0;\n}\n\nexport function generateMdReport(\n  report: ScoredReport,\n  options?: MdReportOptions,\n): string {\n  return new MarkdownDocument()\n    .heading(HIERARCHY.level_1, REPORT_HEADLINE_TEXT)\n    .$concat(\n      ...(hasCategories(report)\n        ? [categoriesOverviewSection(report), categoriesDetailsSection(report)]\n        : []),\n      auditsSection(report, options),\n      aboutSection(report),\n    )\n    .rule()\n    .paragraph(md`${FOOTER_PREFIX} ${md.link(README_LINK, 'Code PushUp')}`)\n    .toString();\n}\n\nexport function auditDetailsIssues(\n  issues: Issue[] = [],\n  options?: MdReportOptions,\n): MarkdownDocument | null {\n  if (issues.length === 0) {\n    return null;\n  }\n  return new MarkdownDocument().heading(HIERARCHY.level_4, 'Issues').table(\n    [\n      { heading: 'Severity', alignment: 'center' },\n      { heading: 'Message', alignment: 'left' },\n      { heading: 'Source file', alignment: 'left' },\n      { heading: 'Line(s)', alignment: 'center' },\n    ],\n    issues.map(({ severity: level, message, source }: Issue) => {\n      const severity = md`${severityMarker(level)} ${md.italic(level)}`;\n\n      if (!source) {\n        return [severity, message];\n      }\n      const file = linkToLocalSourceForIde(source, options);\n      if (!source.position) {\n        return [severity, message, file];\n      }\n      const line = formatSourceLine(source.position);\n      return [severity, message, file, line];\n    }),\n  );\n}\n\nexport function auditDetails(\n  audit: AuditReport,\n  options?: MdReportOptions,\n): MarkdownDocument {\n  const { table, issues = [] } = audit.details ?? {};\n  const detailsValue = auditDetailsAuditValue(audit);\n\n  // undefined details OR empty details (undefined issues OR empty issues AND empty table)\n  if (issues.length === 0 && !table?.rows.length) {\n    return new MarkdownDocument().paragraph(detailsValue);\n  }\n\n  const tableSectionContent = table && tableSection(table);\n  const issuesSectionContent =\n    issues.length > 0 && auditDetailsIssues(issues, options);\n\n  return new MarkdownDocument().details(\n    detailsValue,\n    new MarkdownDocument().$concat(tableSectionContent, issuesSectionContent),\n  );\n}\n\nexport function auditsSection(\n  { plugins }: Pick<ScoredReport, 'plugins'>,\n  options?: MdReportOptions,\n): MarkdownDocument {\n  return new MarkdownDocument()\n    .heading(HIERARCHY.level_2, '\uD83D\uDEE1\uFE0F Audits')\n    .$foreach(\n      plugins.flatMap(plugin =>\n        plugin.audits.map(audit => ({ ...audit, plugin })),\n      ),\n      (doc, { plugin, ...audit }) => {\n        const auditTitle = `${audit.title} (${plugin.title})`;\n        const detailsContent = auditDetails(audit, options);\n        const descriptionContent = metaDescription(audit);\n\n        return doc\n          .heading(HIERARCHY.level_3, auditTitle)\n          .$concat(detailsContent)\n          .paragraph(descriptionContent);\n      },\n    );\n}\n\nexport function aboutSection(\n  report: Omit<ScoredReport, 'packageName'>,\n): MarkdownDocument {\n  const { date, plugins } = report;\n  return new MarkdownDocument()\n    .heading(HIERARCHY.level_2, 'About')\n    .paragraph(\n      md`Report was created by ${md.link(\n        README_LINK,\n        'Code PushUp',\n      )} on ${formatDate(new Date(date))}.`,\n    )\n    .table(...pluginMetaTable({ plugins }))\n    .table(...reportMetaTable(report));\n}\n\nexport function pluginMetaTable({\n  plugins,\n}: Pick<Report, 'plugins'>): Parameters<MarkdownDocument['table']> {\n  return [\n    [\n      { heading: 'Plugin', alignment: 'left' },\n      { heading: 'Audits', alignment: 'center' },\n      { heading: 'Version', alignment: 'center' },\n      { heading: 'Duration', alignment: 'right' },\n    ],\n    plugins.map(({ title, audits, version = '', duration }) => [\n      title,\n      audits.length.toString(),\n      version && md.code(version),\n      formatDuration(duration),\n    ]),\n  ];\n}\n\nexport function reportMetaTable({\n  commit,\n  version,\n  duration,\n  plugins,\n  categories,\n}: Pick<\n  ScoredReport,\n  'date' | 'duration' | 'version' | 'commit' | 'plugins' | 'categories'\n>): Parameters<MarkdownDocument['table']> {\n  return [\n    [\n      { heading: 'Commit', alignment: 'left' },\n      { heading: 'Version', alignment: 'center' },\n      { heading: 'Duration', alignment: 'right' },\n      { heading: 'Plugins', alignment: 'center' },\n      { heading: 'Categories', alignment: 'center' },\n      { heading: 'Audits', alignment: 'center' },\n    ],\n    [\n      [\n        commit ? `${commit.message} (${commit.hash})` : 'N/A',\n        md.code(version),\n        formatDuration(duration),\n        plugins.length.toString(),\n        (categories?.length ?? 0).toString(),\n        plugins.reduce((acc, { audits }) => acc + audits.length, 0).toString(),\n      ],\n    ],\n  ];\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/formatting.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/formatting.ts\";import {\n  type HeadingLevel,\n  type InlineText,\n  MarkdownDocument,\n  md,\n} from 'build-md';\nimport path from 'node:path';\nimport type {\n  AuditReport,\n  SourceFileLocation,\n  Table,\n} from '@code-pushup/models';\nimport { HIERARCHY } from '../text-formats/index.js';\nimport {\n  columnsToStringArray,\n  getColumnAlignments,\n  rowToStringArray,\n} from '../text-formats/table.js';\nimport {\n  getEnvironmentType,\n  getGitHubBaseUrl,\n  getGitLabBaseUrl,\n} from './environment-type.js';\nimport type { MdReportOptions } from './types.js';\n\nexport function tableSection(\n  tableData: Table,\n  options?: {\n    level?: HeadingLevel;\n  },\n): MarkdownDocument | null {\n  if (tableData.rows.length === 0) {\n    return null;\n  }\n  const { level = HIERARCHY.level_4 } = options ?? {};\n  const columns = columnsToStringArray(tableData);\n  const alignments = getColumnAlignments(tableData);\n  const rows = rowToStringArray(tableData);\n  return new MarkdownDocument().heading(level, tableData.title).table(\n    columns.map((heading, i) => {\n      const alignment = alignments[i];\n      if (alignment) {\n        return { heading, alignment };\n      }\n      return heading;\n    }),\n    rows,\n  );\n}\n\n// @TODO extract `Pick<AuditReport, 'docsUrl' | 'description'>` to a reusable schema and type\nexport function metaDescription(\n  audit: Pick<AuditReport, 'docsUrl' | 'description'>,\n): InlineText {\n  const docsUrl = audit.docsUrl;\n  const description = audit.description?.trim();\n  if (docsUrl) {\n    const docsLink = md.link(docsUrl, '\uD83D\uDCD6 Docs');\n    if (!description) {\n      return docsLink;\n    }\n    const parsedDescription = description.endsWith('```')\n      ? `${description}\\n\\n`\n      : `${description} `;\n    return md`${parsedDescription}${docsLink}`;\n  }\n  if (description && description.trim().length > 0) {\n    return description;\n  }\n  return '';\n}\n\n/**\n * Link to local source for IDE\n * @param source\n * @param reportLocation\n *\n * @example\n * linkToLocalSourceInIde({ file: 'src/index.ts' }, { outputDir: '.code-pushup' }) // [`src/index.ts`](../src/index.ts)\n */\nexport function linkToLocalSourceForIde(\n  source: SourceFileLocation,\n  options?: Pick<MdReportOptions, 'outputDir'>,\n): InlineText {\n  const { file, position } = source;\n  const { outputDir } = options ?? {};\n\n  // NOT linkable\n  if (!outputDir) {\n    return md.code(file);\n  }\n\n  return md.link(formatFileLink(file, position, outputDir), md.code(file));\n}\n\nexport function formatSourceLine(\n  position: SourceFileLocation['position'],\n): string {\n  if (!position) {\n    return '';\n  }\n  const { startLine, endLine } = position;\n  return endLine && startLine !== endLine\n    ? `${startLine}-${endLine}`\n    : `${startLine}`;\n}\n\nexport function formatGitHubLink(\n  file: string,\n  position: SourceFileLocation['position'],\n): string {\n  const baseUrl = getGitHubBaseUrl();\n  if (!position) {\n    return `${baseUrl}/${file}`;\n  }\n  const { startLine, endLine, startColumn, endColumn } = position;\n  const start = startColumn ? `L${startLine}C${startColumn}` : `L${startLine}`;\n  const end = endLine\n    ? endColumn\n      ? `L${endLine}C${endColumn}`\n      : `L${endLine}`\n    : '';\n  const lineRange = end && start !== end ? `${start}-${end}` : start;\n  return `${baseUrl}/${file}#${lineRange}`;\n}\n\nexport function formatGitLabLink(\n  file: string,\n  position: SourceFileLocation['position'],\n): string {\n  const baseUrl = getGitLabBaseUrl();\n  if (!position) {\n    return `${baseUrl}/${file}`;\n  }\n  const { startLine, endLine } = position;\n  const lineRange =\n    endLine && startLine !== endLine ? `${startLine}-${endLine}` : startLine;\n  return `${baseUrl}/${file}#L${lineRange}`;\n}\n\nexport function formatFileLink(\n  file: string,\n  position: SourceFileLocation['position'],\n  outputDir: string,\n): string {\n  const relativePath = path.posix.relative(outputDir, file);\n  const env = getEnvironmentType();\n\n  switch (env) {\n    case 'vscode':\n      return position ? `${relativePath}#L${position.startLine}` : relativePath;\n    case 'github':\n      return formatGitHubLink(file, position);\n    case 'gitlab':\n      return formatGitLabLink(file, position);\n    default:\n      return relativePath;\n  }\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/generate-md-report-categoy-section.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/generate-md-report-categoy-section.ts\";import { type InlineText, MarkdownDocument, md } from 'build-md';\nimport type { AuditReport } from '@code-pushup/models';\nimport { slugify } from '../formatting.js';\nimport { HIERARCHY } from '../text-formats/index.js';\nimport { metaDescription } from './formatting.js';\nimport { getSortableAuditByRef, getSortableGroupByRef } from './sorting.js';\nimport type { ScoredGroup, ScoredReport } from './types.js';\nimport {\n  countCategoryAudits,\n  formatReportScore,\n  getPluginNameFromSlug,\n  scoreMarker,\n  targetScoreIcon,\n} from './utils.js';\n\nexport function categoriesOverviewSection(\n  report: Required<Pick<ScoredReport, 'plugins' | 'categories'>>,\n): MarkdownDocument {\n  const { categories, plugins } = report;\n  return new MarkdownDocument().table(\n    [\n      { heading: '\uD83C\uDFF7 Category', alignment: 'left' },\n      { heading: '\u2B50 Score', alignment: 'center' },\n      { heading: '\uD83D\uDEE1 Audits', alignment: 'center' },\n    ],\n    categories.map(({ title, refs, score, isBinary }) => [\n      // @TODO refactor `isBinary: boolean` to `targetScore: number` #713\n      // The heading \"ID\" is inferred from the heading text in Markdown.\n      md.link(`#${slugify(title)}`, title),\n      md`${scoreMarker(score)} ${md.bold(\n        formatReportScore(score),\n      )}${binaryIconSuffix(score, isBinary)}`,\n      countCategoryAudits(refs, plugins).toString(),\n    ]),\n  );\n}\n\nexport function categoriesDetailsSection(\n  report: Required<Pick<ScoredReport, 'plugins' | 'categories'>>,\n): MarkdownDocument {\n  const { categories, plugins } = report;\n\n  return new MarkdownDocument()\n    .heading(HIERARCHY.level_2, '\uD83C\uDFF7 Categories')\n    .$foreach(categories, (doc, category) =>\n      doc\n        .heading(HIERARCHY.level_3, category.title)\n        .paragraph(metaDescription(category))\n        .paragraph(\n          md`${scoreMarker(category.score)} Score: ${md.bold(\n            formatReportScore(category.score),\n          )}${binaryIconSuffix(category.score, category.isBinary)}`,\n        )\n        .list(\n          category.refs.map(ref => {\n            // Add group details\n            if (ref.type === 'group') {\n              const group = getSortableGroupByRef(ref, plugins);\n              const groupAudits = group.refs.map(groupRef =>\n                getSortableAuditByRef(\n                  { ...groupRef, plugin: group.plugin, type: 'audit' },\n                  plugins,\n                ),\n              );\n              const pluginTitle = getPluginNameFromSlug(ref.plugin, plugins);\n              return categoryGroupItem(group, groupAudits, pluginTitle);\n            }\n            // Add audit details\n            else {\n              const audit = getSortableAuditByRef(ref, plugins);\n              const pluginTitle = getPluginNameFromSlug(ref.plugin, plugins);\n              return categoryRef(audit, pluginTitle);\n            }\n          }),\n        ),\n    );\n}\n\nexport function categoryRef(\n  { title, score, value, displayValue }: AuditReport,\n  pluginTitle: string,\n): InlineText {\n  const auditTitleAsLink = md.link(\n    `#${slugify(title)}-${slugify(pluginTitle)}`,\n    title,\n  );\n  const marker = scoreMarker(score, 'square');\n  return md`${marker} ${auditTitleAsLink} (${md.italic(\n    pluginTitle,\n  )}) - ${md.bold((displayValue || value).toString())}`;\n}\n\nexport function categoryGroupItem(\n  { score = 0, title }: ScoredGroup,\n  groupAudits: AuditReport[],\n  pluginTitle: string,\n): InlineText {\n  const groupTitle = md`${scoreMarker(score)} ${title} (${md.italic(\n    pluginTitle,\n  )})`;\n\n  const auditsList = md.list(\n    groupAudits.map(\n      ({ title: auditTitle, score: auditScore, value, displayValue }) => {\n        const auditTitleLink = md.link(\n          `#${slugify(auditTitle)}-${slugify(pluginTitle)}`,\n          auditTitle,\n        );\n        const marker = scoreMarker(auditScore, 'square');\n        return md`${marker} ${auditTitleLink} - ${md.bold(\n          String(displayValue ?? value),\n        )}`;\n      },\n    ),\n  );\n\n  return md`${groupTitle}${auditsList}`;\n}\n\nexport function binaryIconSuffix(\n  score: number,\n  isBinary: boolean | undefined,\n): string {\n  // @TODO refactor `isBinary: boolean` to `targetScore: number` #713\n  return targetScoreIcon(score, isBinary ? 1 : undefined, { prefix: ' ' });\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/generate-md-reports-diff.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/generate-md-reports-diff.ts\";import {\n  type HeadingLevel,\n  MarkdownDocument,\n  type TableColumnObject,\n  type TableRow,\n  md,\n} from 'build-md';\nimport type { ReportsDiff } from '@code-pushup/models';\nimport { HIERARCHY } from '../text-formats/index.js';\nimport { toArray } from '../transform.js';\nimport type { WithRequired } from '../types.js';\nimport {\n  changesToDiffOutcomes,\n  compareDiffsBy,\n  createGroupsOrAuditsDetails,\n  formatPortalLink,\n  formatReportOutcome,\n  formatTitle,\n  getDiffChanges,\n  mergeDiffOutcomes,\n  sortChanges,\n  summarizeDiffOutcomes,\n  summarizeUnchanged,\n} from './generate-md-reports-diff-utils.js';\nimport type { DiffOutcome } from './types.js';\nimport {\n  formatScoreChange,\n  formatScoreWithColor,\n  formatValueChange,\n  scoreMarker,\n} from './utils.js';\n\nexport function generateMdReportsDiff(diff: ReportsDiff): string {\n  return new MarkdownDocument()\n    .$concat(\n      createDiffHeaderSection(diff),\n      createDiffCategoriesSection(diff),\n      createDiffDetailsSection(diff),\n    )\n    .toString();\n}\n\nexport type LabeledDiff = WithRequired<ReportsDiff, 'label'>;\n\nexport function generateMdReportsDiffForMonorepo(diffs: LabeledDiff[]): string {\n  const diffsWithOutcomes = diffs\n    .map(diff => ({\n      ...diff,\n      outcome: mergeDiffOutcomes(changesToDiffOutcomes(getDiffChanges(diff))),\n    }))\n    .sort(\n      (a, b) =>\n        compareDiffsBy('categories', a, b) ||\n        compareDiffsBy('groups', a, b) ||\n        compareDiffsBy('audits', a, b) ||\n        a.label.localeCompare(b.label),\n    );\n  const unchanged = diffsWithOutcomes.filter(\n    ({ outcome }) => outcome === 'unchanged',\n  );\n  const changed = diffsWithOutcomes.filter(diff => !unchanged.includes(diff));\n\n  return new MarkdownDocument()\n    .$concat(\n      createDiffHeaderSection(diffs),\n      ...changed.map(createDiffProjectSection),\n    )\n    .$if(unchanged.length > 0, doc =>\n      doc\n        .rule()\n        .paragraph(summarizeUnchanged('project', { unchanged, changed })),\n    )\n    .toString();\n}\n\nfunction createDiffHeaderSection(\n  diff: ReportsDiff | ReportsDiff[],\n): MarkdownDocument {\n  const outcome = mergeDiffOutcomes(\n    changesToDiffOutcomes(toArray(diff).flatMap(getDiffChanges)),\n  );\n  // TODO: what if array contains different commit pairs?\n  const commits = Array.isArray(diff) ? diff[0]?.commits : diff.commits;\n  const portalUrl = Array.isArray(diff) ? undefined : diff.portalUrl;\n\n  return new MarkdownDocument()\n    .heading(HIERARCHY.level_1, 'Code PushUp')\n    .paragraph(formatReportOutcome(outcome, commits))\n    .paragraph(formatPortalLink(portalUrl));\n}\n\nfunction createDiffProjectSection(\n  diff: LabeledDiff & { outcome: DiffOutcome },\n): MarkdownDocument {\n  return new MarkdownDocument()\n    .heading(HIERARCHY.level_2, md`\uD83D\uDCBC Project ${md.code(diff.label)}`)\n    .paragraph(formatReportOutcome(diff.outcome))\n    .paragraph(formatPortalLink(diff.portalUrl))\n    .$concat(\n      createDiffCategoriesSection(diff, {\n        skipHeading: true,\n        skipUnchanged: true,\n      }),\n      createDiffDetailsSection(diff, HIERARCHY.level_3),\n    );\n}\n\nfunction createDiffCategoriesSection(\n  diff: ReportsDiff,\n  options?: { skipHeading?: boolean; skipUnchanged?: boolean },\n): MarkdownDocument | null {\n  const { changed, unchanged, added } = diff.categories;\n  const { skipHeading, skipUnchanged } = options ?? {};\n\n  const categoriesCount = changed.length + unchanged.length + added.length;\n  const hasChanges = unchanged.length < categoriesCount;\n\n  if (categoriesCount === 0) {\n    return null;\n  }\n\n  const [columns, rows] = createCategoriesTable(diff, {\n    hasChanges,\n    skipUnchanged,\n  });\n\n  return new MarkdownDocument()\n    .heading(HIERARCHY.level_2, !skipHeading && '\uD83C\uDFF7\uFE0F Categories')\n    .table(columns, rows)\n    .paragraph(added.length > 0 && md.italic(String.raw`(\\*) New category.`))\n    .paragraph(\n      skipUnchanged &&\n        unchanged.length > 0 &&\n        summarizeUnchanged('category', { changed, unchanged }),\n    );\n}\n\nfunction createCategoriesTable(\n  diff: ReportsDiff,\n  options: { hasChanges: boolean; skipUnchanged?: boolean },\n): Parameters<MarkdownDocument['table']> {\n  const { changed, unchanged, added } = diff.categories;\n  const { hasChanges, skipUnchanged } = options;\n\n  const rows: TableRow[] = [\n    ...sortChanges(changed).map(category => [\n      formatTitle(category),\n      formatScoreWithColor(category.scores.before, {\n        skipBold: true,\n      }),\n      formatScoreWithColor(category.scores.after),\n      formatScoreChange(category.scores.diff),\n    ]),\n    ...added.map(category => [\n      formatTitle(category),\n      md.italic(String.raw`n/a (\\*)`),\n      formatScoreWithColor(category.score),\n      md.italic(String.raw`n/a (\\*)`),\n    ]),\n    ...(skipUnchanged\n      ? []\n      : unchanged.map(category => [\n          formatTitle(category),\n          formatScoreWithColor(category.score, { skipBold: true }),\n          formatScoreWithColor(category.score),\n          '\u2013',\n        ])),\n  ];\n\n  if (rows.length === 0) {\n    return [[], []];\n  }\n\n  const columns: TableColumnObject[] = [\n    { heading: '\uD83C\uDFF7\uFE0F Category', alignment: 'left' },\n    {\n      heading: hasChanges ? '\u2B50 Previous score' : '\u2B50 Score',\n      alignment: 'center',\n    },\n    { heading: '\u2B50 Current score', alignment: 'center' },\n    { heading: '\uD83D\uDD04 Score change', alignment: 'center' },\n  ];\n\n  return [\n    hasChanges ? columns : columns.slice(0, 2),\n    rows.map(row => (hasChanges ? row : row.slice(0, 2))),\n  ];\n}\n\nfunction createDiffDetailsSection(\n  diff: ReportsDiff,\n  level: HeadingLevel = HIERARCHY.level_2,\n): MarkdownDocument | null {\n  if (diff.groups.changed.length + diff.audits.changed.length === 0) {\n    return null;\n  }\n  const summary = (['group', 'audit'] as const)\n    .map(token =>\n      summarizeDiffOutcomes(\n        changesToDiffOutcomes(diff[`${token}s`].changed),\n        token,\n      ),\n    )\n    .filter(Boolean)\n    .join(', ');\n  const details = new MarkdownDocument().$concat(\n    createDiffGroupsSection(diff, level),\n    createDiffAuditsSection(diff, level),\n  );\n  return new MarkdownDocument().details(summary, details);\n}\n\nfunction createDiffGroupsSection(\n  diff: ReportsDiff,\n  level: HeadingLevel,\n): MarkdownDocument | null {\n  if (diff.groups.changed.length + diff.groups.unchanged.length === 0) {\n    return null;\n  }\n  return new MarkdownDocument().heading(level, '\uD83D\uDDC3\uFE0F Groups').$concat(\n    createGroupsOrAuditsDetails(\n      'group',\n      diff.groups,\n      [\n        { heading: '\uD83D\uDD0C Plugin', alignment: 'left' },\n        { heading: '\uD83D\uDDC3\uFE0F Group', alignment: 'left' },\n        { heading: '\u2B50 Previous score', alignment: 'center' },\n        { heading: '\u2B50 Current score', alignment: 'center' },\n        { heading: '\uD83D\uDD04 Score change', alignment: 'center' },\n      ],\n      sortChanges(diff.groups.changed).map(group => [\n        formatTitle(group.plugin),\n        formatTitle(group),\n        formatScoreWithColor(group.scores.before, { skipBold: true }),\n        formatScoreWithColor(group.scores.after),\n        formatScoreChange(group.scores.diff),\n      ]),\n    ),\n  );\n}\n\nfunction createDiffAuditsSection(\n  diff: ReportsDiff,\n  level: HeadingLevel,\n): MarkdownDocument {\n  return new MarkdownDocument().heading(level, '\uD83D\uDEE1\uFE0F Audits').$concat(\n    createGroupsOrAuditsDetails(\n      'audit',\n      diff.audits,\n      [\n        { heading: '\uD83D\uDD0C Plugin', alignment: 'left' },\n        { heading: '\uD83D\uDEE1\uFE0F Audit', alignment: 'left' },\n        { heading: '\uD83D\uDCCF Previous value', alignment: 'center' },\n        { heading: '\uD83D\uDCCF Current value', alignment: 'center' },\n        { heading: '\uD83D\uDD04 Value change', alignment: 'center' },\n      ],\n      sortChanges(diff.audits.changed).map(audit => [\n        formatTitle(audit.plugin),\n        formatTitle(audit),\n        `${scoreMarker(audit.scores.before, 'square')} ${\n          audit.displayValues.before || audit.values.before.toString()\n        }`,\n        md`${scoreMarker(audit.scores.after, 'square')} ${md.bold(\n          audit.displayValues.after || audit.values.after.toString(),\n        )}`,\n        formatValueChange(audit),\n      ]),\n    ),\n  );\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/generate-md-reports-diff-utils.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/generate-md-reports-diff-utils.ts\";import { type InlineText, MarkdownDocument, md } from 'build-md';\nimport type { ReportsDiff } from '@code-pushup/models';\nimport { pluralize, pluralizeToken } from '../formatting.js';\nimport { objectToEntries } from '../transform.js';\nimport type { DiffOutcome } from './types.js';\n\n// to prevent exceeding Markdown comment character limit\nconst MAX_ROWS = 100;\n\nexport function summarizeUnchanged(\n  token: string,\n  { changed, unchanged }: { changed: unknown[]; unchanged: unknown[] },\n): string {\n  const pluralizedCount =\n    changed.length > 0\n      ? pluralizeToken(`other ${token}`, unchanged.length)\n      : `All of ${pluralizeToken(token, unchanged.length)}`;\n  const pluralizedVerb = unchanged.length === 1 ? 'is' : 'are';\n  return `${pluralizedCount} ${pluralizedVerb} unchanged.`;\n}\n\nexport function summarizeDiffOutcomes(\n  outcomes: DiffOutcome[],\n  token: string,\n): string {\n  return objectToEntries(countDiffOutcomes(outcomes))\n    .filter(\n      (entry): entry is [Exclude<DiffOutcome, 'unchanged'>, number] =>\n        entry[0] !== 'unchanged' && entry[1] > 0,\n    )\n    .map(([outcome, count]): string => {\n      const formattedCount = `<strong>${count}</strong> ${pluralize(\n        token,\n        count,\n      )}`;\n      switch (outcome) {\n        case 'positive':\n          return `\uD83D\uDC4D ${formattedCount} improved`;\n        case 'negative':\n          return `\uD83D\uDC4E ${formattedCount} regressed`;\n        case 'mixed':\n          return `${formattedCount} changed without impacting score`;\n      }\n    })\n    .join(', ');\n}\n\nexport function createGroupsOrAuditsDetails<T extends 'group' | 'audit'>(\n  token: T,\n  { changed, unchanged }: ReportsDiff[`${T}s`],\n  ...[columns, rows]: Parameters<MarkdownDocument['table']>\n): MarkdownDocument {\n  if (changed.length === 0) {\n    return new MarkdownDocument().paragraph(\n      summarizeUnchanged(token, { changed, unchanged }),\n    );\n  }\n  return new MarkdownDocument()\n    .table(columns, rows.slice(0, MAX_ROWS))\n    .paragraph(\n      changed.length > MAX_ROWS &&\n        md.italic(\n          `Only the ${MAX_ROWS} most affected ${pluralize(\n            token,\n          )} are listed above for brevity.`,\n        ),\n    )\n    .paragraph(\n      unchanged.length > 0 && summarizeUnchanged(token, { changed, unchanged }),\n    );\n}\n\nexport function formatTitle({\n  title,\n  docsUrl,\n}: {\n  title: string;\n  docsUrl?: string;\n}): InlineText {\n  if (docsUrl) {\n    return md.link(docsUrl, title);\n  }\n  return title;\n}\n\nexport function formatPortalLink(\n  portalUrl: string | undefined,\n): InlineText | undefined {\n  return (\n    portalUrl &&\n    md.link(portalUrl, '\uD83D\uDD75\uFE0F See full comparison in Code PushUp portal \uD83D\uDD0D')\n  );\n}\n\ntype Change = {\n  scores: { diff: number };\n  values?: { diff: number };\n};\n\nexport function sortChanges<T extends Change>(changes: T[]): T[] {\n  return changes.toSorted(\n    (a, b) =>\n      Math.abs(b.scores.diff) - Math.abs(a.scores.diff) ||\n      Math.abs(b.values?.diff ?? 0) - Math.abs(a.values?.diff ?? 0),\n  );\n}\n\nexport function getDiffChanges(diff: ReportsDiff): Change[] {\n  return [\n    ...diff.categories.changed,\n    ...diff.groups.changed,\n    ...diff.audits.changed,\n  ];\n}\n\nexport function changesToDiffOutcomes(changes: Change[]): DiffOutcome[] {\n  return changes.map((change): DiffOutcome => {\n    if (change.scores.diff > 0) {\n      return 'positive';\n    }\n    if (change.scores.diff < 0) {\n      return 'negative';\n    }\n    if (change.values != null && change.values.diff !== 0) {\n      return 'mixed';\n    }\n    return 'unchanged';\n  });\n}\n\nexport function mergeDiffOutcomes(outcomes: DiffOutcome[]): DiffOutcome {\n  if (outcomes.every(outcome => outcome === 'unchanged')) {\n    return 'unchanged';\n  }\n  if (outcomes.includes('positive') && !outcomes.includes('negative')) {\n    return 'positive';\n  }\n  if (outcomes.includes('negative') && !outcomes.includes('positive')) {\n    return 'negative';\n  }\n  return 'mixed';\n}\n\nfunction countDiffOutcomes(\n  outcomes: DiffOutcome[],\n): Record<DiffOutcome, number> {\n  return {\n    positive: outcomes.filter(outcome => outcome === 'positive').length,\n    negative: outcomes.filter(outcome => outcome === 'negative').length,\n    mixed: outcomes.filter(outcome => outcome === 'mixed').length,\n    unchanged: outcomes.filter(outcome => outcome === 'unchanged').length,\n  };\n}\n\nexport function formatReportOutcome(\n  outcome: DiffOutcome,\n  commits?: ReportsDiff['commits'],\n): InlineText {\n  const outcomeTexts = {\n    positive: md`\uD83E\uDD73 Code PushUp report has ${md.bold('improved')}`,\n    negative: md`\uD83D\uDE1F Code PushUp report has ${md.bold('regressed')}`,\n    mixed: md`\uD83E\uDD28 Code PushUp report has both ${md.bold(\n      'improvements and regressions',\n    )}`,\n    unchanged: md`\uD83D\uDE10 Code PushUp report is ${md.bold('unchanged')}`,\n  };\n\n  if (commits) {\n    const commitsText = `compared target commit ${commits.after.hash} with source commit ${commits.before.hash}`;\n    return md`${outcomeTexts[outcome]} \u2013 ${commitsText}.`;\n  }\n\n  return md`${outcomeTexts[outcome]}.`;\n}\n\nexport function compareDiffsBy<T extends 'categories' | 'groups' | 'audits'>(\n  type: T,\n  a: ReportsDiff,\n  b: ReportsDiff,\n): number {\n  return (\n    sumScoreChanges(b[type].changed) - sumScoreChanges(a[type].changed) ||\n    sumConfigChanges(b[type]) - sumConfigChanges(a[type])\n  );\n}\n\nfunction sumScoreChanges(changes: Change[]): number {\n  return changes.reduce<number>(\n    (acc, { scores }) => acc + Math.abs(scores.diff),\n    0,\n  );\n}\n\nfunction sumConfigChanges({\n  added,\n  removed,\n}: {\n  added: unknown[];\n  removed: unknown[];\n}): number {\n  return added.length + removed.length;\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/load-report.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/load-report.ts\";import path from 'node:path';\nimport {\n  type Format,\n  type PersistConfig,\n  type Report,\n  reportSchema,\n} from '@code-pushup/models';\nimport {\n  ensureDirectoryExists,\n  readJsonFile,\n  readTextFile,\n} from '../file-system.js';\n\ntype LoadedReportFormat<T extends Format> = T extends 'json' ? Report : string;\n\nexport async function loadReport<T extends Format>(\n  options: Required<Omit<PersistConfig, 'format'>> & {\n    format: T;\n  },\n): Promise<LoadedReportFormat<T>> {\n  const { outputDir, filename, format } = options;\n  await ensureDirectoryExists(outputDir);\n  const filePath = path.join(outputDir, `${filename}.${format}`);\n\n  if (format === 'json') {\n    const content = await readJsonFile(filePath);\n    return reportSchema.parse(content) as LoadedReportFormat<T>;\n  }\n\n  const text = await readTextFile(filePath);\n  return text as LoadedReportFormat<T>;\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/log-stdout-summary.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/log-stdout-summary.ts\";import { bold, cyan, cyanBright, green, red } from 'ansis';\nimport type { AuditReport } from '@code-pushup/models';\nimport { ui } from '../logging.js';\nimport {\n  CODE_PUSHUP_DOMAIN,\n  FOOTER_PREFIX,\n  REPORT_HEADLINE_TEXT,\n  REPORT_RAW_OVERVIEW_TABLE_HEADERS,\n  TERMINAL_WIDTH,\n} from './constants.js';\nimport type { ScoredReport } from './types.js';\nimport {\n  applyScoreColor,\n  countCategoryAudits,\n  targetScoreIcon,\n} from './utils.js';\n\nfunction log(msg = ''): void {\n  ui().logger.log(msg);\n}\n\nexport function logStdoutSummary(report: ScoredReport, verbose = false): void {\n  const { plugins, categories, packageName, version } = report;\n  log(reportToHeaderSection({ packageName, version }));\n  log();\n  logPlugins(plugins, verbose);\n  if (categories && categories.length > 0) {\n    logCategories({ plugins, categories });\n  }\n  log(`${FOOTER_PREFIX} ${CODE_PUSHUP_DOMAIN}`);\n  log();\n}\n\nfunction reportToHeaderSection({\n  packageName,\n  version,\n}: Pick<ScoredReport, 'packageName' | 'version'>): string {\n  return `${bold(REPORT_HEADLINE_TEXT)} - ${packageName}@${version}`;\n}\n\nexport function logPlugins(\n  plugins: ScoredReport['plugins'],\n  verbose: boolean,\n): void {\n  plugins.forEach(plugin => {\n    const { title, audits } = plugin;\n    const filteredAudits =\n      verbose || audits.length === 1\n        ? audits\n        : audits.filter(({ score }) => score !== 1);\n    const diff = audits.length - filteredAudits.length;\n\n    logAudits(title, filteredAudits);\n\n    if (diff > 0) {\n      const notice =\n        filteredAudits.length === 0\n          ? `... All ${diff} audits have perfect scores ...`\n          : `... ${diff} audits with perfect scores omitted for brevity ...`;\n      logRow(1, notice);\n    }\n    log();\n  });\n}\n\nfunction logAudits(pluginTitle: string, audits: AuditReport[]): void {\n  log();\n  log(bold.magentaBright(`${pluginTitle} audits`));\n  log();\n  audits.forEach(({ score, title, displayValue, value }) => {\n    logRow(score, title, displayValue || `${value}`);\n  });\n}\n\nfunction logRow(score: number, title: string, value?: string): void {\n  ui().row([\n    {\n      text: applyScoreColor({ score, text: '\u25CF' }),\n      width: 2,\n      padding: [0, 1, 0, 0],\n    },\n    {\n      text: title,\n      // eslint-disable-next-line @typescript-eslint/no-magic-numbers\n      padding: [0, 3, 0, 0],\n    },\n    ...(value\n      ? [\n          {\n            text: cyanBright(value),\n            // eslint-disable-next-line @typescript-eslint/no-magic-numbers\n            width: 20,\n            padding: [0, 0, 0, 0],\n          },\n        ]\n      : []),\n  ]);\n}\n\nexport function logCategories({\n  plugins,\n  categories,\n}: Required<Pick<ScoredReport, 'plugins' | 'categories'>>): void {\n  const hAlign = (idx: number) => (idx === 0 ? 'left' : 'right');\n\n  const rows = categories.map(({ title, score, refs, isBinary }) => [\n    title,\n    `${binaryIconPrefix(score, isBinary)}${applyScoreColor({ score })}`,\n    countCategoryAudits(refs, plugins),\n  ]);\n  const table = ui().table();\n  // eslint-disable-next-line @typescript-eslint/no-magic-numbers\n  table.columnWidths([TERMINAL_WIDTH - 9 - 10 - 4, 9, 10]);\n  table.head(\n    REPORT_RAW_OVERVIEW_TABLE_HEADERS.map((heading, idx) => ({\n      content: cyan(heading),\n      hAlign: hAlign(idx),\n    })),\n  );\n  rows.forEach(row =>\n    table.row(\n      row.map((content, idx) => ({\n        content: content.toString(),\n        hAlign: hAlign(idx),\n      })),\n    ),\n  );\n\n  log(bold.magentaBright('Categories'));\n  log();\n  table.render();\n  log();\n}\n\n// @TODO refactor `isBinary: boolean` to `targetScore: number` #713\nexport function binaryIconPrefix(\n  score: number,\n  isBinary: boolean | undefined,\n): string {\n  return targetScoreIcon(score, isBinary ? 1 : undefined, {\n    passIcon: bold(green('\u2713')),\n    failIcon: bold(red('\u2717')),\n    postfix: ' ',\n  });\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/zod-validation.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/zod-validation.ts\";import { bold, red } from 'ansis';\nimport type { MessageBuilder } from 'zod-validation-error';\n\nexport function formatErrorPath(errorPath: (string | number)[]): string {\n  return errorPath\n    .map((key, index) => {\n      if (typeof key === 'number') {\n        return `[${key}]`;\n      }\n      return index > 0 ? `.${key}` : key;\n    })\n    .join('');\n}\n\nexport const zodErrorMessageBuilder: MessageBuilder = issues =>\n  issues\n    .map(issue => {\n      const formattedMessage = red(`${bold(issue.code)}: ${issue.message}`);\n      const formattedPath = formatErrorPath(issue.path);\n      if (formattedPath) {\n        return `Validation error at ${bold(formattedPath)}\\n${formattedMessage}\\n`;\n      }\n      return `${formattedMessage}\\n`;\n    })\n    .join('\\n');\n"],
  "mappings": "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",
  "names": ["z", "path", "path", "ui", "path", "bold", "path", "ui", "z", "z", "config", "groups", "audits", "calculateCoverage", "config", "calculateCoverage", "config", "createRequire", "path", "fileURLToPath", "z", "z", "slugify", "toArray", "path", "exists", "toArray", "ui", "exists", "toArray", "ui", "ESLint", "writeFile", "path", "ensureDirectoryExists", "filePathToCliArg", "pluginWorkDir", "readJsonFile", "distinct", "executeProcess", "filePathToCliArg", "toArray", "ui", "WORKDIR", "pluginWorkDir", "RUNNER_OUTPUT_PATH", "path", "PLUGIN_CONFIG_PATH", "path", "fileExists", "toArray", "createRequire", "path", "fileURLToPath", "z", "z", "objectToKeys", "path", "objectToKeys", "readJsonFile", "objectToEntries", "objectToEntries", "objectToEntries", "objectToEntries", "objectToKeys", "objectToKeys", "objectToEntries", "fromJsonLines", "objectFromEntries", "objectToEntries", "objectToKeys", "writeFile", "path", "ensureDirectoryExists", "executeProcess", "filePathToCliArg", "objectFromEntries", "readJsonFile", "objectToEntries", "path", "pluginWorkDir", "WORKDIR", "pluginWorkDir", "RUNNER_OUTPUT_PATH", "path", "PLUGIN_CONFIG_PATH", "md", "objectFromEntries", "objectToKeys", "objectToKeys", "path", "fileExists", "executeProcess", "createRequire", "path", "path", "bold", "ui", "path", "path", "path", "ensureDirectoryExists", "bold", "importModule", "readJsonFile", "ui", "bold", "yellow", "ui", "tableSchema", "formatBytes", "formatDuration", "html", "bold", "ui", "bold", "toArray", "config", "config", "exists", "md", "bold", "readFile", "path", "path", "simpleGit", "platform", "config", "categories", "bold", "gray", "MarkdownDocument", "md", "md", "path", "MarkdownDocument", "md", "MarkdownDocument", "md", "MarkdownDocument", "md", "path", "bold", "green", "bold", "red", "z"]
}
 diff --git a/code-pushup.config.ts b/code-pushup.config.ts index d1b674a1d..ddfcd59f6 100644 --- a/code-pushup.config.ts +++ b/code-pushup.config.ts @@ -40,5 +40,22 @@ export default mergeConfigs( 'https://github.com/code-pushup/cli?tab=readme-ov-file#code-pushup-cli/', ), await eslintCoreConfigNx(), - await docCoverageCoreConfig(), + await docCoverageCoreConfig({ + sourceGlob: [ + 'packages/**/src/**/*.ts', + '!**/*.spec.ts', + '!**/*.test.ts', + '!**/implementation/**', + '!**/internal/**', + ], + onlyAudits: [ + 'methods-coverage', + 'functions-coverage', + 'types-coverage', + 'classes-coverage', + 'interfaces-coverage', + 'enums-coverage', + 'type-aliases-coverage', + ], + }), ); diff --git a/code-pushup.preset.ts b/code-pushup.preset.ts index 979610544..1060dd1e9 100644 --- a/code-pushup.preset.ts +++ b/code-pushup.preset.ts @@ -5,8 +5,14 @@ import type { import coveragePlugin, { getNxCoveragePaths, } from './packages/plugin-coverage/src/index.js'; -import docCoveragePlugin from './packages/plugin-doc-coverage/src/index.js'; -import { docCoverageAudits } from './packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.js'; +import docCoveragePlugin, { + DocCoveragePluginConfig, +} from './packages/plugin-doc-coverage/src/index.js'; +import { + PLUGIN_SLUG, + groups, +} from './packages/plugin-doc-coverage/src/lib/constants.js'; +import { filterGroupsByOnlyAudits } from './packages/plugin-doc-coverage/src/lib/utils.js'; import eslintPlugin, { eslintConfigFromAllNxProjects, eslintConfigFromNxProject, @@ -84,19 +90,23 @@ export const eslintCategories: CategoryConfig[] = [ }, ]; -export const docCoverageCategories: CategoryConfig[] = [ - { - slug: 'doc-coverage', - title: 'Documentation coverage', - description: 'Measures how much of your code is **documented**.', - refs: docCoverageAudits.map(audit => ({ - weight: 1, - type: 'audit', - plugin: 'doc-coverage', - slug: audit.slug, - })), - }, -]; +export function getDocCoverageCategories( + config: DocCoveragePluginConfig, +): CategoryConfig[] { + return [ + { + slug: 'doc-coverage-cat', + title: 'Documentation coverage', + description: 'Measures how much of your code is **documented**.', + refs: filterGroupsByOnlyAudits(groups, config).map(group => ({ + weight: 1, + type: 'group', + plugin: PLUGIN_SLUG, + slug: group.slug, + })), + }, + ]; +} export const coverageCategories: CategoryConfig[] = [ { @@ -130,15 +140,12 @@ export const lighthouseCoreConfig = async ( }; }; -export const docCoverageCoreConfig = async (): Promise => { +export const docCoverageCoreConfig = async ( + config: DocCoveragePluginConfig, +): Promise => { return { - plugins: [ - await docCoveragePlugin({ - language: 'typescript', - sourceGlob: 'packages/**/*.ts', - }), - ], - categories: docCoverageCategories, + plugins: [await docCoveragePlugin(config)], + categories: getDocCoverageCategories(config), }; }; diff --git a/packages/plugin-doc-coverage/mocks/component-mock.spec.ts b/packages/plugin-doc-coverage/mocks/component-mock.spec.ts new file mode 100644 index 000000000..62998c2a9 --- /dev/null +++ b/packages/plugin-doc-coverage/mocks/component-mock.spec.ts @@ -0,0 +1,16 @@ +import { describe, expect, it } from 'vitest'; +import { DUMMY_FUNCTION, DUMMY_FUNCTION_2 } from './component-mock'; + +export function shouldnotBeHere() { + return 'Hello World'; +} + +describe('component-mock', () => { + it('should return Hello World', () => { + expect(DUMMY_FUNCTION()).toBe('Hello World'); + }); + + it('should return Hello World 2', () => { + expect(DUMMY_FUNCTION_2()).toBe('Hello World 2'); + }); +}); diff --git a/packages/plugin-doc-coverage/mocks/component-mock.ts b/packages/plugin-doc-coverage/mocks/component-mock.ts index acd80f441..5b2da7c27 100644 --- a/packages/plugin-doc-coverage/mocks/component-mock.ts +++ b/packages/plugin-doc-coverage/mocks/component-mock.ts @@ -10,40 +10,40 @@ export function DUMMY_FUNCTION_2() { return 'Hello World 2'; } -class DummyClass { - /** - * Dummy property that returns 'Hello World 3'. - * @returns {string} - The string 'Hello World 3'. - */ - dummyProperty = 'Hello World 3'; - - /** - * Dummy method that returns 'Hello World 4'. - * @returns {string} - The string 'Hello World 4'. - */ - dummyMethod() { - return 'Hello World 4'; - } - - constructor() { - this.dummyProperty = 'Hello World 3'; - } -} - -export default DummyClass; - -export const variableDummy = 'Hello World 5'; - -export const variableDummy2 = 'Hello World 6'; - -/** Dummy variable that returns 'Hello World 7'. */ -export const variableDummy3 = 'Hello World 7'; - -/** Dummy interface that returns 'Hello World 8'. */ -export interface DummyInterface { - dummyProperty: string; - dummyMethod(): string; -} - -/** Dummy type that returns 'Hello World 9'. */ -export type DummyType = string; +// class DummyClass { +// /** +// * Dummy property that returns 'Hello World 3'. +// * @returns {string} - The string 'Hello World 3'. +// */ +// dummyProperty = 'Hello World 3'; + +// /** +// * Dummy method that returns 'Hello World 4'. +// * @returns {string} - The string 'Hello World 4'. +// */ +// dummyMethod() { +// return 'Hello World 4'; +// } + +// constructor() { +// this.dummyProperty = 'Hello World 3'; +// } +// } + +// export default DummyClass; + +// export const variableDummy = 'Hello World 5'; + +// export const variableDummy2 = 'Hello World 6'; + +// /** Dummy variable that returns 'Hello World 7'. */ +// export const variableDummy3 = 'Hello World 7'; + +// /** Dummy interface that returns 'Hello World 8'. */ +// export interface DummyInterface { +// dummyProperty: string; +// dummyMethod(): string; +// } + +// /** Dummy type that returns 'Hello World 9'. */ +// export type DummyType = string; diff --git a/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.css b/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.css new file mode 100644 index 000000000..f3958f2b4 --- /dev/null +++ b/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.css @@ -0,0 +1,4 @@ +h1 { + color: #336699; + text-align: center; +} diff --git a/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.html b/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.html new file mode 100644 index 000000000..b6515528b --- /dev/null +++ b/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.html @@ -0,0 +1 @@ +

{{ title }}

diff --git a/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.spec.ts b/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.spec.ts new file mode 100644 index 000000000..c89f47dd8 --- /dev/null +++ b/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.spec.ts @@ -0,0 +1,3 @@ +function notRealisticFunction() { + return 'notRealisticFunction'; +} diff --git a/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.ts b/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.ts new file mode 100644 index 000000000..2fc2b165f --- /dev/null +++ b/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.ts @@ -0,0 +1,18 @@ +/** + * Basic Angular component that displays a welcome message + */ +export class AppComponent { + protected readonly title = 'My Angular App'; + + /** + * Dummy method that returns a welcome message + * @returns {string} - The welcome message + */ + getWelcomeMessage() { + return 'Welcome to My Angular App!'; + } + + sendEvent() { + return 'Event sent'; + } +} diff --git a/packages/plugin-doc-coverage/mocks/fixtures/angular/map-event.function.ts b/packages/plugin-doc-coverage/mocks/fixtures/angular/map-event.function.ts new file mode 100644 index 000000000..9cd32ce8a --- /dev/null +++ b/packages/plugin-doc-coverage/mocks/fixtures/angular/map-event.function.ts @@ -0,0 +1,8 @@ +export function mapEventToCustomEvent(event: string) { + return event; +} + +/** Commented */ +export function mapCustomEventToEvent(event: string) { + return event; +} diff --git a/packages/plugin-doc-coverage/mocks/source-files.mock.ts b/packages/plugin-doc-coverage/mocks/source-files.mock.ts new file mode 100644 index 000000000..bc0ad113c --- /dev/null +++ b/packages/plugin-doc-coverage/mocks/source-files.mock.ts @@ -0,0 +1,114 @@ +import { + ClassDeclaration, + EnumDeclaration, + FunctionDeclaration, + InterfaceDeclaration, + SourceFile, + SyntaxKind, + TypeAliasDeclaration, +} from 'ts-morph'; +import type { CoverageType } from '../src/lib/models'; + +export function sourceFileMock( + file: string, + nodes: Partial>>, +): SourceFile { + return { + getFilePath: () => file as any, + getClasses: () => + nodes.classes + ? (Object.entries(nodes.classes).map(([line, isCommented]) => + nodeMock({ + coverageType: 'classes', + line: Number(line), + file, + isCommented, + }), + ) as unknown as ClassDeclaration[]) + : [], + getFunctions: () => + nodes.functions + ? (Object.entries(nodes.functions).map(([line, isCommented]) => + nodeMock({ + coverageType: 'functions', + line: Number(line), + file, + isCommented, + }), + ) as unknown as FunctionDeclaration[]) + : [], + getEnums: () => + nodes.enums + ? (Object.entries(nodes.enums).map(([line, isCommented]) => + nodeMock({ + coverageType: 'enums', + line: Number(line), + file, + isCommented, + }), + ) as unknown as EnumDeclaration[]) + : [], + getTypeAliases: () => + nodes.types + ? (Object.entries(nodes.types).map(([line, isCommented]) => + nodeMock({ + coverageType: 'types', + line: Number(line), + file, + isCommented, + }), + ) as unknown as TypeAliasDeclaration[]) + : [], + getInterfaces: () => + nodes.interfaces + ? (Object.entries(nodes.interfaces).map(([line, isCommented]) => + nodeMock({ + coverageType: 'interfaces', + line: Number(line), + file, + isCommented, + }), + ) as unknown as InterfaceDeclaration[]) + : [], + } as SourceFile; +} + +export function nodeMock(options: { + coverageType: CoverageType; + line: number; + file: string; + isCommented: boolean; +}) { + return { + getKind: () => getKindFromCoverageType(options.coverageType), + getJsDocs: () => (options.isCommented ? ['Comment'] : []), + getName: () => 'test', + getStartLineNumber: () => options.line, + // Only for classes + getMethods: () => [], + getProperties: () => [], + }; +} + +function getKindFromCoverageType(coverageType: CoverageType): SyntaxKind { + switch (coverageType) { + case 'classes': + return SyntaxKind.ClassDeclaration; + case 'methods': + return SyntaxKind.MethodDeclaration; + case 'functions': + return SyntaxKind.FunctionDeclaration; + case 'interfaces': + return SyntaxKind.InterfaceDeclaration; + case 'enums': + return SyntaxKind.EnumDeclaration; + case 'variables': + return SyntaxKind.VariableDeclaration; + case 'properties': + return SyntaxKind.PropertyDeclaration; + case 'types': + return SyntaxKind.TypeAliasDeclaration; + default: + throw new Error(`Unsupported syntax kind: ${coverageType}`); + } +} diff --git a/packages/plugin-doc-coverage/src/lib/config.ts b/packages/plugin-doc-coverage/src/lib/config.ts index 853099796..52ccb5cb8 100644 --- a/packages/plugin-doc-coverage/src/lib/config.ts +++ b/packages/plugin-doc-coverage/src/lib/config.ts @@ -1,13 +1,10 @@ import { z } from 'zod'; -export type DocType = 'percentage-coverage'; - export const docCoveragePluginConfigSchema = z.object({ + onlyAudits: z.array(z.string()).optional(), sourceGlob: z - .string({ - description: 'Glob pattern to find source files', - }) - .default('src/**/*.{ts,tsx}'), + .array(z.string()) + .default(['src/**/*.{ts,tsx}', '!**/*.spec.ts', '!**/*.test.ts']), }); export type DocCoveragePluginConfig = z.infer< diff --git a/packages/plugin-doc-coverage/src/lib/config.unit.test.ts b/packages/plugin-doc-coverage/src/lib/config.unit.test.ts index 4cb85ed8a..63d0007b9 100644 --- a/packages/plugin-doc-coverage/src/lib/config.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/config.unit.test.ts @@ -8,7 +8,7 @@ describe('docCoveragePluginConfigSchema', () => { it('accepts a valid source glob pattern', () => { expect(() => docCoveragePluginConfigSchema.parse({ - sourceGlob: 'src/**/*.{ts,tsx}', + sourceGlob: ['src/**/*.{ts,tsx}', '!**/*.spec.ts', '!**/*.test.ts'], } satisfies DocCoveragePluginConfig), ).not.toThrow(); }); diff --git a/packages/plugin-doc-coverage/src/lib/constants.ts b/packages/plugin-doc-coverage/src/lib/constants.ts new file mode 100644 index 000000000..458409066 --- /dev/null +++ b/packages/plugin-doc-coverage/src/lib/constants.ts @@ -0,0 +1,68 @@ +import type { Audit, Group } from '@code-pushup/models'; +import type { AuditSlug } from './models'; + +export const PLUGIN_SLUG = 'doc-coverage'; + +export const AUDITS_MAP: Record = { + 'classes-coverage': { + slug: 'classes-coverage', + title: 'Classes coverage', + description: 'Coverage of classes', + }, + 'methods-coverage': { + slug: 'methods-coverage', + title: 'Methods coverage', + description: 'Coverage of methods', + }, + 'functions-coverage': { + slug: 'functions-coverage', + title: 'Functions coverage', + description: 'Coverage of functions', + }, + 'interfaces-coverage': { + slug: 'interfaces-coverage', + title: 'Interfaces coverage', + description: 'Coverage of interfaces', + }, + 'variables-coverage': { + slug: 'variables-coverage', + title: 'Variables coverage', + description: 'Coverage of variables', + }, + 'properties-coverage': { + slug: 'properties-coverage', + title: 'Properties coverage', + description: 'Coverage of properties', + }, + 'types-coverage': { + slug: 'types-coverage', + title: 'Types coverage', + description: 'Coverage of types', + }, + 'enums-coverage': { + slug: 'enums-coverage', + title: 'Enums coverage', + description: 'Coverage of enums', + }, +} as const; + +export const groups: Group[] = [ + { + slug: 'documentation-coverage', + title: 'Documentation coverage', + description: 'Documentation coverage', + refs: Object.keys(AUDITS_MAP).map(slug => { + switch (slug as AuditSlug) { + case 'classes-coverage': + case 'functions-coverage': + case 'methods-coverage': + return { slug, weight: 2 }; + case 'interfaces-coverage': + case 'properties-coverage': + case 'types-coverage': + default: + return { slug, weight: 1 }; + } + }), + }, +]; diff --git a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts index 37d54858e..371409e1b 100644 --- a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts +++ b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts @@ -1,12 +1,22 @@ -import { createRequire } from 'node:module'; -import path from 'node:path'; -import { fileURLToPath } from 'node:url'; import type { PluginConfig } from '@code-pushup/models'; import { type DocCoveragePluginConfig, docCoveragePluginConfigSchema, } from './config.js'; -import { createRunnerConfig } from './runner/index.js'; +import { PLUGIN_SLUG, groups } from './constants.js'; +import { createRunnerFunction } from './runner/runner.js'; +import { + filterAuditsByPluginConfig, + filterGroupsByOnlyAudits, +} from './utils.js'; + +const PLUGIN_TITLE = 'Documentation coverage'; + +const PLUGIN_DESCRIPTION = + 'Official Code PushUp documentation coverage plugin.'; + +const PLUGIN_DOCS_URL = + 'https://www.npmjs.com/package/@code-pushup/doc-coverage-plugin/'; /** * Instantiates Code PushUp documentation coverage plugin for core config. @@ -26,40 +36,19 @@ import { createRunnerConfig } from './runner/index.js'; * * @returns Plugin configuration. */ - -export const docCoverageAudits = [ - { - slug: 'percentage-coverage', - title: 'Percentage of codebase with documentation', - description: 'Measures how many % of the codebase have documentation.', - }, -]; - export async function docCoveragePlugin( config: DocCoveragePluginConfig, ): Promise { const docCoverageConfig = docCoveragePluginConfigSchema.parse(config); - const runnerScriptPath = path.join( - fileURLToPath(path.dirname(import.meta.url)), - '..', - 'bin.js', - ); - - const packageJson = createRequire(import.meta.url)( - '../../package.json', - ) as typeof import('../../package.json'); - return { - slug: 'doc-coverage', - title: 'Documentation coverage', + slug: PLUGIN_SLUG, + title: PLUGIN_TITLE, icon: 'folder-src', - description: 'Official Code PushUp documentation coverage plugin.', - docsUrl: 'https://www.npmjs.com/package/@code-pushup/doc-coverage-plugin/', - packageName: packageJson.name, - version: packageJson.version, - audits: docCoverageAudits, - // groups: [group], - runner: await createRunnerConfig(runnerScriptPath, docCoverageConfig), + description: PLUGIN_DESCRIPTION, + docsUrl: PLUGIN_DOCS_URL, + groups: filterGroupsByOnlyAudits(groups, docCoverageConfig), + audits: filterAuditsByPluginConfig(docCoverageConfig), + runner: createRunnerFunction(docCoverageConfig), }; } diff --git a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts index 992f6de6c..d3d178a91 100644 --- a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts @@ -12,7 +12,9 @@ vi.mock('./runner/index.ts', () => ({ describe('docCoveragePlugin', () => { it('should initialise a Documentation coverage plugin', async () => { await expect( - docCoveragePlugin({ sourceGlob: 'src/**/*.ts' }), + docCoveragePlugin({ + sourceGlob: ['src/**/*.ts', '!**/*.spec.ts', '!**/*.test.ts'], + }), ).resolves.toStrictEqual( expect.objectContaining({ slug: 'doc-coverage', @@ -25,7 +27,9 @@ describe('docCoveragePlugin', () => { it('should generate percentage coverage audit', async () => { await expect( - docCoveragePlugin({ sourceGlob: 'src/**/*.ts' }), + docCoveragePlugin({ + sourceGlob: ['src/**/*.ts', '!**/*.spec.ts', '!**/*.test.ts'], + }), ).resolves.toStrictEqual( expect.objectContaining({ audits: [ @@ -43,7 +47,9 @@ describe('docCoveragePlugin', () => { it('should include package metadata', async () => { await expect( - docCoveragePlugin({ sourceGlob: 'src/**/*.ts' }), + docCoveragePlugin({ + sourceGlob: ['src/**/*.ts', '!**/*.spec.ts', '!**/*.test.ts'], + }), ).resolves.toStrictEqual( expect.objectContaining({ icon: 'folder-src', diff --git a/packages/plugin-doc-coverage/src/lib/models.ts b/packages/plugin-doc-coverage/src/lib/models.ts index dd61e1bdc..4500a13d1 100644 --- a/packages/plugin-doc-coverage/src/lib/models.ts +++ b/packages/plugin-doc-coverage/src/lib/models.ts @@ -1,30 +1,3 @@ -export type UndocumentedItem = { - file: string; - type: string; - name: string; - line: number; - class?: string; -}; +import type { CoverageType } from './runner/models'; -export type CoverageByType = { - functions: number; - variables: number; - classes: number; - methods: number; - properties: number; - interfaces: number; - types: number; -}; - -export type CoverageKey = keyof CoverageByType; - -export type DocumentationStats = { - documented: number; - total: number; -}; - -export type CoverageResult = { - undocumentedItems: UndocumentedItem[]; - currentCoverage: number; - coverageByType: CoverageByType; -}; +export type AuditSlug = `${CoverageType}-coverage`; diff --git a/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.integration.test.ts.snap b/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.integration.test.ts.snap new file mode 100644 index 000000000..33a38bd67 --- /dev/null +++ b/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.integration.test.ts.snap @@ -0,0 +1,139 @@ +// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html + +exports[`processDocCoverage > should succesfully get the right number of ts files 1`] = ` +{ + "classes": { + "coverage": 100, + "issues": [], + "nodesCount": 1, + }, + "enums": { + "coverage": 100, + "issues": [], + "nodesCount": 0, + }, + "functions": { + "coverage": 33.333333333333336, + "issues": [ + { + "file": "/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.spec.ts", + "line": 1, + "name": "notRealisticFunction", + "type": "functions", + }, + { + "file": "/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/mocks/fixtures/angular/map-event.function.ts", + "line": 1, + "name": "mapEventToCustomEvent", + "type": "functions", + }, + ], + "nodesCount": 3, + }, + "interfaces": { + "coverage": 100, + "issues": [], + "nodesCount": 0, + }, + "methods": { + "coverage": 50, + "issues": [ + { + "file": "/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.ts", + "line": 15, + "name": "sendEvent", + "type": "methods", + }, + ], + "nodesCount": 2, + }, + "properties": { + "coverage": 0, + "issues": [ + { + "file": "/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.ts", + "line": 5, + "name": "title", + "type": "properties", + }, + ], + "nodesCount": 1, + }, + "types": { + "coverage": 100, + "issues": [], + "nodesCount": 0, + }, + "variables": { + "coverage": 100, + "issues": [], + "nodesCount": 0, + }, +} +`; + +exports[`processDocCoverage > should succesfully get the right number of ts files and not include spec files 1`] = ` +{ + "classes": { + "coverage": 100, + "issues": [], + "nodesCount": 1, + }, + "enums": { + "coverage": 100, + "issues": [], + "nodesCount": 0, + }, + "functions": { + "coverage": 50, + "issues": [ + { + "file": "/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/mocks/fixtures/angular/map-event.function.ts", + "line": 1, + "name": "mapEventToCustomEvent", + "type": "functions", + }, + ], + "nodesCount": 2, + }, + "interfaces": { + "coverage": 100, + "issues": [], + "nodesCount": 0, + }, + "methods": { + "coverage": 50, + "issues": [ + { + "file": "/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.ts", + "line": 15, + "name": "sendEvent", + "type": "methods", + }, + ], + "nodesCount": 2, + }, + "properties": { + "coverage": 0, + "issues": [ + { + "file": "/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.ts", + "line": 5, + "name": "title", + "type": "properties", + }, + ], + "nodesCount": 1, + }, + "types": { + "coverage": 100, + "issues": [], + "nodesCount": 0, + }, + "variables": { + "coverage": 100, + "issues": [], + "nodesCount": 0, + }, +} +`; diff --git a/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.unit.test.ts.snap b/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.unit.test.ts.snap new file mode 100644 index 000000000..b72b0a151 --- /dev/null +++ b/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.unit.test.ts.snap @@ -0,0 +1,92 @@ +// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html + +exports[`getUnprocessedCoverageReport > should produce a full report 1`] = ` +{ + "classes": { + "coverage": 33.333333333333336, + "issues": [ + { + "file": "test.ts", + "line": 4, + "name": "test", + "type": "classes", + }, + { + "file": "test.ts", + "line": 5, + "name": "test", + "type": "classes", + }, + ], + "nodesCount": 3, + }, + "enums": { + "coverage": 33.333333333333336, + "issues": [ + { + "file": "test.ts", + "line": 8, + "name": "test", + "type": "enums", + }, + { + "file": "test.ts", + "line": 9, + "name": "test", + "type": "enums", + }, + ], + "nodesCount": 3, + }, + "functions": { + "coverage": 100, + "issues": [], + "nodesCount": 3, + }, + "interfaces": { + "coverage": 66.66666666666667, + "issues": [ + { + "file": "test.ts", + "line": 15, + "name": "test", + "type": "interfaces", + }, + ], + "nodesCount": 3, + }, + "methods": { + "coverage": 100, + "issues": [], + "nodesCount": 0, + }, + "properties": { + "coverage": 100, + "issues": [], + "nodesCount": 0, + }, + "types": { + "coverage": 50, + "issues": [ + { + "file": "test.ts", + "line": 10, + "name": "test", + "type": "types", + }, + { + "file": "test.ts", + "line": 11, + "name": "test", + "type": "types", + }, + ], + "nodesCount": 4, + }, + "variables": { + "coverage": 100, + "issues": [], + "nodesCount": 0, + }, +} +`; diff --git a/packages/plugin-doc-coverage/src/lib/runner/constants.ts b/packages/plugin-doc-coverage/src/lib/runner/constants.ts deleted file mode 100644 index 9cf24d169..000000000 --- a/packages/plugin-doc-coverage/src/lib/runner/constants.ts +++ /dev/null @@ -1,42 +0,0 @@ -import path from 'node:path'; -import { pluginWorkDir } from '@code-pushup/utils'; - -export const WORKDIR = pluginWorkDir('doc-coverage'); - -export const RUNNER_OUTPUT_PATH = path.join(WORKDIR, 'runner-output.json'); - -export const PLUGIN_CONFIG_PATH = path.join( - process.cwd(), - WORKDIR, - 'plugin-config.json', -); - -export const enum ProgrammingLanguage { - JavaScript = 'javascript', - TypeScript = 'typescript', -} - -export const DEFAULT_SOURCE_GLOB = { - [ProgrammingLanguage.JavaScript]: '"src/**/*.js"', - [ProgrammingLanguage.TypeScript]: '"src/**/*.ts"', -}; - -export const DEFAULT_OUTPUT_FOLDER_PATH = './documentation'; - -export const COMMANDS_FOR_LANGUAGES: Readonly< - Record -> = { - [ProgrammingLanguage.JavaScript]: { - command: 'npx', - args: 'typedoc $sourceGlob --entryPointStrategy expand --plugin typedoc-plugin-coverage --coverageOutputType json --skipErrorChecking --out $outputFolderPath', - }, - [ProgrammingLanguage.TypeScript]: { - command: 'npx', - args: 'typedoc $sourceGlob --entryPointStrategy expand --plugin typedoc-plugin-coverage --coverageOutputType json --skipErrorChecking --out $outputFolderPath', - }, -} as const; - -export type TypedocResult = { - percent: number; - notDocumented: string[]; -}; diff --git a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.integration.test.ts b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.integration.test.ts index 94bebac27..51e607eb9 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.integration.test.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.integration.test.ts @@ -1,21 +1,23 @@ import { processDocCoverage } from './doc-processer'; -describe('docProcesser', () => { - it('should successfully get documentation coverage', () => { - const results = processDocCoverage( - 'packages/plugin-doc-coverage/mocks/**/*.ts', - ); - console.log(results); - expect(results).toBeDefined(); - expect(results.currentCoverage).toBe(60); - expect(results.coverageByType).toEqual({ - functions: 50, - variables: 33.33, - classes: 0, - methods: 100, - properties: 100, - interfaces: 100, - types: 100, +describe('processDocCoverage', () => { + it('should succesfully get the right number of ts files', () => { + const results = processDocCoverage({ + sourceGlob: [ + 'packages/plugin-doc-coverage/mocks/fixtures/angular/**/*.ts', + ], }); + expect(results).toMatchSnapshot(); + }); + + it('should succesfully get the right number of ts files and not include spec files', () => { + const results = processDocCoverage({ + sourceGlob: [ + 'packages/plugin-doc-coverage/mocks/fixtures/angular/**/*.ts', + '!**/*.spec.ts', + '!**/*.test.ts', + ], + }); + expect(results).toMatchSnapshot(); }); }); diff --git a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts index 46a2cbacf..fbf333bfc 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts @@ -1,289 +1,115 @@ -import { Project } from 'ts-morph'; +import { ClassDeclaration, Project, SourceFile } from 'ts-morph'; +import type { DocCoveragePluginConfig } from '../config.js'; import type { - CoverageByType, - CoverageKey, CoverageResult, - DocumentationStats, - UndocumentedItem, -} from '../models.js'; - -/* eslint-disable @typescript-eslint/no-explicit-any */ -/* eslint-disable functional/immutable-data */ -/* eslint-disable @typescript-eslint/max-params */ -/* eslint-disable functional/no-let */ + CoverageType, + UnprocessedCoverageResult, +} from './models.js'; +import { + calculateCoverage, + createEmptyUnprocessedCoverageReport, + getCoverageTypeFromKind, +} from './utils.js'; /** * Processes documentation coverage for TypeScript files in the specified path * @param toInclude - The file path pattern to include for documentation analysis * @returns {CoverageResult} Object containing coverage statistics and undocumented items */ -export function processDocCoverage(toInclude: string): CoverageResult { +export function processDocCoverage( + config: DocCoveragePluginConfig, +): CoverageResult { const project = new Project(); - project.addSourceFilesAtPaths(toInclude); - - const stats: Record = { - functions: { documented: 0, total: 0 }, - variables: { documented: 0, total: 0 }, - classes: { documented: 0, total: 0 }, - methods: { documented: 0, total: 0 }, - properties: { documented: 0, total: 0 }, - interfaces: { documented: 0, total: 0 }, - types: { documented: 0, total: 0 }, - }; - - const undocumentedItems: UndocumentedItem[] = []; - - project.getSourceFiles().forEach(sourceFile => { - if (isTestFile(sourceFile.getFilePath())) { - return; - } - - processClassDeclarations(sourceFile, undocumentedItems, stats); - processDeclarations(sourceFile, undocumentedItems, stats); - }); - - return { - undocumentedItems, - currentCoverage: calculateOverallCoverage(stats), - coverageByType: calculateCoverageByType(stats), - }; -} - -/** - * Checks if a file is a test file based on its path - * @param filePath - The path of the file to check - * @returns {boolean} True if the file is a test file, false otherwise - */ -function isTestFile(filePath: string): boolean { - return filePath.includes('.spec.') || filePath.includes('.test.'); + project.addSourceFilesAtPaths(config.sourceGlob); + return getUnprocessedCoverageReport(project.getSourceFiles()); } /** - * Creates an undocumented item entry - * @param file - The file path where the item was found - * @param type - The type of the undocumented item - * @param name - The name of the undocumented item - * @param line - The line number where the item appears - * @returns {UndocumentedItem} The undocumented item entry + * Gets the unprocessed coverage report from the source files + * @param sourceFiles - The source files to process + * @returns {UnprocessedCoverageResult} The unprocessed coverage report */ -function addUndocumentedItem( - file: string, - type: CoverageKey, - name: string, - line: number, -): UndocumentedItem { - return { file, type, name, line }; -} - -/** - * Processes class declarations in a source file and updates documentation statistics - * @param sourceFile - The source file to process - * @param undocumentedItems - Array to store undocumented items found - * @param stats - Object to track documentation statistics - */ -function processClassDeclarations( - sourceFile: any, - undocumentedItems: UndocumentedItem[], - stats: Record, -): void { - sourceFile.getClasses().forEach((classDeclaration: any) => { - const className = classDeclaration.getName() || 'Anonymous Class'; - const filePath = sourceFile.getFilePath(); - stats.classes.total++; - - if (classDeclaration.getJsDocs().length === 0) { - undocumentedItems.push( - addUndocumentedItem( - filePath, - 'classes', - className, - classDeclaration.getStartLineNumber(), - ), +export function getUnprocessedCoverageReport(sourceFiles: SourceFile[]) { + const unprocessedCoverageReport = sourceFiles.reduce( + (coverageReportOfAllFiles, sourceFile) => { + // Info of the file + const filePath = sourceFile.getFilePath(); + const classes = sourceFile.getClasses(); + + // All nodes of the file + const allNodesFromFile = [ + ...sourceFile.getFunctions(), + ...classes, + ...getClassNodes(classes), + ...sourceFile.getTypeAliases(), + ...sourceFile.getEnums(), + ...sourceFile.getInterfaces(), + // ...sourceFile.getVariableStatements().flatMap(statement => statement.getDeclarations()) + ]; + + const coverageReportOfCurrentFile = allNodesFromFile.reduce( + (acc, node) => { + const nodeType = getCoverageTypeFromKind(node.getKind()); + acc[nodeType].nodesCount++; + if (node.getJsDocs().length === 0) { + acc[nodeType].issues.push({ + file: filePath, + type: nodeType, + name: node.getName() || '', + line: node.getStartLineNumber(), + }); + } + return acc; + }, + createEmptyUnprocessedCoverageReport(), ); - } else { - stats.classes.documented++; - } - // Process properties - classDeclaration.getProperties().forEach((property: any) => { - stats.properties.total++; - if (property.getJsDocs().length === 0) { - undocumentedItems.push( - addUndocumentedItem( - filePath, - 'properties', - property.getName(), - property.getStartLineNumber(), - ), - ); - } else { - stats.properties.documented++; - } - }); - - // Process methods - classDeclaration.getMethods().forEach((method: any) => { - stats.methods.total++; - if (method.getJsDocs().length === 0) { - undocumentedItems.push( - addUndocumentedItem( - filePath, - 'methods', - method.getName(), - method.getStartLineNumber(), - ), - ); - } else { - stats.methods.documented++; - } - }); - }); -} - -/** - * Processes declarations (functions, variables, interfaces, and types) in a source file - * @param sourceFile - The source file to process - * @param undocumentedItems - Array to store undocumented items found - * @param stats - Object to track documentation statistics - */ -function processDeclarations( - sourceFile: any, - undocumentedItems: UndocumentedItem[], - stats: Record, -): void { - const filePath = sourceFile.getFilePath(); - - // Process functions - processItems( - sourceFile.getFunctions(), - 'functions', - item => item.getName() || 'Anonymous Function', - filePath, - undocumentedItems, - stats, + return mergeCoverageResults( + coverageReportOfAllFiles, + coverageReportOfCurrentFile, + ); + }, + createEmptyUnprocessedCoverageReport(), ); - // Process variables - sourceFile.getVariableStatements().forEach((statement: any) => { - statement.getDeclarations().forEach((declaration: any) => { - stats.variables.total++; - if (statement.getJsDocs().length === 0) { - undocumentedItems.push( - addUndocumentedItem( - filePath, - 'variables', - declaration.getName(), - declaration.getStartLineNumber(), - ), - ); - } else { - stats.variables.documented++; - } - }); - }); - - // Process interfaces and types - processItems( - sourceFile.getInterfaces(), - 'interfaces', - item => item.getName(), - filePath, - undocumentedItems, - stats, - ); - processItems( - sourceFile.getTypeAliases(), - 'types', - item => item.getName(), - filePath, - undocumentedItems, - stats, - ); + return calculateCoverage(unprocessedCoverageReport); } /** - * Generic function to process a collection of items and update documentation statistics - * @param items - Array of items to process - * @param type - The type of items being processed - * @param getName - Function to extract the name from an item - * @param filePath - The path of the file being processed - * @param undocumentedItems - Array to store undocumented items found - * @param stats - Object to track documentation statistics + * Merges two coverage results + * @param results - The first empty coverage result + * @param current - The second coverage result + * @returns {UnprocessedCoverageResult} The merged coverage result */ -function processItems( - items: any[], - type: CoverageKey, - getName: (item: any) => string, - filePath: string, - undocumentedItems: UndocumentedItem[], - stats: Record, -): void { - items.forEach(item => { - stats[type].total++; - if (item.getJsDocs().length === 0) { - undocumentedItems.push( - addUndocumentedItem( - filePath, +export function mergeCoverageResults( + results: UnprocessedCoverageResult, + current: Partial, +) { + return { + ...Object.fromEntries( + Object.entries(results).map(([key, value]) => { + const node = value as CoverageResult[CoverageType]; + const type = key as CoverageType; + return [ type, - getName(item), - item.getStartLineNumber(), - ), - ); - } else { - stats[type].documented++; - } - }); -} - -/** - * Calculates the overall documentation coverage percentage - * @param stats - Object containing documentation statistics - * @returns {number} The overall coverage percentage (0-100) - */ -function calculateOverallCoverage( - stats: Record, -): number { - let totalDocumented = 0; - let totalItems = 0; - - Object.values(stats).forEach(({ documented, total }) => { - totalDocumented += documented; - totalItems += total; - }); - - return totalItems === 0 ? 0 : (totalDocumented / totalItems) * 100; + { + nodesCount: node.nodesCount + (current[type]?.nodesCount ?? 0), + issues: [...node.issues, ...(current[type]?.issues ?? [])], + }, + ]; + }), + ), + } as UnprocessedCoverageResult; } /** - * Calculates documentation coverage percentage for each type - * @param stats - Object containing documentation statistics - * @returns {CoverageByType} Object containing coverage percentages for each type + * Gets the nodes from a class + * @param classNodes - The class nodes to process + * @returns {Node[]} The nodes from the class */ -function calculateCoverageByType( - stats: Record, -): CoverageByType { - const calculatePercentage = (documented: number, total: number) => - total === 0 ? 0 : Number(((documented / total) * 100).toFixed(2)); - - return { - functions: calculatePercentage( - stats.functions.documented, - stats.functions.total, - ), - variables: calculatePercentage( - stats.variables.documented, - stats.variables.total, - ), - classes: calculatePercentage(stats.classes.documented, stats.classes.total), - methods: calculatePercentage(stats.methods.documented, stats.methods.total), - properties: calculatePercentage( - stats.properties.documented, - stats.properties.total, - ), - interfaces: calculatePercentage( - stats.interfaces.documented, - stats.interfaces.total, - ), - types: calculatePercentage(stats.types.documented, stats.types.total), - }; +export function getClassNodes(classNodes: ClassDeclaration[]) { + return classNodes.flatMap(classNode => [ + ...classNode.getMethods(), + ...classNode.getProperties(), + ]); } diff --git a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts new file mode 100644 index 000000000..21c829349 --- /dev/null +++ b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts @@ -0,0 +1,198 @@ +import type { ClassDeclaration } from 'ts-morph'; +import { nodeMock, sourceFileMock } from './../../../mocks/source-files.mock'; +import { + getClassNodes, + getUnprocessedCoverageReport, + mergeCoverageResults, +} from './doc-processer'; +import type { UnprocessedCoverageResult } from './models'; + +describe('getUnprocessedCoverageReport', () => { + it('should produce a full report', () => { + const results = getUnprocessedCoverageReport([ + sourceFileMock('test.ts', { + functions: { 1: true, 2: true, 3: true }, + classes: { 4: false, 5: false, 6: true }, + enums: { 7: true, 8: false, 9: false }, + types: { 10: false, 11: false, 12: true, 40: true }, + interfaces: { 13: true, 14: true, 15: false }, + properties: { 16: false, 17: false, 18: false }, + variables: { 22: true, 23: true, 24: true }, + }), + ]); + expect(results).toMatchSnapshot(); + }); + + it('should accept array of source files', () => { + const results = getUnprocessedCoverageReport([ + sourceFileMock('test.ts', { functions: { 1: true, 2: true, 3: false } }), + ]); + expect(results).toBeDefined(); + }); + + it('should count nodes correctly', () => { + const results = getUnprocessedCoverageReport([ + sourceFileMock('test.ts', { functions: { 1: true, 2: true, 3: false } }), + ]); + + expect(results.functions.nodesCount).toBe(3); + }); + + it('should collect uncommented nodes issues', () => { + const results = getUnprocessedCoverageReport([ + sourceFileMock('test.ts', { functions: { 1: true, 2: false, 3: false } }), + ]); + + expect(results.functions.issues.length).toBe(2); + }); + + it('should collect valid issues', () => { + const results = getUnprocessedCoverageReport([ + sourceFileMock('test.ts', { functions: { 1: false } }), + ]); + + expect(results.functions.issues).toStrictEqual([ + { + line: 1, + file: 'test.ts', + type: 'functions', + name: 'test', + }, + ]); + }); + + it('should calculate coverage correctly', () => { + const results = getUnprocessedCoverageReport([ + sourceFileMock('test.ts', { functions: { 1: true, 2: false } }), + ]); + + expect(results.functions.coverage).toBe(50); + }); +}); + +describe('mergeCoverageResults', () => { + const emptyResult: UnprocessedCoverageResult = { + enums: { nodesCount: 0, issues: [] }, + interfaces: { nodesCount: 0, issues: [] }, + types: { nodesCount: 0, issues: [] }, + functions: { nodesCount: 0, issues: [] }, + variables: { nodesCount: 0, issues: [] }, + classes: { nodesCount: 0, issues: [] }, + methods: { nodesCount: 0, issues: [] }, + properties: { nodesCount: 0, issues: [] }, + }; + + it.each([ + 'enums', + 'interfaces', + 'types', + 'functions', + 'variables', + 'classes', + 'methods', + 'properties', + ])('should merge results on top-level property: %s', type => { + const secondResult = { + [type]: { + nodesCount: 1, + issues: [{ file: 'test2.ts', line: 1, name: 'test2', type }], + }, + }; + + const results = mergeCoverageResults( + emptyResult, + secondResult as Partial, + ); + expect(results).toStrictEqual( + expect.objectContaining({ + [type]: { + nodesCount: 1, + issues: [{ file: 'test2.ts', line: 1, name: 'test2', type }], + }, + }), + ); + }); + + it('should merge empty results', () => { + const results = mergeCoverageResults(emptyResult, emptyResult); + expect(results).toStrictEqual(emptyResult); + }); + + it('should merge second level property nodesCount', () => { + const results = mergeCoverageResults( + { + ...emptyResult, + enums: { nodesCount: 1, issues: [] }, + }, + { + enums: { nodesCount: 1, issues: [] }, + }, + ); + expect(results.enums.nodesCount).toBe(2); + }); + + it('should merge second level property issues', () => { + const results = mergeCoverageResults( + { + ...emptyResult, + enums: { + nodesCount: 0, + issues: [ + { + file: 'file.enum-first.ts', + line: 6, + name: 'file.enum-first', + type: 'enums', + }, + ], + }, + }, + { + enums: { + nodesCount: 0, + issues: [ + { + file: 'file.enum-second.ts', + line: 5, + name: 'file.enum-second', + type: 'enums', + }, + ], + }, + }, + ); + expect(results.enums.issues).toStrictEqual([ + { + file: 'file.enum-first.ts', + line: 6, + name: 'file.enum-first', + type: 'enums', + }, + { + file: 'file.enum-second.ts', + line: 5, + name: 'file.enum-second', + type: 'enums', + }, + ]); + }); +}); + +describe('getClassNodes', () => { + it('should return all nodes from a class', () => { + const nodeMock1 = nodeMock({ + coverageType: 'classes', + line: 1, + file: 'test.ts', + isCommented: false, + }); + + const classNodeSpy = vi.spyOn(nodeMock1, 'getMethods'); + const propertyNodeSpy = vi.spyOn(nodeMock1, 'getProperties'); + + getClassNodes([nodeMock1] as unknown as ClassDeclaration[]); + + expect(classNodeSpy).toHaveBeenCalledTimes(1); + expect(propertyNodeSpy).toHaveBeenCalledTimes(1); + }); +}); diff --git a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts.snap b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts.snap new file mode 100644 index 000000000..220467a98 --- /dev/null +++ b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts.snap @@ -0,0 +1,125 @@ +{ + "classes": { + "coverage": 0, + "issues": [ + { + "file": "test.ts", + "line": 4, + "name": "test", + "type": "classes", + }, + { + "file": "test.ts", + "line": 5, + "name": "test", + "type": "classes", + }, + { + "file": "test.ts", + "line": 6, + "name": "test", + "type": "classes", + }, + ], + "nodesCount": 3, + }, + "enums": { + "coverage": 0, + "issues": [ + { + "file": "test.ts", + "line": 7, + "name": "test", + "type": "enums", + }, + { + "file": "test.ts", + "line": 8, + "name": "test", + "type": "enums", + }, + { + "file": "test.ts", + "line": 9, + "name": "test", + "type": "enums", + }, + ], + "nodesCount": 3, + }, + "functions": { + "coverage": 66.66666666666667, + "issues": [ + { + "file": "test.ts", + "line": 3, + "name": "test", + "type": "functions", + }, + ], + "nodesCount": 3, + }, + "interfaces": { + "coverage": 0, + "issues": [ + { + "file": "test.ts", + "line": 13, + "name": "test", + "type": "interfaces", + }, + { + "file": "test.ts", + "line": 14, + "name": "test", + "type": "interfaces", + }, + { + "file": "test.ts", + "line": 15, + "name": "test", + "type": "interfaces", + }, + ], + "nodesCount": 3, + }, + "methods": { + "coverage": 100, + "issues": [], + "nodesCount": 0, + }, + "properties": { + "coverage": 100, + "issues": [], + "nodesCount": 0, + }, + "types": { + "coverage": 0, + "issues": [ + { + "file": "test.ts", + "line": 10, + "name": "test", + "type": "types", + }, + { + "file": "test.ts", + "line": 11, + "name": "test", + "type": "types", + }, + { + "file": "test.ts", + "line": 12, + "name": "test", + "type": "types", + }, + ], + "nodesCount": 3, + }, + "variables": { + "coverage": 100, + "issues": [], + "nodesCount": 0, + }, +} \ No newline at end of file diff --git a/packages/plugin-doc-coverage/src/lib/runner/index.ts b/packages/plugin-doc-coverage/src/lib/runner/index.ts deleted file mode 100644 index c56713ada..000000000 --- a/packages/plugin-doc-coverage/src/lib/runner/index.ts +++ /dev/null @@ -1,78 +0,0 @@ -import { bold } from 'ansis'; -import { writeFile } from 'node:fs/promises'; -import path from 'node:path'; -import type { AuditOutput, RunnerConfig } from '@code-pushup/models'; -import { - ProcessError, - ensureDirectoryExists, - filePathToCliArg, - readJsonFile, - ui, -} from '@code-pushup/utils'; -import type { DocCoveragePluginConfig } from '../config.js'; -import type { CoverageResult } from '../models.js'; -import { PLUGIN_CONFIG_PATH, RUNNER_OUTPUT_PATH } from './constants.js'; -import { processDocCoverage } from './doc-processer.js'; - -export { PLUGIN_CONFIG_PATH, RUNNER_OUTPUT_PATH } from './constants.js'; - -export async function executeRunner(): Promise { - try { - const config = - await readJsonFile(PLUGIN_CONFIG_PATH); - console.log(config.sourceGlob, 'dadawdawd'); - const processResult = processDocCoverage(config.sourceGlob); - await _createFinalReport(processResult); - } catch (error) { - if (error instanceof ProcessError) { - ui().logger.error(bold('stdout from failed Typedoc process:')); - ui().logger.error(error.stdout); - ui().logger.error(bold('stderr from failed Typedoc process:')); - ui().logger.error(error.stderr); - } - throw new Error( - 'Doc Coverage plugin: Running Typedoc failed. Please check the error above.', - ); - } -} - -export async function createRunnerConfig( - scriptPath: string, - config: DocCoveragePluginConfig, -): Promise { - await ensureDirectoryExists(path.dirname(PLUGIN_CONFIG_PATH)); - await writeFile(PLUGIN_CONFIG_PATH, JSON.stringify(config)); - - return { - command: 'node', - args: [filePathToCliArg(scriptPath)], - outputFile: RUNNER_OUTPUT_PATH, - }; -} - -/** - * Create the final report. - * @param coverageResult - The coverage result. - */ -async function _createFinalReport( - coverageResult: CoverageResult, -): Promise { - const auditOutputs: AuditOutput[] = [ - { - slug: 'percentage-coverage', - value: coverageResult.currentCoverage, - score: coverageResult.currentCoverage / 100, - displayValue: `${coverageResult.currentCoverage} %`, - details: { - issues: coverageResult.undocumentedItems.map(item => ({ - message: `Missing documentation for a ${item.type}`, - source: { file: item.file, position: { startLine: item.line } }, - severity: 'warning', - })), - }, - }, - ]; - - await ensureDirectoryExists(path.dirname(RUNNER_OUTPUT_PATH)); - await writeFile(RUNNER_OUTPUT_PATH, JSON.stringify(auditOutputs)); -} diff --git a/packages/plugin-doc-coverage/src/lib/runner/models.ts b/packages/plugin-doc-coverage/src/lib/runner/models.ts new file mode 100644 index 000000000..81849c428 --- /dev/null +++ b/packages/plugin-doc-coverage/src/lib/runner/models.ts @@ -0,0 +1,37 @@ +import type { SyntaxKind } from 'ts-morph'; + +type SyntaxKindToStringLiteral = { + [SyntaxKind.ClassDeclaration]: 'classes'; + [SyntaxKind.MethodDeclaration]: 'methods'; + [SyntaxKind.FunctionDeclaration]: 'functions'; + [SyntaxKind.InterfaceDeclaration]: 'interfaces'; + [SyntaxKind.EnumDeclaration]: 'enums'; + [SyntaxKind.VariableDeclaration]: 'variables'; + [SyntaxKind.PropertyDeclaration]: 'properties'; + [SyntaxKind.TypeAliasDeclaration]: 'types'; +}; + +export type CoverageType = + SyntaxKindToStringLiteral[keyof SyntaxKindToStringLiteral]; + +export type UndocumentedNode = { + file: string; + type: CoverageType; + name: string; + line: number; + class?: string; +}; + +export type CoverageData = { + issues: UndocumentedNode[]; + nodesCount: number; +}; + +export type UnprocessedCoverageResult = Record; + +export type CoverageResult = Record< + CoverageType, + CoverageData & { + coverage: number; + } +>; diff --git a/packages/plugin-doc-coverage/src/lib/runner/runner.integration.test.ts b/packages/plugin-doc-coverage/src/lib/runner/runner.integration.test.ts deleted file mode 100644 index 8d8fe081a..000000000 --- a/packages/plugin-doc-coverage/src/lib/runner/runner.integration.test.ts +++ /dev/null @@ -1,58 +0,0 @@ -import { writeFile } from 'node:fs/promises'; -import { describe, it } from 'vitest'; -import type { AuditOutputs, RunnerConfig } from '@code-pushup/models'; -import { readJsonFile, removeDirectoryIfExists } from '@code-pushup/utils'; -import type { DocCoveragePluginConfig } from '../config.js'; -import { - PLUGIN_CONFIG_PATH, - RUNNER_OUTPUT_PATH, - WORKDIR, -} from './constants.js'; -import { createRunnerConfig, executeRunner } from './index.js'; - -describe('createRunnerConfig', () => { - it('should create a valid runner config', async () => { - const runnerConfig = await createRunnerConfig('executeRunner.ts', { - sourceGlob: 'src/**/*.ts', - }); - expect(runnerConfig).toStrictEqual({ - command: 'node', - args: ['"executeRunner.ts"'], - outputFile: expect.stringContaining('runner-output.json'), - }); - }); - - it('should provide plugin config to runner in JSON file', async () => { - await removeDirectoryIfExists(WORKDIR); - - const pluginConfig: DocCoveragePluginConfig = { - sourceGlob: 'src/**/*.ts', - }; - - await createRunnerConfig('executeRunner.ts', pluginConfig); - - const config = - await readJsonFile(PLUGIN_CONFIG_PATH); - expect(config).toStrictEqual(pluginConfig); - }); -}); - -describe('executeRunner', () => { - it( - 'should successfully execute runner', - { - timeout: 60 * 1000, - }, - async () => { - const config: DocCoveragePluginConfig = { - sourceGlob: 'packages/plugin-doc-coverage/mocks/*.ts', - }; - - await writeFile(PLUGIN_CONFIG_PATH, JSON.stringify(config)); - await executeRunner(); - - const results = await readJsonFile(RUNNER_OUTPUT_PATH); - expect(results).toBeDefined(); - }, - ); -}); diff --git a/packages/plugin-doc-coverage/src/lib/runner/runner.ts b/packages/plugin-doc-coverage/src/lib/runner/runner.ts new file mode 100644 index 000000000..91e8282e1 --- /dev/null +++ b/packages/plugin-doc-coverage/src/lib/runner/runner.ts @@ -0,0 +1,49 @@ +import type { AuditOutputs, RunnerFunction } from '@code-pushup/models'; +import type { DocCoveragePluginConfig } from '../config'; +import { processDocCoverage } from './doc-processer'; +import type { CoverageResult, CoverageType } from './models'; + +export function createRunnerFunction( + config: DocCoveragePluginConfig, +): RunnerFunction { + return (): AuditOutputs => { + const coverageResult = processDocCoverage(config); + return trasformCoverageReportToAudits(coverageResult, config); + }; +} + +/** + * Transforms the coverage report into audit outputs. + * @param coverageResult - The coverage result containing undocumented items and coverage statistics + * @param options - Configuration options specifying which audits to include + * @returns Audit outputs with coverage scores and details about undocumented items + */ +export function trasformCoverageReportToAudits( + coverageResult: CoverageResult, + options: Pick, +): AuditOutputs { + return Object.entries(coverageResult) + .filter( + ([type]) => + !options.onlyAudits?.length || + options.onlyAudits.includes(`${type}-coverage`), + ) + .map(([type, items]) => { + const coverageType = type as CoverageType; + const coverage = items.coverage; + + return { + slug: `${coverageType}-coverage`, + value: coverage, + score: coverage / 100, + displayValue: `${coverage} %`, + details: { + issues: items.issues.map(({ file, line }) => ({ + message: 'Missing documentation', + source: { file, position: { startLine: line } }, + severity: 'warning', + })), + }, + }; + }); +} diff --git a/packages/plugin-doc-coverage/src/lib/runner/utils.ts b/packages/plugin-doc-coverage/src/lib/runner/utils.ts new file mode 100644 index 000000000..434187a00 --- /dev/null +++ b/packages/plugin-doc-coverage/src/lib/runner/utils.ts @@ -0,0 +1,61 @@ +import { SyntaxKind } from 'ts-morph'; +import type { + CoverageResult, + CoverageType, + UnprocessedCoverageResult, +} from './models'; + +export function createEmptyUnprocessedCoverageReport(): UnprocessedCoverageResult { + return { + enums: { nodesCount: 0, issues: [] }, + interfaces: { nodesCount: 0, issues: [] }, + types: { nodesCount: 0, issues: [] }, + functions: { nodesCount: 0, issues: [] }, + variables: { nodesCount: 0, issues: [] }, + classes: { nodesCount: 0, issues: [] }, + methods: { nodesCount: 0, issues: [] }, + properties: { nodesCount: 0, issues: [] }, + }; +} + +export function calculateCoverage(result: UnprocessedCoverageResult) { + return Object.fromEntries( + Object.entries(result).map(([key, value]) => { + const type = key as CoverageType; + return [ + type, + { + coverage: + value.nodesCount === 0 + ? 100 + : (1 - value.issues.length / value.nodesCount) * 100, + issues: value.issues, + nodesCount: value.nodesCount, + }, + ]; + }), + ) as CoverageResult; +} + +export function getCoverageTypeFromKind(kind: SyntaxKind): CoverageType { + switch (kind) { + case SyntaxKind.ClassDeclaration: + return 'classes'; + case SyntaxKind.MethodDeclaration: + return 'methods'; + case SyntaxKind.FunctionDeclaration: + return 'functions'; + case SyntaxKind.InterfaceDeclaration: + return 'interfaces'; + case SyntaxKind.EnumDeclaration: + return 'enums'; + case SyntaxKind.VariableDeclaration: + return 'variables'; + case SyntaxKind.PropertyDeclaration: + return 'properties'; + case SyntaxKind.TypeAliasDeclaration: + return 'types'; + default: + throw new Error(`Unsupported syntax kind: ${kind}`); + } +} diff --git a/packages/plugin-doc-coverage/src/lib/utils.ts b/packages/plugin-doc-coverage/src/lib/utils.ts new file mode 100644 index 000000000..b3e7584cb --- /dev/null +++ b/packages/plugin-doc-coverage/src/lib/utils.ts @@ -0,0 +1,46 @@ +import type { Audit, Group } from '@code-pushup/models'; +import type { DocCoveragePluginConfig } from './config'; +import { AUDITS_MAP } from './constants'; + +/** + * Get audits based on the configuration. + * If no audits are specified, return all audits. + * If audits are specified, return only the specified audits. + * @param config - The configuration object. + * @returns The audits. + */ +export function filterAuditsByPluginConfig( + config: Pick, +): Audit[] { + const { onlyAudits } = config; + + if (!onlyAudits || onlyAudits.length === 0) { + return Object.values(AUDITS_MAP); + } + + return Object.values(AUDITS_MAP).filter(audit => + onlyAudits.includes(audit.slug), + ); +} + +/** + * Filter groups by the audits that are specified in the configuration. + * The groups refs are filtered to only include the audits that are specified in the configuration. + * @param groups - The groups to filter. + * @param options - The configuration object. + * @returns The filtered groups. + */ +export function filterGroupsByOnlyAudits( + groups: Group[], + options: Pick, +): Group[] { + const audits = filterAuditsByPluginConfig(options); + return groups + .map(group => ({ + ...group, + refs: group.refs.filter(ref => + audits.some(audit => audit.slug === ref.slug), + ), + })) + .filter(group => group.refs.length > 0); +} diff --git a/packages/plugin-doc-coverage/tsconfig.test.json b/packages/plugin-doc-coverage/tsconfig.test.json index 05637ee6e..9f29d6bb0 100644 --- a/packages/plugin-doc-coverage/tsconfig.test.json +++ b/packages/plugin-doc-coverage/tsconfig.test.json @@ -8,7 +8,6 @@ "vite.config.unit.ts", "vite.config.integration.ts", "mocks/**/*.ts", - "src/**/*.test.ts", - "mocks/component-mock.ts" + "src/**/*.test.ts" ] } From 40c8daa41852741d53b5c66b6f2ed5ded0fbc5d3 Mon Sep 17 00:00:00 2001 From: Alejandro Date: Fri, 20 Dec 2024 18:43:20 +0100 Subject: [PATCH 06/39] test(plugin-doc-coverage): finish remaining tests, add format to coverage --- .../src/lib/config.unit.test.ts | 81 +++++++++++++++--- .../src/lib/doc-coverage-plugin.ts | 6 +- .../src/lib/doc-coverage-plugin.unit.test.ts | 54 +++--------- .../doc-processer.integration.test.ts.snap | 2 +- .../doc-processer.unit.test.ts.snap | 6 +- .../src/lib/runner/utils.ts | 6 +- .../src/lib/runner/utils.unit.test.ts | 85 +++++++++++++++++++ .../src/lib/utils.unit.test.ts | 79 +++++++++++++++++ 8 files changed, 259 insertions(+), 60 deletions(-) create mode 100644 packages/plugin-doc-coverage/src/lib/runner/utils.unit.test.ts create mode 100644 packages/plugin-doc-coverage/src/lib/utils.unit.test.ts diff --git a/packages/plugin-doc-coverage/src/lib/config.unit.test.ts b/packages/plugin-doc-coverage/src/lib/config.unit.test.ts index 63d0007b9..66f33ab52 100644 --- a/packages/plugin-doc-coverage/src/lib/config.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/config.unit.test.ts @@ -5,23 +5,80 @@ import { } from './config.js'; describe('docCoveragePluginConfigSchema', () => { - it('accepts a valid source glob pattern', () => { - expect(() => - docCoveragePluginConfigSchema.parse({ - sourceGlob: ['src/**/*.{ts,tsx}', '!**/*.spec.ts', '!**/*.test.ts'], - } satisfies DocCoveragePluginConfig), - ).not.toThrow(); + describe('sourceGlob', () => { + it('accepts a valid source glob pattern', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + sourceGlob: ['src/**/*.{ts,tsx}', '!**/*.spec.ts', '!**/*.test.ts'], + } satisfies DocCoveragePluginConfig), + ).not.toThrow(); + }); + + it('uses default value for missing sourceGlob', () => { + const result = docCoveragePluginConfigSchema.parse({}); + expect(result.sourceGlob).toEqual([ + 'src/**/*.{ts,tsx}', + '!**/*.spec.ts', + '!**/*.test.ts', + ]); + }); + + it('throws for invalid sourceGlob type', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + sourceGlob: 123, + }), + ).toThrow('Expected array'); + }); }); - it('not throws for missing sourceGlob', () => { - expect(() => docCoveragePluginConfigSchema.parse({})).not.toThrow(); + describe('onlyAudits', () => { + it('accepts valid audit slugs array', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + onlyAudits: ['functions-coverage', 'classes-coverage'], + sourceGlob: ['src/**/*.ts'], + }), + ).not.toThrow(); + }); + + it('accepts empty array for onlyAudits', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + onlyAudits: [], + sourceGlob: ['src/**/*.ts'], + }), + ).not.toThrow(); + }); + + it('allows onlyAudits to be undefined', () => { + const result = docCoveragePluginConfigSchema.parse({}); + expect(result.onlyAudits).toBeUndefined(); + }); + + it('throws for invalid onlyAudits type', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + onlyAudits: 'functions-coverage', + }), + ).toThrow('Expected array'); + }); + + it('throws for array with non-string elements', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + onlyAudits: [123, true], + }), + ).toThrow('Expected string'); + }); }); - it('throws for invalid sourceGlob type', () => { + it('accepts a complete valid configuration', () => { expect(() => docCoveragePluginConfigSchema.parse({ - sourceGlob: 123, - }), - ).toThrow('Expected string'); + sourceGlob: ['src/**/*.ts'], + onlyAudits: ['functions-coverage'], + } satisfies DocCoveragePluginConfig), + ).not.toThrow(); }); }); diff --git a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts index 371409e1b..9d08784b1 100644 --- a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts +++ b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts @@ -10,12 +10,12 @@ import { filterGroupsByOnlyAudits, } from './utils.js'; -const PLUGIN_TITLE = 'Documentation coverage'; +export const PLUGIN_TITLE = 'Documentation coverage'; -const PLUGIN_DESCRIPTION = +export const PLUGIN_DESCRIPTION = 'Official Code PushUp documentation coverage plugin.'; -const PLUGIN_DOCS_URL = +export const PLUGIN_DOCS_URL = 'https://www.npmjs.com/package/@code-pushup/doc-coverage-plugin/'; /** diff --git a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts index d3d178a91..fea278277 100644 --- a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts @@ -1,6 +1,12 @@ import { describe, expect, it } from 'vitest'; import type { RunnerConfig } from '@code-pushup/models'; -import { docCoveragePlugin } from './doc-coverage-plugin.js'; +import { PLUGIN_SLUG } from './constants.js'; +import { + PLUGIN_DESCRIPTION, + PLUGIN_DOCS_URL, + PLUGIN_TITLE, + docCoveragePlugin, +} from './doc-coverage-plugin.js'; vi.mock('./runner/index.ts', () => ({ createRunnerConfig: vi.fn().mockReturnValue({ @@ -17,46 +23,14 @@ describe('docCoveragePlugin', () => { }), ).resolves.toStrictEqual( expect.objectContaining({ - slug: 'doc-coverage', - title: 'Documentation coverage', - audits: expect.any(Array), - runner: expect.any(Object), - }), - ); - }); - - it('should generate percentage coverage audit', async () => { - await expect( - docCoveragePlugin({ - sourceGlob: ['src/**/*.ts', '!**/*.spec.ts', '!**/*.test.ts'], - }), - ).resolves.toStrictEqual( - expect.objectContaining({ - audits: [ - { - slug: 'percentage-coverage', - title: 'Percentage of codebase with documentation', - description: expect.stringContaining( - 'how many % of the codebase have documentation', - ), - }, - ], - }), - ); - }); - - it('should include package metadata', async () => { - await expect( - docCoveragePlugin({ - sourceGlob: ['src/**/*.ts', '!**/*.spec.ts', '!**/*.test.ts'], - }), - ).resolves.toStrictEqual( - expect.objectContaining({ + slug: PLUGIN_SLUG, + title: PLUGIN_TITLE, icon: 'folder-src', - description: expect.stringContaining('documentation coverage plugin'), - docsUrl: expect.stringContaining('npmjs.com'), - packageName: expect.any(String), - version: expect.any(String), + description: PLUGIN_DESCRIPTION, + docsUrl: PLUGIN_DOCS_URL, + groups: expect.any(Array), + audits: expect.any(Array), + runner: expect.any(Function), }), ); }); diff --git a/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.integration.test.ts.snap b/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.integration.test.ts.snap index 33a38bd67..2507460f6 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.integration.test.ts.snap +++ b/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.integration.test.ts.snap @@ -13,7 +13,7 @@ exports[`processDocCoverage > should succesfully get the right number of ts file "nodesCount": 0, }, "functions": { - "coverage": 33.333333333333336, + "coverage": 33.33, "issues": [ { "file": "/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.spec.ts", diff --git a/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.unit.test.ts.snap b/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.unit.test.ts.snap index b72b0a151..1090891fe 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.unit.test.ts.snap +++ b/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.unit.test.ts.snap @@ -3,7 +3,7 @@ exports[`getUnprocessedCoverageReport > should produce a full report 1`] = ` { "classes": { - "coverage": 33.333333333333336, + "coverage": 33.33, "issues": [ { "file": "test.ts", @@ -21,7 +21,7 @@ exports[`getUnprocessedCoverageReport > should produce a full report 1`] = ` "nodesCount": 3, }, "enums": { - "coverage": 33.333333333333336, + "coverage": 33.33, "issues": [ { "file": "test.ts", @@ -44,7 +44,7 @@ exports[`getUnprocessedCoverageReport > should produce a full report 1`] = ` "nodesCount": 3, }, "interfaces": { - "coverage": 66.66666666666667, + "coverage": 66.67, "issues": [ { "file": "test.ts", diff --git a/packages/plugin-doc-coverage/src/lib/runner/utils.ts b/packages/plugin-doc-coverage/src/lib/runner/utils.ts index 434187a00..e9628eac6 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/utils.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/utils.ts @@ -28,7 +28,11 @@ export function calculateCoverage(result: UnprocessedCoverageResult) { coverage: value.nodesCount === 0 ? 100 - : (1 - value.issues.length / value.nodesCount) * 100, + : Number( + ((1 - value.issues.length / value.nodesCount) * 100).toFixed( + 2, + ), + ), issues: value.issues, nodesCount: value.nodesCount, }, diff --git a/packages/plugin-doc-coverage/src/lib/runner/utils.unit.test.ts b/packages/plugin-doc-coverage/src/lib/runner/utils.unit.test.ts new file mode 100644 index 000000000..403c7b3ad --- /dev/null +++ b/packages/plugin-doc-coverage/src/lib/runner/utils.unit.test.ts @@ -0,0 +1,85 @@ +import { SyntaxKind } from 'ts-morph'; +import type { UnprocessedCoverageResult } from './models'; +import { + calculateCoverage, + createEmptyUnprocessedCoverageReport, + getCoverageTypeFromKind, +} from './utils'; + +describe('createEmptyUnprocessedCoverageReport', () => { + it('should create an empty report with all categories initialized', () => { + const result = createEmptyUnprocessedCoverageReport(); + + expect(result).toStrictEqual({ + enums: { nodesCount: 0, issues: [] }, + interfaces: { nodesCount: 0, issues: [] }, + types: { nodesCount: 0, issues: [] }, + functions: { nodesCount: 0, issues: [] }, + variables: { nodesCount: 0, issues: [] }, + classes: { nodesCount: 0, issues: [] }, + methods: { nodesCount: 0, issues: [] }, + properties: { nodesCount: 0, issues: [] }, + }); + }); +}); + +describe('calculateCoverage', () => { + it('should calculate 100% coverage when there are no nodes', () => { + const input: UnprocessedCoverageResult = + createEmptyUnprocessedCoverageReport(); + const result = calculateCoverage(input); + + Object.values(result).forEach(category => { + expect(category.coverage).toBe(100); + expect(category.nodesCount).toBe(0); + expect(category.issues).toEqual([]); + }); + }); + + it('should calculate correct coverage percentage with issues', () => { + const input: UnprocessedCoverageResult = { + ...createEmptyUnprocessedCoverageReport(), + functions: { + nodesCount: 4, + issues: [ + { type: 'functions', line: 1, file: 'test.ts', name: 'fn1' }, + { type: 'functions', line: 2, file: 'test.ts', name: 'fn2' }, + ], + }, + classes: { + nodesCount: 4, + issues: [ + { type: 'classes', line: 1, file: 'test.ts', name: 'Class1' }, + { type: 'classes', line: 2, file: 'test.ts', name: 'Class2' }, + { type: 'classes', line: 3, file: 'test.ts', name: 'Class3' }, + ], + }, + }; + + const result = calculateCoverage(input); + + expect(result.functions.coverage).toBe(50); + expect(result.classes.coverage).toBe(25); + }); +}); + +describe('getCoverageTypeFromKind', () => { + it.each([ + [SyntaxKind.ClassDeclaration, 'classes'], + [SyntaxKind.MethodDeclaration, 'methods'], + [SyntaxKind.FunctionDeclaration, 'functions'], + [SyntaxKind.InterfaceDeclaration, 'interfaces'], + [SyntaxKind.EnumDeclaration, 'enums'], + [SyntaxKind.VariableDeclaration, 'variables'], + [SyntaxKind.PropertyDeclaration, 'properties'], + [SyntaxKind.TypeAliasDeclaration, 'types'], + ])('should return %s for SyntaxKind.%s', (kind, expectedType) => { + expect(getCoverageTypeFromKind(kind)).toBe(expectedType); + }); + + it('should throw error for unsupported syntax kind', () => { + expect(() => getCoverageTypeFromKind(SyntaxKind.Unknown)).toThrow( + 'Unsupported syntax kind', + ); + }); +}); diff --git a/packages/plugin-doc-coverage/src/lib/utils.unit.test.ts b/packages/plugin-doc-coverage/src/lib/utils.unit.test.ts new file mode 100644 index 000000000..ec5ec4008 --- /dev/null +++ b/packages/plugin-doc-coverage/src/lib/utils.unit.test.ts @@ -0,0 +1,79 @@ +import type { Group } from '@code-pushup/models'; +import { AUDITS_MAP } from './constants'; +import { filterAuditsByPluginConfig, filterGroupsByOnlyAudits } from './utils'; + +describe('filterAuditsByPluginConfig', () => { + it('should return all audits when onlyAudits is not provided', () => { + const result = filterAuditsByPluginConfig({}); + expect(result).toStrictEqual(Object.values(AUDITS_MAP)); + }); + + it('should return all audits when onlyAudits is empty array', () => { + const result = filterAuditsByPluginConfig({ onlyAudits: [] }); + expect(result).toStrictEqual(Object.values(AUDITS_MAP)); + }); + + it('should return only specified audits when onlyAudits is provided', () => { + const onlyAudits = ['functions-coverage', 'classes-coverage']; + const result = filterAuditsByPluginConfig({ onlyAudits }); + + expect(result).toStrictEqual( + Object.values(AUDITS_MAP).filter(audit => + onlyAudits.includes(audit.slug), + ), + ); + }); +}); + +describe('filterGroupsByOnlyAudits', () => { + const mockGroups: Group[] = [ + { + title: 'Group 1', + slug: 'group-1', + refs: [ + { slug: 'functions-coverage', weight: 1 }, + { slug: 'classes-coverage', weight: 1 }, + ], + }, + { + title: 'Group 2', + slug: 'group-2', + refs: [ + { slug: 'types-coverage', weight: 1 }, + { slug: 'interfaces-coverage', weight: 1 }, + ], + }, + ]; + + it('should return all groups when onlyAudits is not provided', () => { + const result = filterGroupsByOnlyAudits(mockGroups, {}); + expect(result).toStrictEqual(mockGroups); + }); + + it('should return all groups when onlyAudits is empty array', () => { + const result = filterGroupsByOnlyAudits(mockGroups, { onlyAudits: [] }); + expect(result).toStrictEqual(mockGroups); + }); + + it('should filter groups based on specified audits', () => { + const result = filterGroupsByOnlyAudits(mockGroups, { + onlyAudits: ['functions-coverage'], + }); + + expect(result).toStrictEqual([ + { + title: 'Group 1', + slug: 'group-1', + refs: [{ slug: 'functions-coverage', weight: 1 }], + }, + ]); + }); + + it('should remove groups with no matching refs', () => { + const result = filterGroupsByOnlyAudits(mockGroups, { + onlyAudits: ['enums-coverage'], + }); + + expect(result).toStrictEqual([]); + }); +}); From 47486c80c6262017d6bc5e902bac50d712cae9c4 Mon Sep 17 00:00:00 2001 From: Alejandro Date: Fri, 20 Dec 2024 19:32:30 +0100 Subject: [PATCH 07/39] feat(plugin-doc-coverage): add skipAudits options to the plugin, create unit test for runner file --- code-pushup.config.ts | 41 +++-- .../plugin-doc-coverage/src/lib/config.ts | 18 ++- .../src/lib/config.unit.test.ts | 42 ++++- .../src/lib/doc-coverage-plugin.ts | 2 +- .../__snapshots__/runner.unit.test.ts.snap | 147 ++++++++++++++++++ .../src/lib/runner/models.ts | 6 + .../src/lib/runner/runner.ts | 19 ++- .../src/lib/runner/runner.unit.test.ts | 88 +++++++++++ .../src/lib/runner/utils.ts | 14 ++ packages/plugin-doc-coverage/src/lib/utils.ts | 24 +-- .../src/lib/utils.unit.test.ts | 19 ++- 11 files changed, 364 insertions(+), 56 deletions(-) create mode 100644 packages/plugin-doc-coverage/src/lib/runner/__snapshots__/runner.unit.test.ts.snap create mode 100644 packages/plugin-doc-coverage/src/lib/runner/runner.unit.test.ts diff --git a/code-pushup.config.ts b/code-pushup.config.ts index ddfcd59f6..0b2d52680 100644 --- a/code-pushup.config.ts +++ b/code-pushup.config.ts @@ -1,12 +1,6 @@ import 'dotenv/config'; import { z } from 'zod'; -import { - coverageCoreConfigNx, - docCoverageCoreConfig, - eslintCoreConfigNx, - jsPackagesCoreConfig, - lighthouseCoreConfig, -} from './code-pushup.preset.js'; +import { docCoverageCoreConfig } from './code-pushup.preset.js'; import type { CoreConfig } from './packages/models/src/index.js'; import { mergeConfigs } from './packages/utils/src/index.js'; @@ -33,13 +27,13 @@ const config: CoreConfig = { }; export default mergeConfigs( - config, - await coverageCoreConfigNx(), - await jsPackagesCoreConfig(), - await lighthouseCoreConfig( - 'https://github.com/code-pushup/cli?tab=readme-ov-file#code-pushup-cli/', - ), - await eslintCoreConfigNx(), + // config, + // await coverageCoreConfigNx(), + // await jsPackagesCoreConfig(), + // await lighthouseCoreConfig( + // 'https://github.com/code-pushup/cli?tab=readme-ov-file#code-pushup-cli/', + // ), + // await eslintCoreConfigNx(), await docCoverageCoreConfig({ sourceGlob: [ 'packages/**/src/**/*.ts', @@ -48,14 +42,15 @@ export default mergeConfigs( '!**/implementation/**', '!**/internal/**', ], - onlyAudits: [ - 'methods-coverage', - 'functions-coverage', - 'types-coverage', - 'classes-coverage', - 'interfaces-coverage', - 'enums-coverage', - 'type-aliases-coverage', - ], + skipAudits: ['methods-coverage'], + // onlyAudits: [ + // 'methods-coverage', + // 'functions-coverage', + // 'types-coverage', + // 'classes-coverage', + // 'interfaces-coverage', + // 'enums-coverage', + // 'type-aliases-coverage', + // ], }), ); diff --git a/packages/plugin-doc-coverage/src/lib/config.ts b/packages/plugin-doc-coverage/src/lib/config.ts index 52ccb5cb8..648420a1d 100644 --- a/packages/plugin-doc-coverage/src/lib/config.ts +++ b/packages/plugin-doc-coverage/src/lib/config.ts @@ -1,11 +1,17 @@ import { z } from 'zod'; -export const docCoveragePluginConfigSchema = z.object({ - onlyAudits: z.array(z.string()).optional(), - sourceGlob: z - .array(z.string()) - .default(['src/**/*.{ts,tsx}', '!**/*.spec.ts', '!**/*.test.ts']), -}); +export const docCoveragePluginConfigSchema = z + .object({ + skipAudits: z.array(z.string()).optional(), + onlyAudits: z.array(z.string()).optional(), + sourceGlob: z + .array(z.string()) + .default(['src/**/*.{ts,tsx}', '!**/*.spec.ts', '!**/*.test.ts']), + }) + .refine(data => !(data.skipAudits && data.onlyAudits), { + message: "You can't define 'skipAudits' and 'onlyAudits' simultaneously", + path: ['skipAudits', 'onlyAudits'], + }); export type DocCoveragePluginConfig = z.infer< typeof docCoveragePluginConfigSchema diff --git a/packages/plugin-doc-coverage/src/lib/config.unit.test.ts b/packages/plugin-doc-coverage/src/lib/config.unit.test.ts index 66f33ab52..1d28d2a7d 100644 --- a/packages/plugin-doc-coverage/src/lib/config.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/config.unit.test.ts @@ -5,6 +5,15 @@ import { } from './config.js'; describe('docCoveragePluginConfigSchema', () => { + it('throws when skipAudits and onlyAudits are defined', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + skipAudits: ['functions-coverage'], + onlyAudits: ['classes-coverage'], + }), + ).toThrow("You can't define 'skipAudits' and 'onlyAudits' simultaneously"); + }); + describe('sourceGlob', () => { it('accepts a valid source glob pattern', () => { expect(() => @@ -32,6 +41,15 @@ describe('docCoveragePluginConfigSchema', () => { }); }); + it('accepts a complete valid configuration', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + sourceGlob: ['src/**/*.ts'], + onlyAudits: ['functions-coverage'], + } satisfies DocCoveragePluginConfig), + ).not.toThrow(); + }); + describe('onlyAudits', () => { it('accepts valid audit slugs array', () => { expect(() => @@ -73,12 +91,22 @@ describe('docCoveragePluginConfigSchema', () => { }); }); - it('accepts a complete valid configuration', () => { - expect(() => - docCoveragePluginConfigSchema.parse({ - sourceGlob: ['src/**/*.ts'], - onlyAudits: ['functions-coverage'], - } satisfies DocCoveragePluginConfig), - ).not.toThrow(); + describe('skipAudits', () => { + it('accepts valid audit slugs array', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + skipAudits: ['functions-coverage', 'classes-coverage'], + sourceGlob: ['src/**/*.ts'], + }), + ).not.toThrow(); + }); + + it('throws for array with non-string elements', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + skipAudits: [123, true], + }), + ).toThrow('Expected string'); + }); }); }); diff --git a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts index 9d08784b1..d452839d6 100644 --- a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts +++ b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts @@ -29,7 +29,7 @@ export const PLUGIN_DOCS_URL = * plugins: [ * // ... other plugins ... * await docCoveragePlugin({ - * sourceGlob: 'src/**/*.{ts,tsx}' + * sourceGlob: 'src/**/*.{ts,tsx}', * }) * ] * } diff --git a/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/runner.unit.test.ts.snap b/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/runner.unit.test.ts.snap new file mode 100644 index 000000000..9db5313d1 --- /dev/null +++ b/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/runner.unit.test.ts.snap @@ -0,0 +1,147 @@ +// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html + +exports[`trasformCoverageReportToAudits > should filter audits when onlyAudits is provided 1`] = ` +[ + { + "details": { + "issues": [ + { + "message": "Missing documentation", + "severity": "warning", + "source": { + "file": "test.ts", + "position": { + "startLine": 10, + }, + }, + }, + ], + }, + "displayValue": "75 %", + "score": 0.75, + "slug": "functions-coverage", + "value": 75, + }, +] +`; + +exports[`trasformCoverageReportToAudits > should filter audits when skipAudits is provided 1`] = ` +[ + { + "details": { + "issues": [ + { + "message": "Missing documentation", + "severity": "warning", + "source": { + "file": "test.ts", + "position": { + "startLine": 10, + }, + }, + }, + ], + }, + "displayValue": "75 %", + "score": 0.75, + "slug": "functions-coverage", + "value": 75, + }, +] +`; + +exports[`trasformCoverageReportToAudits > should handle coverage result with multiple issues 1`] = ` +[ + { + "details": { + "issues": [ + { + "message": "Missing documentation", + "severity": "warning", + "source": { + "file": "test1.ts", + "position": { + "startLine": 10, + }, + }, + }, + { + "message": "Missing documentation", + "severity": "warning", + "source": { + "file": "test2.ts", + "position": { + "startLine": 20, + }, + }, + }, + ], + }, + "displayValue": "50 %", + "score": 0.5, + "slug": "functions-coverage", + "value": 50, + }, +] +`; + +exports[`trasformCoverageReportToAudits > should handle empty coverage result 1`] = `[]`; + +exports[`trasformCoverageReportToAudits > should prioritize onlyAudits over skipAudits when both are provided 1`] = ` +[ + { + "details": { + "issues": [ + { + "message": "Missing documentation", + "severity": "warning", + "source": { + "file": "test.ts", + "position": { + "startLine": 10, + }, + }, + }, + ], + }, + "displayValue": "75 %", + "score": 0.75, + "slug": "functions-coverage", + "value": 75, + }, +] +`; + +exports[`trasformCoverageReportToAudits > should transform coverage report to audit outputs with no filters 1`] = ` +[ + { + "details": { + "issues": [ + { + "message": "Missing documentation", + "severity": "warning", + "source": { + "file": "test.ts", + "position": { + "startLine": 10, + }, + }, + }, + ], + }, + "displayValue": "75 %", + "score": 0.75, + "slug": "functions-coverage", + "value": 75, + }, + { + "details": { + "issues": [], + }, + "displayValue": "100 %", + "score": 1, + "slug": "classes-coverage", + "value": 100, + }, +] +`; diff --git a/packages/plugin-doc-coverage/src/lib/runner/models.ts b/packages/plugin-doc-coverage/src/lib/runner/models.ts index 81849c428..c8119b4db 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/models.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/models.ts @@ -1,5 +1,6 @@ import type { SyntaxKind } from 'ts-morph'; +/** Maps the SyntaxKind from the library ts-morph to the coverage type. */ type SyntaxKindToStringLiteral = { [SyntaxKind.ClassDeclaration]: 'classes'; [SyntaxKind.MethodDeclaration]: 'methods'; @@ -11,9 +12,11 @@ type SyntaxKindToStringLiteral = { [SyntaxKind.TypeAliasDeclaration]: 'types'; }; +/**The coverage type is the same as the SyntaxKind from the library ts-morph but as a string. */ export type CoverageType = SyntaxKindToStringLiteral[keyof SyntaxKindToStringLiteral]; +/** The undocumented node is the node that is not documented and has the information for the report. */ export type UndocumentedNode = { file: string; type: CoverageType; @@ -22,13 +25,16 @@ export type UndocumentedNode = { class?: string; }; +/** The coverage data is the data that is used to create the coverage report. Without coverage stats yet */ export type CoverageData = { issues: UndocumentedNode[]; nodesCount: number; }; +/** The unprocessed coverage result CoverageData but for each coverage type. */ export type UnprocessedCoverageResult = Record; +/** The processed coverage result CoverageData but for each coverage type and with coverage stats. */ export type CoverageResult = Record< CoverageType, CoverageData & { diff --git a/packages/plugin-doc-coverage/src/lib/runner/runner.ts b/packages/plugin-doc-coverage/src/lib/runner/runner.ts index 91e8282e1..bb037e933 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/runner.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/runner.ts @@ -15,19 +15,24 @@ export function createRunnerFunction( /** * Transforms the coverage report into audit outputs. * @param coverageResult - The coverage result containing undocumented items and coverage statistics - * @param options - Configuration options specifying which audits to include + * @param options - Configuration options specifying which audits to include and exclude * @returns Audit outputs with coverage scores and details about undocumented items */ export function trasformCoverageReportToAudits( coverageResult: CoverageResult, - options: Pick, + options: Pick, ): AuditOutputs { return Object.entries(coverageResult) - .filter( - ([type]) => - !options.onlyAudits?.length || - options.onlyAudits.includes(`${type}-coverage`), - ) + .filter(([type]) => { + const auditSlug = `${type}-coverage`; + if (options.onlyAudits?.length) { + return options.onlyAudits.includes(auditSlug); + } + if (options.skipAudits?.length) { + return !options.skipAudits.includes(auditSlug); + } + return true; + }) .map(([type, items]) => { const coverageType = type as CoverageType; const coverage = items.coverage; diff --git a/packages/plugin-doc-coverage/src/lib/runner/runner.unit.test.ts b/packages/plugin-doc-coverage/src/lib/runner/runner.unit.test.ts new file mode 100644 index 000000000..daa1321ac --- /dev/null +++ b/packages/plugin-doc-coverage/src/lib/runner/runner.unit.test.ts @@ -0,0 +1,88 @@ +import type { CoverageResult } from './models'; +import { trasformCoverageReportToAudits } from './runner'; + +describe('trasformCoverageReportToAudits', () => { + const mockCoverageResult = { + functions: { + coverage: 75, + nodesCount: 4, + issues: [ + { + file: 'test.ts', + line: 10, + name: 'testFunction', + type: 'functions', + }, + ], + }, + classes: { + coverage: 100, + nodesCount: 2, + issues: [], + }, + } as unknown as CoverageResult; + + it('should transform coverage report to audit outputs with no filters', () => { + const result = trasformCoverageReportToAudits(mockCoverageResult, {}); + expect(result).toMatchSnapshot(); + }); + + it('should filter audits when onlyAudits is provided', () => { + const result = trasformCoverageReportToAudits(mockCoverageResult, { + onlyAudits: ['functions-coverage'], + }); + expect(result).toMatchSnapshot(); + }); + + it('should filter audits when skipAudits is provided', () => { + const result = trasformCoverageReportToAudits(mockCoverageResult, { + skipAudits: ['classes-coverage'], + }); + expect(result).toMatchSnapshot(); + }); + + it('should handle empty coverage result', () => { + const result = trasformCoverageReportToAudits( + {} as unknown as CoverageResult, + {}, + ); + expect(result).toMatchSnapshot(); + }); + + it('should handle coverage result with multiple issues', () => { + const coverageWithMultipleIssues = { + functions: { + coverage: 50, + nodesCount: 4, + issues: [ + { + file: 'test1.ts', + line: 10, + name: 'function1', + type: 'functions', + }, + { + file: 'test2.ts', + line: 20, + name: 'function2', + type: 'functions', + }, + ], + }, + } as unknown as CoverageResult; + + const result = trasformCoverageReportToAudits( + coverageWithMultipleIssues, + {}, + ); + expect(result).toMatchSnapshot(); + }); + + it('should prioritize onlyAudits over skipAudits when both are provided', () => { + const result = trasformCoverageReportToAudits(mockCoverageResult, { + onlyAudits: ['functions-coverage'], + skipAudits: ['functions-coverage'], + }); + expect(result).toMatchSnapshot(); + }); +}); diff --git a/packages/plugin-doc-coverage/src/lib/runner/utils.ts b/packages/plugin-doc-coverage/src/lib/runner/utils.ts index e9628eac6..1cdede6dd 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/utils.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/utils.ts @@ -5,6 +5,10 @@ import type { UnprocessedCoverageResult, } from './models'; +/** + * Creates an empty unprocessed coverage report. + * @returns The empty unprocessed coverage report. + */ export function createEmptyUnprocessedCoverageReport(): UnprocessedCoverageResult { return { enums: { nodesCount: 0, issues: [] }, @@ -18,6 +22,11 @@ export function createEmptyUnprocessedCoverageReport(): UnprocessedCoverageResul }; } +/** + * Calculates the coverage percentage for each coverage type. + * @param result - The unprocessed coverage result. + * @returns The processed coverage result. + */ export function calculateCoverage(result: UnprocessedCoverageResult) { return Object.fromEntries( Object.entries(result).map(([key, value]) => { @@ -41,6 +50,11 @@ export function calculateCoverage(result: UnprocessedCoverageResult) { ) as CoverageResult; } +/** + * Maps the SyntaxKind from the library ts-morph to the coverage type. + * @param kind - The SyntaxKind from the library ts-morph. + * @returns The coverage type. + */ export function getCoverageTypeFromKind(kind: SyntaxKind): CoverageType { switch (kind) { case SyntaxKind.ClassDeclaration: diff --git a/packages/plugin-doc-coverage/src/lib/utils.ts b/packages/plugin-doc-coverage/src/lib/utils.ts index b3e7584cb..45b664693 100644 --- a/packages/plugin-doc-coverage/src/lib/utils.ts +++ b/packages/plugin-doc-coverage/src/lib/utils.ts @@ -10,29 +10,35 @@ import { AUDITS_MAP } from './constants'; * @returns The audits. */ export function filterAuditsByPluginConfig( - config: Pick, + config: Pick, ): Audit[] { - const { onlyAudits } = config; + const { onlyAudits, skipAudits } = config; - if (!onlyAudits || onlyAudits.length === 0) { - return Object.values(AUDITS_MAP); + if (onlyAudits && onlyAudits.length > 0) { + return Object.values(AUDITS_MAP).filter(audit => + onlyAudits.includes(audit.slug), + ); } - return Object.values(AUDITS_MAP).filter(audit => - onlyAudits.includes(audit.slug), - ); + if (skipAudits && skipAudits.length > 0) { + return Object.values(AUDITS_MAP).filter( + audit => !skipAudits.includes(audit.slug), + ); + } + + return Object.values(AUDITS_MAP); } /** * Filter groups by the audits that are specified in the configuration. * The groups refs are filtered to only include the audits that are specified in the configuration. * @param groups - The groups to filter. - * @param options - The configuration object. + * @param options - The configuration object containing either onlyAudits or skipAudits. * @returns The filtered groups. */ export function filterGroupsByOnlyAudits( groups: Group[], - options: Pick, + options: Pick, ): Group[] { const audits = filterAuditsByPluginConfig(options); return groups diff --git a/packages/plugin-doc-coverage/src/lib/utils.unit.test.ts b/packages/plugin-doc-coverage/src/lib/utils.unit.test.ts index ec5ec4008..a7ea37d59 100644 --- a/packages/plugin-doc-coverage/src/lib/utils.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/utils.unit.test.ts @@ -3,13 +3,16 @@ import { AUDITS_MAP } from './constants'; import { filterAuditsByPluginConfig, filterGroupsByOnlyAudits } from './utils'; describe('filterAuditsByPluginConfig', () => { - it('should return all audits when onlyAudits is not provided', () => { + it('should return all audits when onlyAudits and skipAudits are not provided', () => { const result = filterAuditsByPluginConfig({}); expect(result).toStrictEqual(Object.values(AUDITS_MAP)); }); - it('should return all audits when onlyAudits is empty array', () => { - const result = filterAuditsByPluginConfig({ onlyAudits: [] }); + it('should return all audits when onlyAudits is empty array and skipAudits is also empty array', () => { + const result = filterAuditsByPluginConfig({ + onlyAudits: [], + skipAudits: [], + }); expect(result).toStrictEqual(Object.values(AUDITS_MAP)); }); @@ -23,6 +26,16 @@ describe('filterAuditsByPluginConfig', () => { ), ); }); + + it('should return only specified audits when skipAudits is provided', () => { + const skipAudits = ['functions-coverage', 'classes-coverage']; + const result = filterAuditsByPluginConfig({ skipAudits }); + expect(result).toStrictEqual( + Object.values(AUDITS_MAP).filter( + audit => !skipAudits.includes(audit.slug), + ), + ); + }); }); describe('filterGroupsByOnlyAudits', () => { From f21fbe2866730129bb727affed0a045296263b59 Mon Sep 17 00:00:00 2001 From: Alejandro Date: Fri, 20 Dec 2024 19:45:03 +0100 Subject: [PATCH 08/39] chore(plugin-doc-coverage): fix linter problems --- ...ck.spec.ts => component-mock.unit.test.ts} | 2 +- packages/plugin-doc-coverage/package.json | 2 - packages/plugin-doc-coverage/src/bin.ts | 3 - .../plugin-doc-coverage/src/lib/constants.ts | 25 +++---- .../plugin-doc-coverage/src/lib/models.ts | 2 +- .../runner/doc-processer.integration.test.ts | 2 +- .../src/lib/runner/doc-processer.ts | 69 +++++++++++-------- .../src/lib/runner/doc-processer.unit.test.ts | 8 +-- .../src/lib/runner/runner.ts | 6 +- .../src/lib/runner/runner.unit.test.ts | 4 +- .../src/lib/runner/utils.ts | 2 +- .../src/lib/runner/utils.unit.test.ts | 4 +- packages/plugin-doc-coverage/src/lib/utils.ts | 4 +- .../src/lib/utils.unit.test.ts | 7 +- 14 files changed, 72 insertions(+), 68 deletions(-) rename packages/plugin-doc-coverage/mocks/{component-mock.spec.ts => component-mock.unit.test.ts} (98%) delete mode 100644 packages/plugin-doc-coverage/src/bin.ts diff --git a/packages/plugin-doc-coverage/mocks/component-mock.spec.ts b/packages/plugin-doc-coverage/mocks/component-mock.unit.test.ts similarity index 98% rename from packages/plugin-doc-coverage/mocks/component-mock.spec.ts rename to packages/plugin-doc-coverage/mocks/component-mock.unit.test.ts index 62998c2a9..648080fb0 100644 --- a/packages/plugin-doc-coverage/mocks/component-mock.spec.ts +++ b/packages/plugin-doc-coverage/mocks/component-mock.unit.test.ts @@ -1,5 +1,5 @@ import { describe, expect, it } from 'vitest'; -import { DUMMY_FUNCTION, DUMMY_FUNCTION_2 } from './component-mock'; +import { DUMMY_FUNCTION, DUMMY_FUNCTION_2 } from './component-mock.js'; export function shouldnotBeHere() { return 'Hello World'; diff --git a/packages/plugin-doc-coverage/package.json b/packages/plugin-doc-coverage/package.json index ec8b984a9..c06f92a38 100644 --- a/packages/plugin-doc-coverage/package.json +++ b/packages/plugin-doc-coverage/package.json @@ -35,8 +35,6 @@ "type": "module", "dependencies": { "@code-pushup/models": "0.57.0", - "@code-pushup/utils": "0.57.0", - "ansis": "^3.3.0", "zod": "^3.22.4", "ts-morph": "^24.0.0" }, diff --git a/packages/plugin-doc-coverage/src/bin.ts b/packages/plugin-doc-coverage/src/bin.ts deleted file mode 100644 index bf6572a76..000000000 --- a/packages/plugin-doc-coverage/src/bin.ts +++ /dev/null @@ -1,3 +0,0 @@ -import { executeRunner } from './lib/runner/index.js'; - -await executeRunner(); diff --git a/packages/plugin-doc-coverage/src/lib/constants.ts b/packages/plugin-doc-coverage/src/lib/constants.ts index 458409066..d199b2b55 100644 --- a/packages/plugin-doc-coverage/src/lib/constants.ts +++ b/packages/plugin-doc-coverage/src/lib/constants.ts @@ -1,5 +1,5 @@ import type { Audit, Group } from '@code-pushup/models'; -import type { AuditSlug } from './models'; +import type { AuditSlug } from './models.js'; export const PLUGIN_SLUG = 'doc-coverage'; @@ -51,18 +51,15 @@ export const groups: Group[] = [ slug: 'documentation-coverage', title: 'Documentation coverage', description: 'Documentation coverage', - refs: Object.keys(AUDITS_MAP).map(slug => { - switch (slug as AuditSlug) { - case 'classes-coverage': - case 'functions-coverage': - case 'methods-coverage': - return { slug, weight: 2 }; - case 'interfaces-coverage': - case 'properties-coverage': - case 'types-coverage': - default: - return { slug, weight: 1 }; - } - }), + refs: Object.keys(AUDITS_MAP).map(slug => ({ + slug, + weight: [ + 'classes-coverage', + 'functions-coverage', + 'methods-coverage', + ].includes(slug) + ? 2 + : 1, + })), }, ]; diff --git a/packages/plugin-doc-coverage/src/lib/models.ts b/packages/plugin-doc-coverage/src/lib/models.ts index 4500a13d1..a407d2a74 100644 --- a/packages/plugin-doc-coverage/src/lib/models.ts +++ b/packages/plugin-doc-coverage/src/lib/models.ts @@ -1,3 +1,3 @@ -import type { CoverageType } from './runner/models'; +import type { CoverageType } from './runner/models.js'; export type AuditSlug = `${CoverageType}-coverage`; diff --git a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.integration.test.ts b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.integration.test.ts index 51e607eb9..00bdc83a7 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.integration.test.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.integration.test.ts @@ -1,4 +1,4 @@ -import { processDocCoverage } from './doc-processer'; +import { processDocCoverage } from './doc-processer.js'; describe('processDocCoverage', () => { it('should succesfully get the right number of ts files', () => { diff --git a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts index fbf333bfc..d510ae15f 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts @@ -29,14 +29,14 @@ export function processDocCoverage( * @param sourceFiles - The source files to process * @returns {UnprocessedCoverageResult} The unprocessed coverage report */ -export function getUnprocessedCoverageReport(sourceFiles: SourceFile[]) { +export function getUnprocessedCoverageReport( + sourceFiles: SourceFile[], +): CoverageResult { const unprocessedCoverageReport = sourceFiles.reduce( (coverageReportOfAllFiles, sourceFile) => { - // Info of the file const filePath = sourceFile.getFilePath(); const classes = sourceFile.getClasses(); - // All nodes of the file const allNodesFromFile = [ ...sourceFile.getFunctions(), ...classes, @@ -44,22 +44,33 @@ export function getUnprocessedCoverageReport(sourceFiles: SourceFile[]) { ...sourceFile.getTypeAliases(), ...sourceFile.getEnums(), ...sourceFile.getInterfaces(), - // ...sourceFile.getVariableStatements().flatMap(statement => statement.getDeclarations()) ]; const coverageReportOfCurrentFile = allNodesFromFile.reduce( (acc, node) => { const nodeType = getCoverageTypeFromKind(node.getKind()); - acc[nodeType].nodesCount++; - if (node.getJsDocs().length === 0) { - acc[nodeType].issues.push({ - file: filePath, - type: nodeType, - name: node.getName() || '', - line: node.getStartLineNumber(), - }); - } - return acc; + const currentTypeReport = acc[nodeType]; + + const updatedIssues = + node.getJsDocs().length === 0 + ? [ + ...currentTypeReport.issues, + { + file: filePath, + type: nodeType, + name: node.getName() || '', + line: node.getStartLineNumber(), + }, + ] + : currentTypeReport.issues; + + return { + ...acc, + [nodeType]: { + nodesCount: currentTypeReport.nodesCount + 1, + issues: updatedIssues, + }, + }; }, createEmptyUnprocessedCoverageReport(), ); @@ -84,22 +95,20 @@ export function getUnprocessedCoverageReport(sourceFiles: SourceFile[]) { export function mergeCoverageResults( results: UnprocessedCoverageResult, current: Partial, -) { - return { - ...Object.fromEntries( - Object.entries(results).map(([key, value]) => { - const node = value as CoverageResult[CoverageType]; - const type = key as CoverageType; - return [ - type, - { - nodesCount: node.nodesCount + (current[type]?.nodesCount ?? 0), - issues: [...node.issues, ...(current[type]?.issues ?? [])], - }, - ]; - }), - ), - } as UnprocessedCoverageResult; +): UnprocessedCoverageResult { + return Object.fromEntries( + Object.entries(results).map(([key, value]) => { + const node = value as CoverageResult[CoverageType]; + const type = key as CoverageType; + return [ + type, + { + nodesCount: node.nodesCount + (current[type]?.nodesCount ?? 0), + issues: [...node.issues, ...(current[type]?.issues ?? [])], + }, + ]; + }), + ) as UnprocessedCoverageResult; } /** diff --git a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts index 21c829349..233723f03 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts @@ -1,11 +1,11 @@ import type { ClassDeclaration } from 'ts-morph'; -import { nodeMock, sourceFileMock } from './../../../mocks/source-files.mock'; +import { nodeMock, sourceFileMock } from '../../../mocks/source-files.mock'; import { getClassNodes, getUnprocessedCoverageReport, mergeCoverageResults, -} from './doc-processer'; -import type { UnprocessedCoverageResult } from './models'; +} from './doc-processer.js'; +import type { UnprocessedCoverageResult } from './models.js'; describe('getUnprocessedCoverageReport', () => { it('should produce a full report', () => { @@ -43,7 +43,7 @@ describe('getUnprocessedCoverageReport', () => { sourceFileMock('test.ts', { functions: { 1: true, 2: false, 3: false } }), ]); - expect(results.functions.issues.length).toBe(2); + expect(results.functions.issues).toHaveLength(2); }); it('should collect valid issues', () => { diff --git a/packages/plugin-doc-coverage/src/lib/runner/runner.ts b/packages/plugin-doc-coverage/src/lib/runner/runner.ts index bb037e933..8bbf54066 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/runner.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/runner.ts @@ -1,7 +1,7 @@ import type { AuditOutputs, RunnerFunction } from '@code-pushup/models'; -import type { DocCoveragePluginConfig } from '../config'; -import { processDocCoverage } from './doc-processer'; -import type { CoverageResult, CoverageType } from './models'; +import type { DocCoveragePluginConfig } from '../config.js'; +import { processDocCoverage } from './doc-processer.js'; +import type { CoverageResult, CoverageType } from './models.js'; export function createRunnerFunction( config: DocCoveragePluginConfig, diff --git a/packages/plugin-doc-coverage/src/lib/runner/runner.unit.test.ts b/packages/plugin-doc-coverage/src/lib/runner/runner.unit.test.ts index daa1321ac..d81748ab3 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/runner.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/runner.unit.test.ts @@ -1,5 +1,5 @@ -import type { CoverageResult } from './models'; -import { trasformCoverageReportToAudits } from './runner'; +import type { CoverageResult } from './models.js'; +import { trasformCoverageReportToAudits } from './runner.js'; describe('trasformCoverageReportToAudits', () => { const mockCoverageResult = { diff --git a/packages/plugin-doc-coverage/src/lib/runner/utils.ts b/packages/plugin-doc-coverage/src/lib/runner/utils.ts index 1cdede6dd..31c312619 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/utils.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/utils.ts @@ -3,7 +3,7 @@ import type { CoverageResult, CoverageType, UnprocessedCoverageResult, -} from './models'; +} from './models.js'; /** * Creates an empty unprocessed coverage report. diff --git a/packages/plugin-doc-coverage/src/lib/runner/utils.unit.test.ts b/packages/plugin-doc-coverage/src/lib/runner/utils.unit.test.ts index 403c7b3ad..731d5280c 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/utils.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/utils.unit.test.ts @@ -1,10 +1,10 @@ import { SyntaxKind } from 'ts-morph'; -import type { UnprocessedCoverageResult } from './models'; +import type { UnprocessedCoverageResult } from './models.js'; import { calculateCoverage, createEmptyUnprocessedCoverageReport, getCoverageTypeFromKind, -} from './utils'; +} from './utils.js'; describe('createEmptyUnprocessedCoverageReport', () => { it('should create an empty report with all categories initialized', () => { diff --git a/packages/plugin-doc-coverage/src/lib/utils.ts b/packages/plugin-doc-coverage/src/lib/utils.ts index 45b664693..73e04c0af 100644 --- a/packages/plugin-doc-coverage/src/lib/utils.ts +++ b/packages/plugin-doc-coverage/src/lib/utils.ts @@ -1,6 +1,6 @@ import type { Audit, Group } from '@code-pushup/models'; -import type { DocCoveragePluginConfig } from './config'; -import { AUDITS_MAP } from './constants'; +import type { DocCoveragePluginConfig } from './config.js'; +import { AUDITS_MAP } from './constants.js'; /** * Get audits based on the configuration. diff --git a/packages/plugin-doc-coverage/src/lib/utils.unit.test.ts b/packages/plugin-doc-coverage/src/lib/utils.unit.test.ts index a7ea37d59..9252b5fd5 100644 --- a/packages/plugin-doc-coverage/src/lib/utils.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/utils.unit.test.ts @@ -1,6 +1,9 @@ import type { Group } from '@code-pushup/models'; -import { AUDITS_MAP } from './constants'; -import { filterAuditsByPluginConfig, filterGroupsByOnlyAudits } from './utils'; +import { AUDITS_MAP } from './constants.js'; +import { + filterAuditsByPluginConfig, + filterGroupsByOnlyAudits, +} from './utils.js'; describe('filterAuditsByPluginConfig', () => { it('should return all audits when onlyAudits and skipAudits are not provided', () => { From 4fb478ef46f6242a1c903a2b69edbe0db04c3c63 Mon Sep 17 00:00:00 2001 From: Alejandro Date: Fri, 20 Dec 2024 19:46:40 +0100 Subject: [PATCH 09/39] fix: return code-pushup config to original state --- code-pushup.config.ts | 31 ++++++++++++++----------------- 1 file changed, 14 insertions(+), 17 deletions(-) diff --git a/code-pushup.config.ts b/code-pushup.config.ts index 0b2d52680..a0a33cfee 100644 --- a/code-pushup.config.ts +++ b/code-pushup.config.ts @@ -1,6 +1,12 @@ import 'dotenv/config'; import { z } from 'zod'; -import { docCoverageCoreConfig } from './code-pushup.preset.js'; +import { + coverageCoreConfigNx, + docCoverageCoreConfig, + eslintCoreConfigNx, + jsPackagesCoreConfig, + lighthouseCoreConfig, +} from './code-pushup.preset.js'; import type { CoreConfig } from './packages/models/src/index.js'; import { mergeConfigs } from './packages/utils/src/index.js'; @@ -27,13 +33,13 @@ const config: CoreConfig = { }; export default mergeConfigs( - // config, - // await coverageCoreConfigNx(), - // await jsPackagesCoreConfig(), - // await lighthouseCoreConfig( - // 'https://github.com/code-pushup/cli?tab=readme-ov-file#code-pushup-cli/', - // ), - // await eslintCoreConfigNx(), + config, + await coverageCoreConfigNx(), + await jsPackagesCoreConfig(), + await lighthouseCoreConfig( + 'https://github.com/code-pushup/cli?tab=readme-ov-file#code-pushup-cli/', + ), + await eslintCoreConfigNx(), await docCoverageCoreConfig({ sourceGlob: [ 'packages/**/src/**/*.ts', @@ -43,14 +49,5 @@ export default mergeConfigs( '!**/internal/**', ], skipAudits: ['methods-coverage'], - // onlyAudits: [ - // 'methods-coverage', - // 'functions-coverage', - // 'types-coverage', - // 'classes-coverage', - // 'interfaces-coverage', - // 'enums-coverage', - // 'type-aliases-coverage', - // ], }), ); From feefa0ad771f97448be79a35334e379907fdc21b Mon Sep 17 00:00:00 2001 From: Alejandro Date: Sat, 21 Dec 2024 12:44:27 +0100 Subject: [PATCH 10/39] feat(plugin-doc-coverage): add support for variable statement to be documented, improve test --- code-pushup.config.bundled_oq2x2csd2at.mjs | 1210 ----------------- .../mocks/component-mock.ts | 38 - .../fixtures/angular/map-event.function.ts | 2 + .../mocks/source-files.mock.ts | 72 +- .../doc-processer.integration.test.ts.snap | 38 +- .../src/lib/runner/doc-processer.ts | 32 +- .../src/lib/runner/doc-processer.unit.test.ts | 79 +- .../src/lib/runner/utils.ts | 1 + 8 files changed, 158 insertions(+), 1314 deletions(-) delete mode 100644 code-pushup.config.bundled_oq2x2csd2at.mjs diff --git a/code-pushup.config.bundled_oq2x2csd2at.mjs b/code-pushup.config.bundled_oq2x2csd2at.mjs deleted file mode 100644 index 4c033e42d..000000000 --- a/code-pushup.config.bundled_oq2x2csd2at.mjs +++ /dev/null @@ -1,1210 +0,0 @@ -// code-pushup.config.ts -// packages/utils/src/lib/logging.ts -import isaacs_cliui from '@isaacs/cliui'; -import { cliui } from '@poppinss/cliui'; -// packages/plugin-coverage/src/lib/runner/index.ts -import { bold } from 'ansis'; -// packages/plugin-coverage/src/lib/nx/coverage-paths.ts -import { bold as bold2 } from 'ansis'; -// packages/plugin-lighthouse/src/lib/normalize-flags.ts -import { bold as bold3, yellow } from 'ansis'; -// packages/plugin-lighthouse/src/lib/runner/utils.ts -import { bold as bold7 } from 'ansis'; -// packages/plugin-lighthouse/src/lib/runner/details/details.ts -import { bold as bold6, yellow as yellow2 } from 'ansis'; -// packages/plugin-lighthouse/src/lib/runner/details/item-value.ts -import { bold as bold4 } from 'ansis'; -// packages/plugin-lighthouse/src/lib/runner/details/utils.ts -import { bold as bold5 } from 'ansis'; -// packages/utils/src/lib/reports/utils.ts -import ansis from 'ansis'; -// packages/utils/src/lib/file-system.ts -import { bold as bold8, gray } from 'ansis'; -import { underline } from 'ansis'; -// packages/utils/src/lib/progress.ts -import { black, bold as bold9, gray as gray2, green } from 'ansis'; -// packages/utils/src/lib/reports/log-stdout-summary.ts -import { bold as bold11, cyan, cyanBright, green as green2, red } from 'ansis'; -// packages/utils/src/lib/zod-validation.ts -import { bold as bold12, red as red2 } from 'ansis'; -// packages/plugin-js-packages/src/lib/runner/audit/transform.ts -import { md } from 'build-md'; -// packages/plugin-js-packages/src/lib/runner/outdated/transform.ts -import { md as md2 } from 'build-md'; -import { md as md3 } from 'build-md'; -// packages/utils/src/lib/reports/generate-md-report.ts -import { MarkdownDocument as MarkdownDocument3, md as md6 } from 'build-md'; -// packages/utils/src/lib/reports/formatting.ts -import { MarkdownDocument, md as md4 } from 'build-md'; -// packages/utils/src/lib/reports/generate-md-report-categoy-section.ts -import { MarkdownDocument as MarkdownDocument2, md as md5 } from 'build-md'; -// packages/utils/src/lib/reports/generate-md-reports-diff.ts -import { MarkdownDocument as MarkdownDocument5, md as md8 } from 'build-md'; -// packages/utils/src/lib/reports/generate-md-reports-diff-utils.ts -import { MarkdownDocument as MarkdownDocument4, md as md7 } from 'build-md'; -import { bundleRequire } from 'bundle-require'; -// packages/plugin-lighthouse/src/lib/constants.ts -import { DEFAULT_FLAGS } from 'chrome-launcher/dist/flags.js'; -import 'dotenv/config'; -// packages/plugin-eslint/src/lib/setup.ts -import { ESLint } from 'eslint'; -// packages/plugin-eslint/src/lib/meta/versions/detect.ts -import { ESLint as ESLint2 } from 'eslint'; -// packages/plugin-eslint/src/lib/meta/versions/flat.ts -import { builtinRules } from 'eslint/use-at-your-own-risk'; -// packages/plugin-lighthouse/src/lib/runner/constants.ts -import { defaultConfig } from 'lighthouse'; -import log from 'lighthouse-logger'; -// packages/plugin-lighthouse/src/lib/runner/runner.ts -import { runLighthouse } from 'lighthouse/cli/run.js'; -import desktopConfig from 'lighthouse/core/config/desktop-config.js'; -import experimentalConfig from 'lighthouse/core/config/experimental-config.js'; -import perfConfig from 'lighthouse/core/config/perf-config.js'; -import { MultiProgressBars } from 'multi-progress-bars'; -// packages/utils/src/lib/execute-process.ts -import { spawn } from 'node:child_process'; -// packages/plugin-eslint/src/lib/meta/hash.ts -import { createHash } from 'node:crypto'; -import { writeFile } from 'node:fs/promises'; -// packages/plugin-eslint/src/lib/runner/index.ts -import { writeFile as writeFile2 } from 'node:fs/promises'; -// packages/plugin-js-packages/src/lib/runner/index.ts -import { writeFile as writeFile3 } from 'node:fs/promises'; -// packages/plugin-js-packages/src/lib/package-managers/derive-package-manager.ts -import { readFile } from 'node:fs/promises'; -import { - mkdir, - readFile as readFile2, - readdir, - rm, - stat, -} from 'node:fs/promises'; -// packages/plugin-coverage/src/lib/coverage-plugin.ts -import { createRequire } from 'node:module'; -// packages/plugin-eslint/src/lib/eslint-plugin.ts -import { createRequire as createRequire2 } from 'node:module'; -// packages/plugin-js-packages/src/lib/js-packages-plugin.ts -import { createRequire as createRequire3 } from 'node:module'; -// packages/plugin-lighthouse/src/lib/lighthouse-plugin.ts -import { createRequire as createRequire4 } from 'node:module'; -// packages/plugin-eslint/src/lib/runner/lint.ts -import { platform } from 'node:os'; -// packages/utils/src/lib/transform.ts -import { platform as platform2 } from 'node:os'; -import path4 from 'node:path'; -import path3 from 'node:path'; -// packages/plugin-coverage/src/lib/runner/constants.ts -import path from 'node:path'; -// packages/plugin-coverage/src/lib/runner/lcov/lcov-runner.ts -import path2 from 'node:path'; -import path5 from 'node:path'; -import path8 from 'node:path'; -import path6 from 'node:path'; -import path7 from 'node:path'; -// packages/plugin-eslint/src/lib/nx/utils.ts -import path9 from 'node:path'; -import path14 from 'node:path'; -// packages/plugin-js-packages/src/lib/runner/utils.ts -import path10 from 'node:path'; -import path12 from 'node:path'; -// packages/plugin-js-packages/src/lib/runner/constants.ts -import path11 from 'node:path'; -import path13 from 'node:path'; -import path15 from 'node:path'; -import path16 from 'node:path'; -import path17 from 'node:path'; -import path18 from 'node:path'; -// packages/utils/src/lib/git/git.ts -import path19 from 'node:path'; -import path20 from 'node:path'; -// packages/utils/src/lib/reports/load-report.ts -import path21 from 'node:path'; -import { fileURLToPath } from 'node:url'; -import { fileURLToPath as fileURLToPath2 } from 'node:url'; -import { pathToFileURL } from 'node:url'; -import { fileURLToPath as fileURLToPath3 } from 'node:url'; -// packages/plugin-coverage/src/lib/runner/lcov/parse-lcov.ts -import parseLcovExport from 'parse-lcov'; -import { clean, diff, neq } from 'semver'; -// packages/utils/src/lib/semver.ts -import { rcompare, valid } from 'semver'; -// packages/utils/src/lib/git/git.commits-and-tags.ts -import { simpleGit } from 'simple-git'; -import { simpleGit as simpleGit2 } from 'simple-git'; -// packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts -import { Project } from 'ts-morph'; -// packages/plugin-doc-coverage/src/lib/utils.ts -import { SyntaxKind } from 'typescript'; -import { z as z5 } from 'zod'; -// packages/plugin-coverage/src/lib/config.ts -import { z } from 'zod'; -// packages/plugin-doc-coverage/src/lib/config.ts -import { z as z2 } from 'zod'; -// packages/plugin-eslint/src/lib/config.ts -import { z as z3 } from 'zod'; -// packages/plugin-js-packages/src/lib/config.ts -import { z as z4 } from 'zod'; -import { issueSeveritySchema } from '@code-pushup/models'; -import { DEFAULT_PERSIST_OUTPUT_DIR } from '@code-pushup/models'; -// packages/plugin-lighthouse/src/lib/runner/details/opportunity.type.ts -import { tableSchema as tableSchema2 } from '@code-pushup/models'; -// packages/plugin-lighthouse/src/lib/runner/details/table.type.ts -import { tableSchema } from '@code-pushup/models'; -// packages/utils/src/index.ts -import { exists as exists4 } from '@code-pushup/models'; -// packages/utils/src/lib/formatting.ts -import { - MAX_DESCRIPTION_LENGTH, - MAX_ISSUE_MESSAGE_LENGTH, - MAX_TITLE_LENGTH, -} from '@code-pushup/models'; -import { commitSchema } from '@code-pushup/models'; -import { reportSchema } from '@code-pushup/models'; -import { capitalize } from '@code-pushup/utils'; -import { - ProcessError, - ensureDirectoryExists, - executeProcess, - filePathToCliArg, - readJsonFile, - ui as ui2, -} from '@code-pushup/utils'; -import { pluginWorkDir } from '@code-pushup/utils'; -import { exists, readTextFile, toUnixNewlines, ui } from '@code-pushup/utils'; -// packages/plugin-coverage/src/lib/runner/lcov/transform.ts -import { toNumberPrecision, toOrdinal } from '@code-pushup/utils'; -import { importModule, ui as ui3 } from '@code-pushup/utils'; -import { toArray } from '@code-pushup/utils'; -// packages/plugin-eslint/src/lib/meta/groups.ts -import { objectToKeys, slugify as slugify2 } from '@code-pushup/utils'; -import { slugify } from '@code-pushup/utils'; -// packages/plugin-eslint/src/lib/meta/parse.ts -import { toArray as toArray2 } from '@code-pushup/utils'; -import { - exists as exists2, - findNearestFile, - toArray as toArray3, - ui as ui4, -} from '@code-pushup/utils'; -// packages/plugin-eslint/src/lib/meta/versions/legacy.ts -import { - distinct, - exists as exists3, - toArray as toArray4, - ui as ui5, -} from '@code-pushup/utils'; -import { fileExists } from '@code-pushup/utils'; -// packages/plugin-eslint/src/lib/meta/transform.ts -import { truncateDescription, truncateTitle } from '@code-pushup/utils'; -import { - ensureDirectoryExists as ensureDirectoryExists2, - filePathToCliArg as filePathToCliArg3, - pluginWorkDir as pluginWorkDir2, - readJsonFile as readJsonFile2, -} from '@code-pushup/utils'; -import { - distinct as distinct2, - executeProcess as executeProcess2, - filePathToCliArg as filePathToCliArg2, - toArray as toArray5, -} from '@code-pushup/utils'; -// packages/plugin-eslint/src/lib/runner/transform.ts -import { - compareIssueSeverity, - countOccurrences, - objectToEntries, - pluralizeToken, - truncateIssueMessage, - ui as ui6, -} from '@code-pushup/utils'; -import { - fileExists as fileExists2, - toArray as toArray6, -} from '@code-pushup/utils'; -// packages/plugin-js-packages/src/lib/package-managers/npm/npm.ts -import { objectToKeys as objectToKeys3 } from '@code-pushup/utils'; -import { - crawlFileSystem, - objectFromEntries, - objectToKeys as objectToKeys2, - readJsonFile as readJsonFile3, -} from '@code-pushup/utils'; -// packages/plugin-js-packages/src/lib/package-managers/npm/audit-result.ts -import { objectToEntries as objectToEntries2 } from '@code-pushup/utils'; -// packages/plugin-js-packages/src/lib/package-managers/npm/outdated-result.ts -import { objectToEntries as objectToEntries3 } from '@code-pushup/utils'; -// packages/plugin-js-packages/src/lib/package-managers/pnpm/pnpm.ts -import { objectToKeys as objectToKeys4 } from '@code-pushup/utils'; -// packages/plugin-js-packages/src/lib/package-managers/pnpm/outdated-result.ts -import { objectToEntries as objectToEntries4 } from '@code-pushup/utils'; -// packages/plugin-js-packages/src/lib/package-managers/yarn-classic/audit-result.ts -import { fromJsonLines } from '@code-pushup/utils'; -// packages/plugin-js-packages/src/lib/package-managers/yarn-classic/outdated-result.ts -import { - fromJsonLines as fromJsonLines2, - objectFromEntries as objectFromEntries2, - objectToEntries as objectToEntries5, - objectToKeys as objectToKeys5, -} from '@code-pushup/utils'; -import { - ensureDirectoryExists as ensureDirectoryExists3, - executeProcess as executeProcess3, - filePathToCliArg as filePathToCliArg4, - isPromiseFulfilledResult, - isPromiseRejectedResult, - objectFromEntries as objectFromEntries4, - readJsonFile as readJsonFile4, -} from '@code-pushup/utils'; -import { objectToEntries as objectToEntries6 } from '@code-pushup/utils'; -import { pluginWorkDir as pluginWorkDir3 } from '@code-pushup/utils'; -import { - objectFromEntries as objectFromEntries3, - pluralize, -} from '@code-pushup/utils'; -// packages/plugin-js-packages/src/lib/runner/outdated/constants.ts -import { objectToKeys as objectToKeys6 } from '@code-pushup/utils'; -import { fileExists as fileExists3 } from '@code-pushup/utils'; -// packages/plugin-js-packages/src/lib/package-managers/derive-yarn.ts -import { executeProcess as executeProcess4 } from '@code-pushup/utils'; -import { ui as ui7 } from '@code-pushup/utils'; -import { ensureDirectoryExists as ensureDirectoryExists4 } from '@code-pushup/utils'; -import { - formatReportScore, - importModule as importModule2, - readJsonFile as readJsonFile5, - ui as ui10, -} from '@code-pushup/utils'; -import { ui as ui9 } from '@code-pushup/utils'; -import { - formatBytes as formatBytes2, - formatDuration as formatDuration2, - html as html2, -} from '@code-pushup/utils'; -import { - formatBytes, - formatDuration, - html, - truncateText, - ui as ui8, -} from '@code-pushup/utils'; -// packages/plugin-lighthouse/src/lib/utils.ts -import { filterItemRefsBy, toArray as toArray7 } from '@code-pushup/utils'; - -var coverageTypeSchema = z.enum(['function', 'branch', 'line']); -var coverageResultSchema = z.union([ - z.object({ - resultsPath: z - .string({ - description: 'Path to coverage results for Nx setup.', - }) - .includes('lcov'), - pathToProject: z - .string({ - description: - 'Path from workspace root to project root. Necessary for LCOV reports which provide a relative path.', - }) - .optional(), - }), - z - .string({ - description: 'Path to coverage results for a single project setup.', - }) - .includes('lcov'), -]); -var coveragePluginConfigSchema = z.object({ - coverageToolCommand: z - .object({ - command: z - .string({ description: 'Command to run coverage tool.' }) - .min(1), - args: z - .array(z.string(), { - description: 'Arguments to be passed to the coverage tool.', - }) - .optional(), - }) - .optional(), - coverageTypes: z - .array(coverageTypeSchema, { - description: 'Coverage types measured. Defaults to all available types.', - }) - .min(1) - .default(['function', 'branch', 'line']), - reports: z - .array(coverageResultSchema, { - description: - 'Path to all code coverage report files. Only LCOV format is supported for now.', - }) - .min(1), - perfectScoreThreshold: z - .number({ - description: - 'Score will be 1 (perfect) for this coverage and above. Score range is 0 - 1.', - }) - .gt(0) - .max(1) - .optional(), -}); - -var WORKDIR = pluginWorkDir('coverage'); -var RUNNER_OUTPUT_PATH = path.join(WORKDIR, 'runner-output.json'); -var PLUGIN_CONFIG_PATH = path.join( - process.cwd(), - WORKDIR, - 'plugin-config.json', -); - -var godKnows = parseLcovExport; -var parseLcov = 'default' in godKnows ? godKnows.default : godKnows; - -var docCoveragePluginConfigSchema = z2.object({ - onlyAudits: z2.array(z2.string()).optional(), - sourceGlob: z2 - .array(z2.string()) - .default(['src/**/*.{ts,tsx}', '!**/*.spec.ts', '!**/*.test.ts']), -}); - -// packages/plugin-doc-coverage/src/lib/constants.ts -var PLUGIN_SLUG = 'doc-coverage'; -var AUDITS_MAP = { - 'classes-coverage': { - slug: 'classes-coverage', - title: 'Classes coverage', - description: 'Coverage of classes', - }, - 'methods-coverage': { - slug: 'methods-coverage', - title: 'Methods coverage', - description: 'Coverage of methods', - }, - 'functions-coverage': { - slug: 'functions-coverage', - title: 'Functions coverage', - description: 'Coverage of functions', - }, - 'interfaces-coverage': { - slug: 'interfaces-coverage', - title: 'Interfaces coverage', - description: 'Coverage of interfaces', - }, - 'variables-coverage': { - slug: 'variables-coverage', - title: 'Variables coverage', - description: 'Coverage of variables', - }, - 'properties-coverage': { - slug: 'properties-coverage', - title: 'Properties coverage', - description: 'Coverage of properties', - }, - 'types-coverage': { - slug: 'types-coverage', - title: 'Types coverage', - description: 'Coverage of types', - }, - 'enums-coverage': { - slug: 'enums-coverage', - title: 'Enums coverage', - description: 'Coverage of enums', - }, -}; -var groups = [ - { - slug: 'documentation-coverage', - title: 'Documentation coverage', - description: 'Documentation coverage', - refs: Object.keys(AUDITS_MAP).map(slug => { - switch (slug) { - case 'classes-coverage': - case 'functions-coverage': - case 'methods-coverage': - return { slug, weight: 2 }; - case 'interfaces-coverage': - case 'properties-coverage': - case 'types-coverage': - default: - return { slug, weight: 1 }; - } - }), - }, -]; - -function filterAuditsByPluginConfig(config2) { - const { onlyAudits } = config2; - if (!onlyAudits || onlyAudits.length === 0) { - return Object.values(AUDITS_MAP); - } - return Object.values(AUDITS_MAP).filter(audit => - onlyAudits.includes(audit.slug), - ); -} -function filterGroupsByOnlyAudits(groups2, options) { - const audits2 = filterAuditsByPluginConfig(options); - return groups2 - .map(group => ({ - ...group, - refs: group.refs.filter(ref => - audits2.some(audit => audit.slug === ref.slug), - ), - })) - .filter(group => group.refs.length > 0); -} -function trasformCoverageReportToAudits(coverageResult, options) { - return Object.entries(coverageResult) - .filter( - ([type]) => - !options.onlyAudits?.length || - options.onlyAudits.includes(`${type}-coverage`), - ) - .map(([type, items]) => { - const coverageType = type; - const coverage = items.coverage; - return { - slug: `${coverageType}-coverage`, - value: coverage, - score: coverage / 100, - displayValue: `${coverage} %`, - details: { - issues: items.issues.map(({ file, line }) => ({ - message: 'Missing documentation', - source: { file, position: { startLine: line } }, - severity: 'warning', - })), - }, - }; - }); -} -function getCoverageTypeFromKind(kind) { - switch (kind) { - case SyntaxKind.ClassDeclaration: - return 'classes'; - case SyntaxKind.MethodDeclaration: - return 'methods'; - case SyntaxKind.FunctionDeclaration: - return 'functions'; - case SyntaxKind.InterfaceDeclaration: - return 'interfaces'; - case SyntaxKind.EnumDeclaration: - return 'enums'; - case SyntaxKind.VariableDeclaration: - return 'variables'; - case SyntaxKind.PropertyDeclaration: - return 'properties'; - case SyntaxKind.TypeAliasDeclaration: - return 'types'; - default: - throw new Error(`Unsupported syntax kind: ${kind}`); - } -} - -// packages/plugin-doc-coverage/src/lib/runner/utils.ts -function createEmptyUnprocessedCoverageReport() { - return { - enums: { nodesCount: 0, issues: [] }, - interfaces: { nodesCount: 0, issues: [] }, - types: { nodesCount: 0, issues: [] }, - functions: { nodesCount: 0, issues: [] }, - variables: { nodesCount: 0, issues: [] }, - classes: { nodesCount: 0, issues: [] }, - methods: { nodesCount: 0, issues: [] }, - properties: { nodesCount: 0, issues: [] }, - }; -} -function calculateCoverage2(result) { - return Object.fromEntries( - Object.entries(result).map(([key, value]) => { - const type = key; - return [ - type, - { - coverage: - value.nodesCount === 0 - ? 100 - : (1 - value.issues.length / value.nodesCount) * 100, - issues: value.issues, - nodesCount: value.nodesCount, - }, - ]; - }), - ); -} - -// packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts -function processDocCoverage(config2) { - const project = new Project(); - project.addSourceFilesAtPaths(config2.sourceGlob); - return getUnprocessedCoverageReport(project.getSourceFiles()); -} -function getUnprocessedCoverageReport(sourceFiles) { - const unprocessedCoverageReport = sourceFiles.reduce( - (coverageReportOfAllFiles, sourceFile) => { - const filePath = sourceFile.getFilePath(); - const classes = sourceFile.getClasses(); - const allNodesFromFile = [ - ...sourceFile.getFunctions(), - ...classes, - ...getClassNodes(classes), - ...sourceFile.getTypeAliases(), - ...sourceFile.getEnums(), - ...sourceFile.getInterfaces(), - // ...sourceFile.getVariableStatements().flatMap(statement => statement.getDeclarations()) - ]; - const coverageReportOfCurrentFile = allNodesFromFile.reduce( - (acc, node) => { - const nodeType = getCoverageTypeFromKind(node.getKind()); - acc[nodeType].nodesCount++; - if (node.getJsDocs().length === 0) { - acc[nodeType].issues.push( - getUndocumentedNode( - filePath, - nodeType, - node.getName() || '', - node.getStartLineNumber(), - ), - ); - } - return acc; - }, - createEmptyUnprocessedCoverageReport(), - ); - return mergeCoverageResults( - coverageReportOfAllFiles, - coverageReportOfCurrentFile, - ); - }, - createEmptyUnprocessedCoverageReport(), - ); - return calculateCoverage2(unprocessedCoverageReport); -} -function mergeCoverageResults(results, current) { - return { - ...Object.fromEntries( - Object.entries(results).map(([key, value]) => { - const node = value; - const type = key; - return [ - type, - { - nodesCount: node.nodesCount + current[type].nodesCount, - issues: [...node.issues, ...current[type].issues], - }, - ]; - }), - ), - }; -} -function getClassNodes(classNodes) { - return classNodes.flatMap(classNode => [ - ...classNode.getMethods(), - ...classNode.getProperties(), - ]); -} -function getUndocumentedNode(file, type, name, line) { - return { file, type, name, line }; -} - -// packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts -var PLUGIN_TITLE = 'Documentation coverage'; -var PLUGIN_DESCRIPTION = 'Official Code PushUp documentation coverage plugin.'; -var PLUGIN_DOCS_URL = - 'https://www.npmjs.com/package/@code-pushup/doc-coverage-plugin/'; -async function docCoveragePlugin(config2) { - const docCoverageConfig = docCoveragePluginConfigSchema.parse(config2); - const groupsC = filterGroupsByOnlyAudits(groups, docCoverageConfig); - const auditsC = filterAuditsByPluginConfig(docCoverageConfig); - return { - slug: PLUGIN_SLUG, - title: PLUGIN_TITLE, - icon: 'folder-src', - description: PLUGIN_DESCRIPTION, - docsUrl: PLUGIN_DOCS_URL, - groups: filterGroupsByOnlyAudits(groups, docCoverageConfig), - audits: filterAuditsByPluginConfig(docCoverageConfig), - runner: createRunnerFunction(docCoverageConfig), - }; -} -function createRunnerFunction(config2) { - return () => { - const coverageResult = processDocCoverage(config2); - return trasformCoverageReportToAudits(coverageResult, config2); - }; -} - -// packages/plugin-doc-coverage/src/index.ts -var src_default = docCoveragePlugin; - -var patternsSchema = z3.union([z3.string(), z3.array(z3.string()).min(1)], { - description: - 'Lint target files. May contain file paths, directory paths or glob patterns', -}); -var eslintrcSchema = z3.string({ description: 'Path to ESLint config file' }); -var eslintTargetObjectSchema = z3.object({ - eslintrc: eslintrcSchema.optional(), - patterns: patternsSchema, -}); -var eslintTargetSchema = z3 - .union([patternsSchema, eslintTargetObjectSchema]) - .transform(target => - typeof target === 'string' || Array.isArray(target) - ? { patterns: target } - : target, - ); -var eslintPluginConfigSchema = z3 - .union([eslintTargetSchema, z3.array(eslintTargetSchema).min(1)]) - .transform(toArray); - -// packages/plugin-eslint/src/lib/runner/index.ts -var WORKDIR2 = pluginWorkDir2('eslint'); -var RUNNER_OUTPUT_PATH2 = path7.join(WORKDIR2, 'runner-output.json'); -var PLUGIN_CONFIG_PATH2 = path7.join( - process.cwd(), - WORKDIR2, - 'plugin-config.json', -); - -// packages/plugin-js-packages/src/lib/constants.ts -var defaultAuditLevelMapping = { - critical: 'error', - high: 'error', - moderate: 'warning', - low: 'warning', - info: 'info', -}; - -// packages/plugin-js-packages/src/lib/config.ts -var dependencyGroups = ['prod', 'dev', 'optional']; -var dependencyGroupSchema = z4.enum(dependencyGroups); -var packageCommandSchema = z4.enum(['audit', 'outdated']); -var packageManagerIdSchema = z4.enum([ - 'npm', - 'yarn-classic', - 'yarn-modern', - 'pnpm', -]); -var packageJsonPathSchema = z4 - .union([ - z4.array(z4.string()).min(1), - z4.object({ autoSearch: z4.literal(true) }), - ]) - .describe( - 'File paths to package.json. Looks only at root package.json by default', - ) - .default(['package.json']); -var packageAuditLevels = ['critical', 'high', 'moderate', 'low', 'info']; -var packageAuditLevelSchema = z4.enum(packageAuditLevels); -function fillAuditLevelMapping(mapping) { - return { - critical: mapping.critical ?? defaultAuditLevelMapping.critical, - high: mapping.high ?? defaultAuditLevelMapping.high, - moderate: mapping.moderate ?? defaultAuditLevelMapping.moderate, - low: mapping.low ?? defaultAuditLevelMapping.low, - info: mapping.info ?? defaultAuditLevelMapping.info, - }; -} -var jsPackagesPluginConfigSchema = z4.object({ - checks: z4 - .array(packageCommandSchema, { - description: - 'Package manager commands to be run. Defaults to both audit and outdated.', - }) - .min(1) - .default(['audit', 'outdated']), - packageManager: packageManagerIdSchema - .describe('Package manager to be used.') - .optional(), - dependencyGroups: z4 - .array(dependencyGroupSchema) - .min(1) - .default(['prod', 'dev']), - auditLevelMapping: z4 - .record(packageAuditLevelSchema, issueSeveritySchema, { - description: - 'Mapping of audit levels to issue severity. Custom mapping or overrides may be entered manually, otherwise has a default preset.', - }) - .default(defaultAuditLevelMapping) - .transform(fillAuditLevelMapping), - packageJsonPaths: packageJsonPathSchema, -}); - -function filterAuditResult(result, key, referenceResult) { - if (result.vulnerabilities.length === 0) { - return result; - } - const uniqueResult = result.vulnerabilities.reduce( - (acc, ref) => { - const matchReference = referenceResult ?? acc; - const isMatch = matchReference.vulnerabilities - .map(vulnerability => vulnerability[key]) - .includes(ref[key]); - if (isMatch) { - return { - vulnerabilities: acc.vulnerabilities, - summary: { - ...acc.summary, - [ref.severity]: acc.summary[ref.severity] - 1, - total: acc.summary.total - 1, - }, - }; - } - return { - vulnerabilities: [...acc.vulnerabilities, ref], - summary: acc.summary, - }; - }, - { vulnerabilities: [], summary: result.summary }, - ); - return { - vulnerabilities: uniqueResult.vulnerabilities, - summary: uniqueResult.summary, - }; -} - -// packages/plugin-js-packages/src/lib/package-managers/constants.ts -var COMMON_AUDIT_ARGS = ['audit', '--json']; -var COMMON_OUTDATED_ARGS = ['outdated', '--json']; - -function npmToAuditResult(output) { - const npmAudit = JSON.parse(output); - const vulnerabilities = objectToEntries2(npmAudit.vulnerabilities).map( - ([name, detail]) => { - const advisory = npmToAdvisory(name, npmAudit.vulnerabilities); - return { - name: name.toString(), - severity: detail.severity, - versionRange: detail.range, - directDependency: detail.isDirect ? true : (detail.effects[0] ?? ''), - fixInformation: npmToFixInformation(detail.fixAvailable), - ...(advisory != null && { - title: advisory.title, - url: advisory.url, - }), - }; - }, - ); - return { - vulnerabilities, - summary: npmAudit.metadata.vulnerabilities, - }; -} -function npmToFixInformation(fixAvailable) { - if (typeof fixAvailable === 'boolean') { - return fixAvailable ? 'Fix is available.' : ''; - } - return `Fix available: Update \`${fixAvailable.name}\` to version **${fixAvailable.version}**${fixAvailable.isSemVerMajor ? ' (breaking change).' : '.'}`; -} -function npmToAdvisory( - name, - vulnerabilities, - prevNodes = /* @__PURE__ */ new Set(), -) { - const advisory = vulnerabilities[name]?.via; - if ( - Array.isArray(advisory) && - advisory.length > 0 && - typeof advisory[0] === 'object' - ) { - return { title: advisory[0].title, url: advisory[0].url }; - } - if ( - Array.isArray(advisory) && - advisory.length > 0 && - advisory.every(value => typeof value === 'string') - ) { - let advisoryInfo = null; - let newReferences = []; - let advisoryInfoFound = false; - for (const via of advisory) { - if (!prevNodes.has(via)) { - newReferences.push(via); - } - } - while (newReferences.length > 0 && !advisoryInfoFound) { - const ref = newReferences.pop(); - prevNodes.add(ref); - const result = npmToAdvisory(ref, vulnerabilities, prevNodes); - if (result != null) { - advisoryInfo = { title: result.title, url: result.url }; - advisoryInfoFound = true; - } - } - return advisoryInfo; - } - return null; -} - -function npmToOutdatedResult(output) { - const npmOutdated = JSON.parse(output); - return objectToEntries3(npmOutdated) - .filter(entry => entry[1].current != null) - .map(([name, overview]) => ({ - name, - current: overview.current, - latest: overview.latest, - type: overview.type, - ...(overview.homepage != null && { url: overview.homepage }), - })); -} - -// packages/plugin-js-packages/src/lib/package-managers/npm/npm.ts -var npmDependencyOptions = { - prod: ['--omit=dev', '--omit=optional'], - dev: ['--include=dev', '--omit=optional'], - optional: ['--include=optional', '--omit=dev'], -}; -var npmPackageManager = { - slug: 'npm', - name: 'NPM', - command: 'npm', - icon: 'npm', - docs: { - homepage: 'https://docs.npmjs.com/', - audit: 'https://docs.npmjs.com/cli/commands/npm-audit', - outdated: 'https://docs.npmjs.com/cli/commands/npm-outdated', - }, - audit: { - getCommandArgs: groupDep => [ - ...COMMON_AUDIT_ARGS, - ...npmDependencyOptions[groupDep], - '--audit-level=none', - ], - unifyResult: npmToAuditResult, - // prod dependencies need to be filtered out manually since v10 - postProcessResult: results => { - const depGroups = objectToKeys3(results); - const devFilter = - results.dev && results.prod - ? filterAuditResult(results.dev, 'name', results.prod) - : results.dev; - const optionalFilter = - results.optional && results.prod - ? filterAuditResult(results.optional, 'name', results.prod) - : results.optional; - return { - ...(depGroups.includes('prod') && { prod: results.prod }), - ...(depGroups.includes('dev') && { dev: devFilter }), - ...(depGroups.includes('optional') && { optional: optionalFilter }), - }; - }, - }, - outdated: { - commandArgs: [...COMMON_OUTDATED_ARGS, '--long'], - unifyResult: npmToOutdatedResult, - }, -}; - -var WORKDIR3 = pluginWorkDir3('js-packages'); -var RUNNER_OUTPUT_PATH3 = path11.join(WORKDIR3, 'runner-output.json'); -var PLUGIN_CONFIG_PATH3 = path11.join( - process.cwd(), - WORKDIR3, - 'plugin-config.json', -); - -var outdatedSeverity = { - major: 'error', - premajor: 'info', - minor: 'warning', - preminor: 'info', - patch: 'info', - prepatch: 'info', - prerelease: 'info', -}; -var RELEASE_TYPES = objectToKeys6(outdatedSeverity); - -var DEFAULT_CHROME_FLAGS = [...DEFAULT_FLAGS, '--headless']; -var LIGHTHOUSE_PLUGIN_SLUG = 'lighthouse'; -var LIGHTHOUSE_OUTPUT_PATH = path15.join( - DEFAULT_PERSIST_OUTPUT_DIR, - LIGHTHOUSE_PLUGIN_SLUG, -); - -var { audits, categories } = defaultConfig; -var allRawLighthouseAudits = await Promise.all( - (audits ?? []).map(loadLighthouseAudit), -); -var LIGHTHOUSE_NAVIGATION_AUDITS = allRawLighthouseAudits - .filter( - audit => - audit.meta.supportedModes == null || - (Array.isArray(audit.meta.supportedModes) && - audit.meta.supportedModes.includes('navigation')), - ) - .map(audit => ({ - slug: audit.meta.id, - title: getMetaString(audit.meta.title), - description: getMetaString(audit.meta.description), - })); -var navigationAuditSlugs = new Set( - LIGHTHOUSE_NAVIGATION_AUDITS.map(({ slug }) => slug), -); -var LIGHTHOUSE_GROUPS = Object.entries(categories ?? {}).map( - ([id, category]) => ({ - slug: id, - title: getMetaString(category.title), - ...(category.description && { - description: getMetaString(category.description), - }), - refs: category.auditRefs - .filter(({ id: auditSlug }) => navigationAuditSlugs.has(auditSlug)) - .map(ref => ({ - slug: ref.id, - weight: ref.weight, - })), - }), -); -function getMetaString(value) { - if (typeof value === 'string') { - return value; - } - return value.formattedDefault; -} -async function loadLighthouseAudit(value) { - if (typeof value === 'object' && 'implementation' in value) { - return value.implementation; - } - if (typeof value === 'function') { - return value; - } - const file = typeof value === 'string' ? value : value.path; - const module = await import(`lighthouse/core/audits/${file}.js`); - return module.default; -} -var LIGHTHOUSE_REPORT_NAME = 'lighthouse-report.json'; -var DEFAULT_CLI_FLAGS = { - // default values extracted from - // https://github.com/GoogleChrome/lighthouse/blob/7d80178c37a1b600ea8f092fc0b098029799a659/cli/cli-flags.js#L80 - verbose: false, - saveAssets: false, - chromeFlags: DEFAULT_CHROME_FLAGS, - port: 0, - hostname: '127.0.0.1', - view: false, - channel: 'cli', - // custom overwrites in favour of the plugin - // hide logs by default - quiet: true, - onlyAudits: [], - skipAudits: [], - onlyCategories: [], - output: ['json'], - outputPath: path16.join(LIGHTHOUSE_OUTPUT_PATH, LIGHTHOUSE_REPORT_NAME), -}; - -// packages/plugin-lighthouse/src/lib/normalize-flags.ts -var { onlyCategories, ...originalDefaultCliFlags } = DEFAULT_CLI_FLAGS; -var DEFAULT_LIGHTHOUSE_OPTIONS = { - ...originalDefaultCliFlags, - onlyGroups: onlyCategories, -}; -var lighthouseUnsupportedCliFlags = [ - 'precomputedLanternDataPath', - // Path to the file where precomputed lantern data should be read from. - 'chromeIgnoreDefaultFlags', - // ignore default flags from Lighthouse CLI - // No error reporting implemented as in the source Sentry was involved - // See: https://github.com/GoogleChrome/lighthouse/blob/d8ccf70692216b7fa047a4eaa2d1277b0b7fe947/cli/bin.js#L124 - 'enableErrorReporting', - // enable error reporting - // lighthouse CLI specific debug logs - 'list-all-audits', - // Prints a list of all available audits and exits. - 'list-locales', - // Prints a list of all supported locales and exits. - 'list-trace-categories', - // Prints a list of all required trace categories and exits. -]; -var LIGHTHOUSE_UNSUPPORTED_CLI_FLAGS = new Set(lighthouseUnsupportedCliFlags); - -function lighthouseGroupRef(groupSlug, weight = 1) { - return { - plugin: LIGHTHOUSE_PLUGIN_SLUG, - slug: groupSlug, - type: 'group', - weight, - }; -} - -// code-pushup.preset.ts -var lighthouseCategories = [ - { - slug: 'performance', - title: 'Performance', - refs: [lighthouseGroupRef('performance')], - }, - { - slug: 'a11y', - title: 'Accessibility', - refs: [lighthouseGroupRef('accessibility')], - }, - { - slug: 'best-practices', - title: 'Best Practices', - refs: [lighthouseGroupRef('best-practices')], - }, - { - slug: 'seo', - title: 'SEO', - refs: [lighthouseGroupRef('seo')], - }, -]; -function getDocCoverageCategories(config2) { - return [ - { - slug: 'doc-coverage-cat', - title: 'Documentation coverage', - description: 'Measures how much of your code is **documented**.', - refs: filterGroupsByOnlyAudits(groups, config2).map(group => ({ - weight: 1, - type: 'group', - plugin: PLUGIN_SLUG, - slug: group.slug, - })), - }, - ]; -} -var docCoverageCoreConfig = async config2 => { - return { - plugins: [await src_default(config2)], - categories: getDocCoverageCategories(config2), - }; -}; - -// packages/utils/src/lib/merge-configs.ts -function mergeConfigs(config2, ...configs) { - return configs.reduce( - (acc, obj) => ({ - ...acc, - ...mergeCategories(acc.categories, obj.categories), - ...mergePlugins(acc.plugins, obj.plugins), - ...mergePersist(acc.persist, obj.persist), - ...mergeUpload(acc.upload, obj.upload), - }), - config2, - ); -} -function mergeCategories(a, b) { - if (!a && !b) { - return {}; - } - const mergedMap = /* @__PURE__ */ new Map(); - const addToMap = categories2 => { - categories2.forEach(newObject => { - if (mergedMap.has(newObject.slug)) { - const existingObject = mergedMap.get(newObject.slug); - mergedMap.set(newObject.slug, { - ...existingObject, - ...newObject, - refs: mergeByUniqueCategoryRefCombination( - existingObject?.refs, - newObject.refs, - ), - }); - } else { - mergedMap.set(newObject.slug, newObject); - } - }); - }; - if (a) { - addToMap(a); - } - if (b) { - addToMap(b); - } - return { categories: [...mergedMap.values()] }; -} -function mergePlugins(a, b) { - if (!a && !b) { - return { plugins: [] }; - } - const mergedMap = /* @__PURE__ */ new Map(); - const addToMap = plugins => { - plugins.forEach(newObject => { - mergedMap.set(newObject.slug, newObject); - }); - }; - if (a) { - addToMap(a); - } - if (b) { - addToMap(b); - } - return { plugins: [...mergedMap.values()] }; -} -function mergePersist(a, b) { - if (!a && !b) { - return {}; - } - if (a) { - return b ? { persist: { ...a, ...b } } : {}; - } else { - return { persist: b }; - } -} -function mergeByUniqueCategoryRefCombination(a, b) { - const map = /* @__PURE__ */ new Map(); - const addToMap = refs => { - refs.forEach(ref => { - const uniqueIdentification = `${ref.type}:${ref.plugin}:${ref.slug}`; - if (map.has(uniqueIdentification)) { - map.set(uniqueIdentification, { - ...map.get(uniqueIdentification), - ...ref, - }); - } else { - map.set(uniqueIdentification, ref); - } - }); - }; - if (a) { - addToMap(a); - } - if (b) { - addToMap(b); - } - return [...map.values()]; -} -function mergeUpload(a, b) { - if (!a && !b) { - return {}; - } - if (a) { - return b ? { upload: { ...a, ...b } } : {}; - } else { - return { upload: b }; - } -} - -// code-pushup.config.ts -var envSchema = z5.object({ - CP_SERVER: z5.string().url(), - CP_API_KEY: z5.string().min(1), - CP_ORGANIZATION: z5.string().min(1), - CP_PROJECT: z5.string().min(1), -}); -var { data: env } = await envSchema.safeParseAsync(process.env); -var config = { - ...(env && { - upload: { - server: env.CP_SERVER, - apiKey: env.CP_API_KEY, - organization: env.CP_ORGANIZATION, - project: env.CP_PROJECT, - }, - }), - plugins: [], -}; -var code_pushup_config_default = mergeConfigs( - config, - // await coverageCoreConfigNx(), - // await jsPackagesCoreConfig(), - // await lighthouseCoreConfig( - // 'https://github.com/code-pushup/cli?tab=readme-ov-file#code-pushup-cli/', - // ), - // await eslintCoreConfigNx(), - await docCoverageCoreConfig({ - sourceGlob: ['packages/**/*.ts', '!**/*.spec.ts', '!**/*.test.ts'], - onlyAudits: ['methods-coverage', 'functions-coverage'], - }), -); -export { code_pushup_config_default as default }; -//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["code-pushup.config.ts", "packages/plugin-coverage/src/lib/coverage-plugin.ts", "packages/plugin-coverage/src/lib/config.ts", "packages/plugin-coverage/src/lib/runner/index.ts", "packages/plugin-coverage/src/lib/runner/constants.ts", "packages/plugin-coverage/src/lib/runner/lcov/lcov-runner.ts", "packages/plugin-coverage/src/lib/runner/lcov/parse-lcov.ts", "packages/plugin-coverage/src/lib/runner/lcov/transform.ts", "packages/plugin-coverage/src/lib/nx/coverage-paths.ts", "packages/plugin-doc-coverage/src/lib/config.ts", "packages/plugin-doc-coverage/src/lib/constants.ts", "packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts", "packages/plugin-doc-coverage/src/lib/utils.ts", "packages/plugin-doc-coverage/src/lib/runner/utils.ts", "packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts", "packages/plugin-doc-coverage/src/index.ts", "packages/plugin-eslint/src/lib/eslint-plugin.ts", "packages/plugin-eslint/src/lib/config.ts", "packages/plugin-eslint/src/lib/meta/groups.ts", "packages/plugin-eslint/src/lib/meta/hash.ts", "packages/plugin-eslint/src/lib/meta/parse.ts", "packages/plugin-eslint/src/lib/meta/versions/flat.ts", "packages/plugin-eslint/src/lib/meta/versions/legacy.ts", "packages/plugin-eslint/src/lib/setup.ts", "packages/plugin-eslint/src/lib/meta/versions/detect.ts", "packages/plugin-eslint/src/lib/meta/transform.ts", "packages/plugin-eslint/src/lib/runner/index.ts", "packages/plugin-eslint/src/lib/runner/lint.ts", "packages/plugin-eslint/src/lib/runner/transform.ts", "packages/plugin-eslint/src/lib/nx/utils.ts", "packages/plugin-js-packages/src/lib/js-packages-plugin.ts", "packages/plugin-js-packages/src/lib/config.ts", "packages/plugin-js-packages/src/lib/constants.ts", "packages/plugin-js-packages/src/lib/package-managers/npm/npm.ts", "packages/plugin-js-packages/src/lib/runner/utils.ts", "packages/plugin-js-packages/src/lib/package-managers/constants.ts", "packages/plugin-js-packages/src/lib/package-managers/npm/audit-result.ts", "packages/plugin-js-packages/src/lib/package-managers/npm/outdated-result.ts", "packages/plugin-js-packages/src/lib/package-managers/pnpm/pnpm.ts", "packages/plugin-js-packages/src/lib/package-managers/pnpm/outdated-result.ts", "packages/plugin-js-packages/src/lib/package-managers/yarn-classic/audit-result.ts", "packages/plugin-js-packages/src/lib/package-managers/yarn-classic/outdated-result.ts", "packages/plugin-js-packages/src/lib/runner/index.ts", "packages/plugin-js-packages/src/lib/runner/audit/transform.ts", "packages/plugin-js-packages/src/lib/runner/constants.ts", "packages/plugin-js-packages/src/lib/runner/outdated/transform.ts", "packages/plugin-js-packages/src/lib/runner/outdated/constants.ts", "packages/plugin-js-packages/src/lib/package-managers/derive-package-manager.ts", "packages/plugin-js-packages/src/lib/package-managers/derive-yarn.ts", "packages/plugin-lighthouse/src/lib/lighthouse-plugin.ts", "packages/plugin-lighthouse/src/lib/constants.ts", "packages/plugin-lighthouse/src/lib/normalize-flags.ts", "packages/plugin-lighthouse/src/lib/runner/constants.ts", "packages/plugin-lighthouse/src/lib/runner/runner.ts", "packages/plugin-lighthouse/src/lib/runner/utils.ts", "packages/plugin-lighthouse/src/lib/runner/details/details.ts", "packages/plugin-lighthouse/src/lib/runner/details/opportunity.type.ts", "packages/plugin-lighthouse/src/lib/runner/details/table.type.ts", "packages/plugin-lighthouse/src/lib/runner/details/item-value.ts", "packages/plugin-lighthouse/src/lib/runner/details/utils.ts", "packages/plugin-lighthouse/src/lib/utils.ts", "code-pushup.preset.ts", "packages/utils/src/index.ts", "packages/utils/src/lib/execute-process.ts", "packages/utils/src/lib/reports/utils.ts", "packages/utils/src/lib/file-system.ts", "packages/utils/src/lib/formatting.ts", "packages/utils/src/lib/logging.ts", "packages/utils/src/lib/git/git.commits-and-tags.ts", "packages/utils/src/lib/semver.ts", "packages/utils/src/lib/git/git.ts", "packages/utils/src/lib/transform.ts", "packages/utils/src/lib/merge-configs.ts", "packages/utils/src/lib/progress.ts", "packages/utils/src/lib/reports/generate-md-report.ts", "packages/utils/src/lib/reports/formatting.ts", "packages/utils/src/lib/reports/generate-md-report-categoy-section.ts", "packages/utils/src/lib/reports/generate-md-reports-diff.ts", "packages/utils/src/lib/reports/generate-md-reports-diff-utils.ts", "packages/utils/src/lib/reports/load-report.ts", "packages/utils/src/lib/reports/log-stdout-summary.ts", "packages/utils/src/lib/zod-validation.ts"],
  "sourcesContent": ["const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/code-pushup.config.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/code-pushup.config.ts\";import 'dotenv/config';\nimport { z } from 'zod';\nimport { docCoverageCoreConfig } from './code-pushup.preset.js';\nimport type { CoreConfig } from './packages/models/src/index.js';\nimport { mergeConfigs } from './packages/utils/src/index.js';\n// load upload configuration from environment\nconst envSchema = z.object({\n  CP_SERVER: z.string().url(),\n  CP_API_KEY: z.string().min(1),\n  CP_ORGANIZATION: z.string().min(1),\n  CP_PROJECT: z.string().min(1),\n});\nconst { data: env } = await envSchema.safeParseAsync(process.env);\n\nconst config: CoreConfig = {\n  ...(env && {\n    upload: {\n      server: env.CP_SERVER,\n      apiKey: env.CP_API_KEY,\n      organization: env.CP_ORGANIZATION,\n      project: env.CP_PROJECT,\n    },\n  }),\n\n  plugins: [],\n};\n\nexport default mergeConfigs(\n  config,\n  // await coverageCoreConfigNx(),\n  // await jsPackagesCoreConfig(),\n  // await lighthouseCoreConfig(\n  //   'https://github.com/code-pushup/cli?tab=readme-ov-file#code-pushup-cli/',\n  // ),\n  // await eslintCoreConfigNx(),\n  await docCoverageCoreConfig({\n    sourceGlob: ['packages/**/*.ts', '!**/*.spec.ts', '!**/*.test.ts'],\n    onlyAudits: ['methods-coverage', 'functions-coverage']\n  }),\n);\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/coverage-plugin.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/coverage-plugin.ts\";import { createRequire } from 'node:module';\nimport path from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport type { Audit, Group, PluginConfig } from '@code-pushup/models';\nimport { capitalize } from '@code-pushup/utils';\nimport {\n  type CoveragePluginConfig,\n  type CoverageType,\n  coveragePluginConfigSchema,\n} from './config.js';\nimport { createRunnerConfig } from './runner/index.js';\nimport { coverageDescription, coverageTypeWeightMapper } from './utils.js';\n\n/**\n * Instantiates Code PushUp code coverage plugin for core config.\n *\n * @example\n * import coveragePlugin from '@code-pushup/coverage-plugin'\n *\n * export default {\n *   // ... core config ...\n *   plugins: [\n *     // ... other plugins ...\n *     await coveragePlugin({\n *       reports: [{ resultsPath: 'coverage/cli/lcov.info', pathToProject: 'packages/cli' }]\n *     })\n *   ]\n * }\n *\n * @returns Plugin configuration.\n */\nexport async function coveragePlugin(\n  config: CoveragePluginConfig,\n): Promise<PluginConfig> {\n  const coverageConfig = coveragePluginConfigSchema.parse(config);\n\n  const audits = coverageConfig.coverageTypes.map(\n    (type): Audit => ({\n      slug: `${type}-coverage`,\n      title: `${capitalize(type)} coverage`,\n      description: coverageDescription[type],\n    }),\n  );\n\n  const group: Group = {\n    slug: 'coverage',\n    title: 'Code coverage metrics',\n    description: 'Group containing all defined coverage types as audits.',\n    refs: audits.map(audit => ({\n      ...audit,\n      weight:\n        coverageTypeWeightMapper[\n          audit.slug.slice(0, audit.slug.indexOf('-')) as CoverageType\n        ],\n    })),\n  };\n\n  const runnerScriptPath = path.join(\n    fileURLToPath(path.dirname(import.meta.url)),\n    '..',\n    'bin.js',\n  );\n\n  const packageJson = createRequire(import.meta.url)(\n    '../../package.json',\n  ) as typeof import('../../package.json');\n\n  return {\n    slug: 'coverage',\n    title: 'Code coverage',\n    icon: 'folder-coverage-open',\n    description: 'Official Code PushUp code coverage plugin.',\n    docsUrl: 'https://www.npmjs.com/package/@code-pushup/coverage-plugin/',\n    packageName: packageJson.name,\n    version: packageJson.version,\n    audits,\n    groups: [group],\n    runner: await createRunnerConfig(runnerScriptPath, coverageConfig),\n  };\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/config.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/config.ts\";import { z } from 'zod';\n\nexport const coverageTypeSchema = z.enum(['function', 'branch', 'line']);\nexport type CoverageType = z.infer<typeof coverageTypeSchema>;\n\nexport const coverageResultSchema = z.union([\n  z.object({\n    resultsPath: z\n      .string({\n        description: 'Path to coverage results for Nx setup.',\n      })\n      .includes('lcov'),\n    pathToProject: z\n      .string({\n        description:\n          'Path from workspace root to project root. Necessary for LCOV reports which provide a relative path.',\n      })\n      .optional(),\n  }),\n  z\n    .string({\n      description: 'Path to coverage results for a single project setup.',\n    })\n    .includes('lcov'),\n]);\nexport type CoverageResult = z.infer<typeof coverageResultSchema>;\n\nexport const coveragePluginConfigSchema = z.object({\n  coverageToolCommand: z\n    .object({\n      command: z\n        .string({ description: 'Command to run coverage tool.' })\n        .min(1),\n      args: z\n        .array(z.string(), {\n          description: 'Arguments to be passed to the coverage tool.',\n        })\n        .optional(),\n    })\n    .optional(),\n  coverageTypes: z\n    .array(coverageTypeSchema, {\n      description: 'Coverage types measured. Defaults to all available types.',\n    })\n    .min(1)\n    .default(['function', 'branch', 'line']),\n  reports: z\n    .array(coverageResultSchema, {\n      description:\n        'Path to all code coverage report files. Only LCOV format is supported for now.',\n    })\n    .min(1),\n  perfectScoreThreshold: z\n    .number({\n      description:\n        'Score will be 1 (perfect) for this coverage and above. Score range is 0 - 1.',\n    })\n    .gt(0)\n    .max(1)\n    .optional(),\n});\nexport type CoveragePluginConfig = z.input<typeof coveragePluginConfigSchema>;\nexport type FinalCoveragePluginConfig = z.infer<\n  typeof coveragePluginConfigSchema\n>;\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner/index.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner/index.ts\";import { bold } from 'ansis';\nimport { writeFile } from 'node:fs/promises';\nimport path from 'node:path';\nimport type { AuditOutputs, RunnerConfig } from '@code-pushup/models';\nimport {\n  ProcessError,\n  ensureDirectoryExists,\n  executeProcess,\n  filePathToCliArg,\n  readJsonFile,\n  ui,\n} from '@code-pushup/utils';\nimport type { FinalCoveragePluginConfig } from '../config.js';\nimport { applyMaxScoreAboveThreshold } from '../utils.js';\nimport { PLUGIN_CONFIG_PATH, RUNNER_OUTPUT_PATH } from './constants.js';\nimport { lcovResultsToAuditOutputs } from './lcov/lcov-runner.js';\n\nexport async function executeRunner(): Promise<void> {\n  const { reports, coverageToolCommand, coverageTypes } =\n    await readJsonFile<FinalCoveragePluginConfig>(PLUGIN_CONFIG_PATH);\n\n  // Run coverage tool if provided\n  if (coverageToolCommand != null) {\n    const { command, args } = coverageToolCommand;\n    try {\n      await executeProcess({ command, args });\n    } catch (error) {\n      if (error instanceof ProcessError) {\n        ui().logger.error(bold('stdout from failed coverage tool process:'));\n        ui().logger.error(error.stdout);\n        ui().logger.error(bold('stderr from failed coverage tool process:'));\n        ui().logger.error(error.stderr);\n      }\n\n      throw new Error(\n        'Coverage plugin: Running coverage tool failed. Make sure all your provided tests are passing.',\n      );\n    }\n  }\n\n  // Calculate coverage from LCOV results\n  const auditOutputs = await lcovResultsToAuditOutputs(reports, coverageTypes);\n\n  await ensureDirectoryExists(path.dirname(RUNNER_OUTPUT_PATH));\n  await writeFile(RUNNER_OUTPUT_PATH, JSON.stringify(auditOutputs));\n}\n\nexport async function createRunnerConfig(\n  scriptPath: string,\n  config: FinalCoveragePluginConfig,\n): Promise<RunnerConfig> {\n  // Create JSON config for executeRunner\n  await ensureDirectoryExists(path.dirname(PLUGIN_CONFIG_PATH));\n  await writeFile(PLUGIN_CONFIG_PATH, JSON.stringify(config));\n\n  const threshold = config.perfectScoreThreshold;\n\n  return {\n    command: 'node',\n    args: [filePathToCliArg(scriptPath)],\n    outputFile: RUNNER_OUTPUT_PATH,\n    ...(threshold != null && {\n      outputTransform: outputs =>\n        applyMaxScoreAboveThreshold(outputs as AuditOutputs, threshold),\n    }),\n  };\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner/constants.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner/constants.ts\";import path from 'node:path';\nimport { pluginWorkDir } from '@code-pushup/utils';\n\nexport const WORKDIR = pluginWorkDir('coverage');\nexport const RUNNER_OUTPUT_PATH = path.join(WORKDIR, 'runner-output.json');\nexport const PLUGIN_CONFIG_PATH = path.join(\n  process.cwd(),\n  WORKDIR,\n  'plugin-config.json',\n);\n\nexport const INVALID_FUNCTION_NAME = '(empty-report)';\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner/lcov/lcov-runner.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner/lcov\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner/lcov/lcov-runner.ts\";import path from 'node:path';\nimport type { LCOVRecord } from 'parse-lcov';\nimport type { AuditOutputs } from '@code-pushup/models';\nimport { exists, readTextFile, toUnixNewlines, ui } from '@code-pushup/utils';\nimport type { CoverageResult, CoverageType } from '../../config.js';\nimport { mergeLcovResults } from './merge-lcov.js';\nimport { parseLcov } from './parse-lcov.js';\nimport {\n  lcovCoverageToAuditOutput,\n  recordToStatFunctionMapper,\n} from './transform.js';\nimport type { LCOVStat, LCOVStats } from './types.js';\n\n// Note: condition or statement coverage is not supported in LCOV\n// https://stackoverflow.com/questions/48260434/is-it-possible-to-check-condition-coverage-with-gcov\n\n/**\n *\n * @param results Paths to LCOV results\n * @param coverageTypes types of coverage to be considered\n * @returns Audit outputs with complete coverage data.\n */\nexport async function lcovResultsToAuditOutputs(\n  results: CoverageResult[],\n  coverageTypes: CoverageType[],\n): Promise<AuditOutputs> {\n  // Parse lcov files\n  const lcovResults = await parseLcovFiles(results);\n\n  // Merge multiple coverage reports for the same file\n  const mergedResults = mergeLcovResults(lcovResults);\n\n  // Calculate code coverage from all coverage results\n  const totalCoverageStats = getTotalCoverageFromLcovRecords(\n    mergedResults,\n    coverageTypes,\n  );\n\n  return coverageTypes\n    .map(coverageType => {\n      const stats = totalCoverageStats[coverageType];\n      if (!stats) {\n        return null;\n      }\n      return lcovCoverageToAuditOutput(stats, coverageType);\n    })\n    .filter(exists);\n}\n\n/**\n *\n * @param results Paths to LCOV results\n * @returns Array of parsed LCOVRecords.\n */\nexport async function parseLcovFiles(\n  results: CoverageResult[],\n): Promise<LCOVRecord[]> {\n  const parsedResults = await Promise.all(\n    results.map(async result => {\n      const resultsPath =\n        typeof result === 'string' ? result : result.resultsPath;\n      const lcovFileContent = await readTextFile(resultsPath);\n      if (lcovFileContent.trim() === '') {\n        ui().logger.warning(\n          `Coverage plugin: Empty lcov report file detected at ${resultsPath}.`,\n        );\n      }\n      const parsedRecords = parseLcov(toUnixNewlines(lcovFileContent));\n      return parsedRecords.map<LCOVRecord>(record => ({\n        ...record,\n        file:\n          typeof result === 'string' || result.pathToProject == null\n            ? record.file\n            : path.join(result.pathToProject, record.file),\n      }));\n    }),\n  );\n  if (parsedResults.length !== results.length) {\n    throw new Error('Some provided LCOV results were not valid.');\n  }\n\n  const flatResults = parsedResults.flat();\n\n  if (flatResults.length === 0) {\n    throw new Error('All provided results are empty.');\n  }\n\n  return flatResults;\n}\n\n/**\n *\n * @param records This function aggregates coverage stats from all coverage files\n * @param coverageTypes Types of coverage to be gathered\n * @returns Complete coverage stats for all defined types of coverage.\n */\nfunction getTotalCoverageFromLcovRecords(\n  records: LCOVRecord[],\n  coverageTypes: CoverageType[],\n): LCOVStats {\n  return records.reduce<LCOVStats>(\n    (acc, report) =>\n      Object.fromEntries([\n        ...Object.entries(acc),\n        ...(\n          Object.entries(\n            getCoverageStatsFromLcovRecord(report, coverageTypes),\n          ) as [CoverageType, LCOVStat][]\n        ).map(([type, stats]): [CoverageType, LCOVStat] => [\n          type,\n          {\n            totalFound: (acc[type]?.totalFound ?? 0) + stats.totalFound,\n            totalHit: (acc[type]?.totalHit ?? 0) + stats.totalHit,\n            issues: [...(acc[type]?.issues ?? []), ...stats.issues],\n          },\n        ]),\n      ]),\n    {},\n  );\n}\n\n/**\n * @param record record file data\n * @param coverageTypes types of coverage to be gathered\n * @returns Relevant coverage data from one lcov record file.\n */\nfunction getCoverageStatsFromLcovRecord(\n  record: LCOVRecord,\n  coverageTypes: CoverageType[],\n): LCOVStats {\n  return Object.fromEntries(\n    coverageTypes.map((coverageType): [CoverageType, LCOVStat] => [\n      coverageType,\n      recordToStatFunctionMapper[coverageType](record),\n    ]),\n  );\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner/lcov/parse-lcov.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner/lcov\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner/lcov/parse-lcov.ts\";import parseLcovExport from 'parse-lcov';\n\ntype ParseLcovFn = typeof parseLcovExport;\n\n// the parse-lcov export is inconsistent (sometimes it's .default, sometimes it's .default.default)\nconst godKnows = parseLcovExport as unknown as\n  | ParseLcovFn\n  | { default: ParseLcovFn };\n\nexport const parseLcov: ParseLcovFn =\n  'default' in godKnows ? godKnows.default : godKnows;\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner/lcov/transform.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner/lcov\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/runner/lcov/transform.ts\";import type { LCOVRecord } from 'parse-lcov';\nimport type { AuditOutput, Issue } from '@code-pushup/models';\nimport { toNumberPrecision, toOrdinal } from '@code-pushup/utils';\nimport type { CoverageType } from '../../config.js';\nimport { INVALID_FUNCTION_NAME } from '../constants.js';\nimport type { LCOVStat } from './types.js';\nimport { calculateCoverage, mergeConsecutiveNumbers } from './utils.js';\n\nexport function lcovReportToFunctionStat(record: LCOVRecord): LCOVStat {\n  const validRecord = removeEmptyReport(record);\n\n  return {\n    totalFound: validRecord.functions.found,\n    totalHit: validRecord.functions.hit,\n    issues:\n      validRecord.functions.hit < validRecord.functions.found\n        ? validRecord.functions.details\n            .filter(detail => !detail.hit)\n            .map(\n              (detail): Issue => ({\n                message: `Function ${detail.name} is not called in any test case.`,\n                severity: 'error',\n                source: {\n                  file: validRecord.file,\n                  position: { startLine: detail.line },\n                },\n              }),\n            )\n        : [],\n  };\n}\n\nfunction removeEmptyReport(record: LCOVRecord): LCOVRecord {\n  const validFunctions = record.functions.details.filter(\n    detail => detail.name !== INVALID_FUNCTION_NAME,\n  );\n\n  if (validFunctions.length === record.functions.found) {\n    return record;\n  }\n\n  return {\n    ...record,\n    functions: {\n      details: validFunctions,\n      found: validFunctions.length,\n      hit: validFunctions.reduce(\n        (acc, fn) => acc + (fn.hit != null && fn.hit > 0 ? 1 : 0),\n        0,\n      ),\n    },\n  };\n}\n\nexport function lcovReportToLineStat(record: LCOVRecord): LCOVStat {\n  const missingCoverage = record.lines.hit < record.lines.found;\n  const lines = missingCoverage\n    ? record.lines.details\n        .filter(detail => !detail.hit)\n        .map(detail => detail.line)\n    : [];\n\n  const linePositions = mergeConsecutiveNumbers(lines);\n\n  return {\n    totalFound: record.lines.found,\n    totalHit: record.lines.hit,\n    issues: missingCoverage\n      ? linePositions.map((linePosition): Issue => {\n          const lineReference =\n            linePosition.end == null\n              ? `Line ${linePosition.start} is`\n              : `Lines ${linePosition.start}-${linePosition.end} are`;\n\n          return {\n            message: `${lineReference} not covered in any test case.`,\n            severity: 'warning',\n            source: {\n              file: record.file,\n              position: {\n                startLine: linePosition.start,\n                endLine: linePosition.end,\n              },\n            },\n          };\n        })\n      : [],\n  };\n}\n\nexport function lcovReportToBranchStat(record: LCOVRecord): LCOVStat {\n  return {\n    totalFound: record.branches.found,\n    totalHit: record.branches.hit,\n    issues:\n      record.branches.hit < record.branches.found\n        ? record.branches.details\n            .filter(detail => !detail.taken)\n            .map(\n              (detail): Issue => ({\n                message: `${toOrdinal(\n                  detail.branch + 1,\n                )} branch is not taken in any test case.`,\n                severity: 'error',\n                source: {\n                  file: record.file,\n                  position: { startLine: detail.line },\n                },\n              }),\n            )\n        : [],\n  };\n}\n\nexport const recordToStatFunctionMapper = {\n  branch: lcovReportToBranchStat,\n  line: lcovReportToLineStat,\n  function: lcovReportToFunctionStat,\n};\n\n/**\n *\n * @param stat code coverage result for a given type\n * @param coverageType code coverage type\n * @returns Result of complete code ccoverage data coverted to AuditOutput\n */\nexport function lcovCoverageToAuditOutput(\n  stat: LCOVStat,\n  coverageType: CoverageType,\n): AuditOutput {\n  const coverage = calculateCoverage(stat.totalHit, stat.totalFound);\n  const MAX_DECIMAL_PLACES = 4;\n  const coveragePercentage = coverage * 100;\n\n  return {\n    slug: `${coverageType}-coverage`,\n    score: toNumberPrecision(coverage, MAX_DECIMAL_PLACES),\n    value: coveragePercentage,\n    displayValue: `${toNumberPrecision(coveragePercentage, 1)} %`,\n    details: {\n      issues: stat.issues,\n    },\n  };\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/nx/coverage-paths.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/nx\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-coverage/src/lib/nx/coverage-paths.ts\";/// <reference types=\"vitest\" />\nimport type {\n  ProjectConfiguration,\n  ProjectGraphProjectNode,\n  Tree,\n} from '@nx/devkit';\nimport type { JestExecutorOptions } from '@nx/jest/src/executors/jest/schema';\nimport type { VitestExecutorOptions } from '@nx/vite/executors';\nimport { bold } from 'ansis';\nimport path from 'node:path';\nimport { importModule, ui } from '@code-pushup/utils';\nimport type { CoverageResult } from '../config.js';\n\n/**\n * @param targets nx targets to be used for measuring coverage, test by default\n * @returns An array of coverage result information for the coverage plugin.\n */\nexport async function getNxCoveragePaths(\n  targets: string[] = ['test'],\n  verbose?: boolean,\n): Promise<CoverageResult[]> {\n  if (verbose) {\n    ui().logger.info(\n      bold('\uD83D\uDCA1 Gathering coverage from the following nx projects:'),\n    );\n  }\n\n  const { createProjectGraphAsync } = await import('@nx/devkit');\n  const { nodes } = await createProjectGraphAsync({ exitOnError: false });\n\n  const coverageResults = await Promise.all(\n    targets.map(async target => {\n      const relevantNodes = Object.values(nodes).filter(graph =>\n        hasNxTarget(graph, target),\n      );\n\n      return await Promise.all(\n        relevantNodes.map<Promise<CoverageResult>>(async ({ name, data }) => {\n          const coveragePaths = await getCoveragePathsForTarget(data, target);\n          if (verbose) {\n            ui().logger.info(`- ${name}: ${target}`);\n          }\n          return coveragePaths;\n        }),\n      );\n    }),\n  );\n\n  if (verbose) {\n    ui().logger.info('\\n');\n  }\n\n  return coverageResults.flat();\n}\n\nfunction hasNxTarget(\n  project: ProjectGraphProjectNode,\n  target: string,\n): boolean {\n  return project.data.targets != null && target in project.data.targets;\n}\n\nexport type VitestCoverageConfig = {\n  test: {\n    coverage?: {\n      reporter?: string[];\n      reportsDirectory?: string;\n    };\n  };\n};\n\nexport type JestCoverageConfig = {\n  coverageDirectory?: string;\n  coverageReporters?: string[];\n};\n\nexport async function getCoveragePathsForTarget(\n  project: ProjectConfiguration,\n  target: string,\n): Promise<CoverageResult> {\n  const targetConfig = project.targets?.[target];\n\n  if (!targetConfig) {\n    throw new Error(\n      `No configuration found for target ${target} in project ${project.name}`,\n    );\n  }\n\n  if (targetConfig.executor?.includes('@nx/vite')) {\n    return getCoveragePathForVitest(\n      targetConfig.options as VitestExecutorOptions,\n      project,\n      target,\n    );\n  }\n\n  if (targetConfig.executor?.includes('@nx/jest')) {\n    return getCoveragePathForJest(\n      targetConfig.options as JestExecutorOptions,\n      project,\n      target,\n    );\n  }\n\n  throw new Error(\n    `Unsupported executor ${targetConfig.executor}. Only @nx/vite and @nx/jest are currently supported.`,\n  );\n}\n\nexport async function getCoveragePathForVitest(\n  options: VitestExecutorOptions,\n  project: ProjectConfiguration,\n  target: string,\n) {\n  const {\n    default: { normalizeViteConfigFilePathWithTree },\n  } = await import('@nx/vite');\n  const config = normalizeViteConfigFilePathWithTree(\n    // HACK: only tree.exists is called, so injecting existSync from node:fs instead\n    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n    { exists: (await import('node:fs')).existsSync } as Tree,\n    project.root,\n    options.configFile,\n  );\n  if (!config) {\n    throw new Error(\n      `Could not find Vitest config file for target ${target} in project ${project.name}`,\n    );\n  }\n\n  const vitestConfig = await importModule<VitestCoverageConfig>({\n    filepath: config,\n    format: 'esm',\n  });\n\n  const reportsDirectory =\n    options.reportsDirectory ?? vitestConfig.test.coverage?.reportsDirectory;\n  const reporter = vitestConfig.test.coverage?.reporter;\n\n  if (reportsDirectory == null) {\n    throw new Error(\n      `Vitest coverage configuration at ${config} does not include coverage path for target ${target} in project ${project.name}. Add the path under coverage > reportsDirectory.`,\n    );\n  }\n\n  if (!reporter?.includes('lcov')) {\n    throw new Error(\n      `Vitest coverage configuration at ${config} does not include LCOV report format for target ${target} in project ${project.name}. Add 'lcov' format under coverage > reporter.`,\n    );\n  }\n\n  if (path.isAbsolute(reportsDirectory)) {\n    return path.join(reportsDirectory, 'lcov.info');\n  }\n  return {\n    pathToProject: project.root,\n    resultsPath: path.join(project.root, reportsDirectory, 'lcov.info'),\n  };\n}\n\nexport async function getCoveragePathForJest(\n  options: JestExecutorOptions,\n  project: ProjectConfiguration,\n  target: string,\n) {\n  const { jestConfig } = options;\n\n  const testConfig = await importModule<JestCoverageConfig>({\n    filepath: jestConfig,\n  });\n  const { coverageDirectory, coverageReporters } = {\n    ...testConfig,\n    ...options,\n  };\n\n  if (coverageDirectory == null) {\n    throw new Error(\n      `Jest coverage configuration at ${jestConfig} does not include coverage path for target ${target} in ${project.name}. Add the path under coverageDirectory.`,\n    );\n  }\n\n  if (!coverageReporters?.includes('lcov') && !('preset' in testConfig)) {\n    throw new Error(\n      `Jest coverage configuration at ${jestConfig} does not include LCOV report format for target ${target} in ${project.name}. Add 'lcov' format under coverageReporters.`,\n    );\n  }\n\n  if (path.isAbsolute(coverageDirectory)) {\n    return path.join(coverageDirectory, 'lcov.info');\n  }\n  return path.join(project.root, coverageDirectory, 'lcov.info');\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/config.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/config.ts\";import { z } from 'zod';\n\nexport const docCoveragePluginConfigSchema = z.object({\n  onlyAudits: z.array(z.string()).optional(),\n  sourceGlob: z\n    .array(z.string())\n    .default(['src/**/*.{ts,tsx}', '!**/*.spec.ts', '!**/*.test.ts']),\n});\n\nexport type DocCoveragePluginConfig = z.infer<\n  typeof docCoveragePluginConfigSchema\n>;", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/constants.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/constants.ts\";import type { Audit, Group } from \"@code-pushup/models\";\nimport type { AuditSlug } from \"./models\";\n\nexport const PLUGIN_SLUG = 'doc-coverage';\n\nexport const AUDITS_MAP: Record<AuditSlug, Audit> = {\n    'classes-coverage': {\n        slug: 'classes-coverage',\n        title: 'Classes coverage',\n        description: 'Coverage of classes',\n    },\n    'methods-coverage': {\n        slug: 'methods-coverage',\n        title: 'Methods coverage',\n        description: 'Coverage of methods',\n    },\n    'functions-coverage': {\n        slug: 'functions-coverage',\n        title: 'Functions coverage',\n        description: 'Coverage of functions',\n    },\n    'interfaces-coverage': {\n        slug: 'interfaces-coverage',\n        title: 'Interfaces coverage',\n        description: 'Coverage of interfaces',\n    },\n    'variables-coverage': {\n        slug: 'variables-coverage',\n        title: 'Variables coverage',\n        description: 'Coverage of variables',\n    },\n    'properties-coverage': {\n        slug: 'properties-coverage',\n        title: 'Properties coverage',\n        description: 'Coverage of properties',\n    },\n    'types-coverage': {\n        slug: 'types-coverage',\n        title: 'Types coverage',\n        description: 'Coverage of types',\n    },\n    'enums-coverage': {\n        slug: 'enums-coverage',\n        title: 'Enums coverage',\n        description: 'Coverage of enums',\n    },\n} as const;\n\nexport const groups: Group[] = [\n    {\n        slug: 'documentation-coverage',\n        title: 'Documentation coverage',\n        description: 'Documentation coverage',\n        refs: Object.keys(AUDITS_MAP).map(slug => {\n            switch (slug as AuditSlug) {\n                case 'classes-coverage':\n                case 'functions-coverage':\n                case 'methods-coverage':\n                    return { slug, weight: 2 }\n                case 'interfaces-coverage':\n                case 'properties-coverage':\n                case 'types-coverage':\n                default:\n                    return { slug, weight: 1 }\n            }\n        }),\n    }];", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/runner\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts\";import { ClassDeclaration, Project, SourceFile } from 'ts-morph';\nimport type { DocCoveragePluginConfig } from '../config.js';\nimport type {\n  CoverageResult,\n  CoverageType,\n  UndocumentedNode,\n  UnprocessedCoverageResult\n} from '../models.js';\nimport { getCoverageTypeFromKind } from '../utils.js';\nimport { calculateCoverage, createEmptyUnprocessedCoverageReport } from './utils.js';\n\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable functional/immutable-data */\n/* eslint-disable @typescript-eslint/max-params */\n/* eslint-disable functional/no-let */\n\n\n/**\n * Processes documentation coverage for TypeScript files in the specified path\n * @param toInclude - The file path pattern to include for documentation analysis\n * @returns {CoverageResult} Object containing coverage statistics and undocumented items\n */\nexport function processDocCoverage(config: DocCoveragePluginConfig): CoverageResult {\n  const project = new Project();\n  project.addSourceFilesAtPaths(config.sourceGlob);\n\n  return getUnprocessedCoverageReport(project.getSourceFiles());\n\n}\n\nexport function getUnprocessedCoverageReport(sourceFiles: SourceFile[]) {\n  const unprocessedCoverageReport = sourceFiles\n    .reduce((coverageReportOfAllFiles, sourceFile) => {\n\n      // Info of the file\n      const filePath = sourceFile.getFilePath();\n      const classes = sourceFile.getClasses();\n\n      // All nodes of the file\n      const allNodesFromFile = [\n        ...sourceFile.getFunctions(),\n        ...classes,\n        ...getClassNodes(classes),\n        ...sourceFile.getTypeAliases(),\n        ...sourceFile.getEnums(),\n        ...sourceFile.getInterfaces(),\n        // ...sourceFile.getVariableStatements().flatMap(statement => statement.getDeclarations())\n      ];\n\n      const coverageReportOfCurrentFile = allNodesFromFile.reduce((acc, node) => {\n        const nodeType = getCoverageTypeFromKind(node.getKind());\n        acc[nodeType].nodesCount++;\n        if (node.getJsDocs().length === 0) {\n          acc[nodeType].issues.push(\n            getUndocumentedNode(filePath, nodeType, node.getName() || '', node.getStartLineNumber())\n          );\n        }\n        return acc;\n      }, createEmptyUnprocessedCoverageReport());\n\n      return mergeCoverageResults(coverageReportOfAllFiles, coverageReportOfCurrentFile);\n    }, createEmptyUnprocessedCoverageReport());\n\n  return calculateCoverage(unprocessedCoverageReport);\n\n}\n\nfunction mergeCoverageResults(results: UnprocessedCoverageResult, current: UnprocessedCoverageResult) {\n  return {\n    ...Object.fromEntries(Object.entries(results).map(([key, value]) => {\n      const node = value as CoverageResult[CoverageType];\n      const type = key as CoverageType;\n      return [type, {\n        nodesCount: node.nodesCount + current[type].nodesCount,\n        issues: [...node.issues, ...current[type].issues],\n      }]\n    }))\n  } as UnprocessedCoverageResult;\n}\n\nfunction getClassNodes(classNodes: ClassDeclaration[]) {\n  return classNodes.flatMap(classNode => [...classNode.getMethods(), ...classNode.getProperties()])\n}\n\n/**\n * Creates an undocumented item entry\n * @param file - The file path where the item was found\n * @param type - The type of the undocumented item\n * @param name - The name of the undocumented item\n * @param line - The line number where the item appears\n * @returns {UndocumentedNode} The undocumented item entry\n */\nfunction getUndocumentedNode(file: string, type: CoverageType, name: string, line: number): UndocumentedNode {\n  return { file, type, name, line };\n}\n\n\n\n\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/utils.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/utils.ts\";import type { Audit, AuditOutputs, Group } from \"@code-pushup/models\";\nimport { SyntaxKind } from \"typescript\";\nimport type { DocCoveragePluginConfig } from \"./config\";\nimport { AUDITS_MAP } from \"./constants\";\nimport type { CoverageResult, CoverageType } from \"./models\";\n\n/**\n * Get audits based on the configuration.\n * If no audits are specified, return all audits.\n * If audits are specified, return only the specified audits.\n * @param config - The configuration object.\n * @returns The audits.\n */\nexport function filterAuditsByPluginConfig(config: Pick<DocCoveragePluginConfig, 'onlyAudits'>): Audit[] {\n    const { onlyAudits } = config\n\n    if (!onlyAudits || onlyAudits.length === 0) {\n        return Object.values(AUDITS_MAP);\n    }\n\n    return Object.values(AUDITS_MAP).filter(audit => onlyAudits.includes(audit.slug));\n\n}\n\n// return groups.filter(group => group.refs.some(ref => audits.some(audit => audit.slug === ref.slug)));\n\n/**\n * Filter groups by the audits that are specified in the configuration.\n * The groups refs are filtered to only include the audits that are specified in the configuration.\n * @param groups - The groups to filter.\n * @param options - The configuration object.\n * @returns The filtered groups.\n */\nexport function filterGroupsByOnlyAudits(groups: Group[], options: Pick<DocCoveragePluginConfig, 'onlyAudits'>): Group[] {\n    const audits = filterAuditsByPluginConfig(options);\n    return groups\n        .map(group => ({\n            ...group,\n            refs: group.refs.filter(ref => audits.some(audit => audit.slug === ref.slug))\n        }))\n        .filter(group => group.refs.length > 0);;\n}\n\n\n/**\n * Transforms the coverage report into audit outputs.\n * @param coverageResult - The coverage result containing undocumented items and coverage statistics\n * @param options - Configuration options specifying which audits to include\n * @returns Audit outputs with coverage scores and details about undocumented items\n */\nexport function trasformCoverageReportToAudits(coverageResult: CoverageResult, options: Pick<DocCoveragePluginConfig, 'onlyAudits'>): AuditOutputs {\n\n    return Object.entries(coverageResult)\n        .filter(([type]) => !options.onlyAudits?.length || options.onlyAudits.includes(`${type}-coverage`))\n        .map(([type, items]) => {\n            const coverageType = type as CoverageType;\n            const coverage = items.coverage;\n\n            return {\n                slug: `${coverageType}-coverage`,\n                value: coverage,\n                score: coverage / 100,\n                displayValue: `${coverage} %`,\n                details: {\n                    issues: items.issues.map(({ file, line }) => ({\n                        message: 'Missing documentation',\n                        source: { file, position: { startLine: line } },\n                        severity: 'warning',\n                    })),\n                },\n            };\n        });\n}\n\nexport function getCoverageTypeFromKind(kind: SyntaxKind): CoverageType {\n    switch (kind) {\n        case SyntaxKind.ClassDeclaration:\n            return 'classes';\n        case SyntaxKind.MethodDeclaration:\n            return 'methods';\n        case SyntaxKind.FunctionDeclaration:\n            return 'functions';\n        case SyntaxKind.InterfaceDeclaration:\n            return 'interfaces';\n        case SyntaxKind.EnumDeclaration:\n            return 'enums';\n        case SyntaxKind.VariableDeclaration:\n            return 'variables';\n        case SyntaxKind.PropertyDeclaration:\n            return 'properties';\n        case SyntaxKind.TypeAliasDeclaration:\n            return 'types';\n        default:\n            throw new Error(`Unsupported syntax kind: ${kind}`);\n    }\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/runner/utils.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/runner\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/runner/utils.ts\";import type { CoverageResult, CoverageType, UnprocessedCoverageResult } from \"../models\";\n\nexport function createEmptyUnprocessedCoverageReport(): UnprocessedCoverageResult {\n    return {\n        enums: { nodesCount: 0, issues: [] },\n        interfaces: { nodesCount: 0, issues: [] },\n        types: { nodesCount: 0, issues: [] },\n        functions: { nodesCount: 0, issues: [] },\n        variables: { nodesCount: 0, issues: [] },\n        classes: { nodesCount: 0, issues: [] },\n        methods: { nodesCount: 0, issues: [] },\n        properties: { nodesCount: 0, issues: [] },\n    }\n}\n\nexport function calculateCoverage(result: UnprocessedCoverageResult) {\n    return Object.fromEntries(Object.entries(result).map(([key, value]) => {\n        const type = key as CoverageType;\n        return [type, {\n            coverage: value.nodesCount === 0 ? 100 : (1 - value.issues.length / value.nodesCount) * 100,\n            issues: value.issues,\n            nodesCount: value.nodesCount\n        }]\n    })) as CoverageResult;\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts\";import type { AuditOutputs, PluginConfig, RunnerFunction } from '@code-pushup/models';\nimport {\n  type DocCoveragePluginConfig,\n  docCoveragePluginConfigSchema,\n} from './config.js';\nimport { groups, PLUGIN_SLUG } from './constants.js';\nimport { processDocCoverage } from './runner/doc-processer.js';\nimport { filterAuditsByPluginConfig, filterGroupsByOnlyAudits, trasformCoverageReportToAudits } from './utils.js';\n\nconst PLUGIN_TITLE = 'Documentation coverage';\n\nconst PLUGIN_DESCRIPTION = 'Official Code PushUp documentation coverage plugin.';\n\nconst PLUGIN_DOCS_URL = 'https://www.npmjs.com/package/@code-pushup/doc-coverage-plugin/';\n\n/**\n * Instantiates Code PushUp documentation coverage plugin for core config.\n *\n * @example\n * import docCoveragePlugin from '@code-pushup/doc-coverage-plugin'\n *\n * export default {\n *   // ... core config ...\n *   plugins: [\n *     // ... other plugins ...\n *     await docCoveragePlugin({\n *       sourceGlob: 'src&#47;**&#47;*.{ts,tsx}'\n *     })\n *   ]\n * }\n *\n * @returns Plugin configuration.\n */\n\n\nexport async function docCoveragePlugin(config: DocCoveragePluginConfig): Promise<PluginConfig> {\n\n\n  const docCoverageConfig = docCoveragePluginConfigSchema.parse(config);\n\n\n  const groupsC = filterGroupsByOnlyAudits(groups, docCoverageConfig);\n  const auditsC = filterAuditsByPluginConfig(docCoverageConfig);\n\n  return {\n    slug: PLUGIN_SLUG,\n    title: PLUGIN_TITLE,\n    icon: 'folder-src',\n    description: PLUGIN_DESCRIPTION,\n    docsUrl: PLUGIN_DOCS_URL,\n    groups: filterGroupsByOnlyAudits(groups, docCoverageConfig),\n    audits: filterAuditsByPluginConfig(docCoverageConfig),\n    runner: createRunnerFunction(docCoverageConfig),\n  };\n}\n\nexport function createRunnerFunction(config: DocCoveragePluginConfig): RunnerFunction {\n  return (): AuditOutputs => {\n    const coverageResult = processDocCoverage(config)\n    return trasformCoverageReportToAudits(coverageResult, config);\n  };\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/index.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/src/index.ts\";import { docCoveragePlugin } from './lib/doc-coverage-plugin.js';\n\nexport default docCoveragePlugin;\nexport type { DocCoveragePluginConfig } from './lib/config.js';\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/eslint-plugin.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/eslint-plugin.ts\";import { createRequire } from 'node:module';\nimport path from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport type { PluginConfig } from '@code-pushup/models';\nimport { type ESLintPluginConfig, eslintPluginConfigSchema } from './config.js';\nimport { listAuditsAndGroups } from './meta/index.js';\nimport { createRunnerConfig } from './runner/index.js';\n\n/**\n * Instantiates Code PushUp ESLint plugin for use in core config.\n *\n * @example\n * import eslintPlugin from '@code-pushup/eslint-plugin'\n *\n * export default {\n *   // ... core config ...\n *   plugins: [\n *     // ... other plugins ...\n *     await eslintPlugin({\n *       eslintrc: '.eslintrc.json',\n *       patterns: ['src', 'test/*.spec.js']\n *     })\n *   ]\n * }\n *\n * @param config Configuration options.\n * @returns Plugin configuration as a promise.\n */\nexport async function eslintPlugin(\n  config: ESLintPluginConfig,\n): Promise<PluginConfig> {\n  const targets = eslintPluginConfigSchema.parse(config);\n\n  const { audits, groups } = await listAuditsAndGroups(targets);\n\n  const runnerScriptPath = path.join(\n    fileURLToPath(path.dirname(import.meta.url)),\n    '..',\n    'bin.js',\n  );\n\n  const packageJson = createRequire(import.meta.url)(\n    '../../package.json',\n  ) as typeof import('../../package.json');\n\n  return {\n    slug: 'eslint',\n    title: 'ESLint',\n    icon: 'eslint',\n    description: 'Official Code PushUp ESLint plugin',\n    docsUrl: 'https://www.npmjs.com/package/@code-pushup/eslint-plugin',\n    packageName: packageJson.name,\n    version: packageJson.version,\n\n    audits,\n    groups,\n\n    runner: await createRunnerConfig(runnerScriptPath, audits, targets),\n  };\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/config.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/config.ts\";import { z } from 'zod';\nimport { toArray } from '@code-pushup/utils';\n\nconst patternsSchema = z.union([z.string(), z.array(z.string()).min(1)], {\n  description:\n    'Lint target files. May contain file paths, directory paths or glob patterns',\n});\n\nconst eslintrcSchema = z.string({ description: 'Path to ESLint config file' });\n\nconst eslintTargetObjectSchema = z.object({\n  eslintrc: eslintrcSchema.optional(),\n  patterns: patternsSchema,\n});\ntype ESLintTargetObject = z.infer<typeof eslintTargetObjectSchema>;\n\nexport const eslintTargetSchema = z\n  .union([patternsSchema, eslintTargetObjectSchema])\n  .transform(\n    (target): ESLintTargetObject =>\n      typeof target === 'string' || Array.isArray(target)\n        ? { patterns: target }\n        : target,\n  );\nexport type ESLintTarget = z.infer<typeof eslintTargetSchema>;\n\nexport const eslintPluginConfigSchema = z\n  .union([eslintTargetSchema, z.array(eslintTargetSchema).min(1)])\n  .transform(toArray);\nexport type ESLintPluginConfig = z.input<typeof eslintPluginConfigSchema>;\n\nexport type ESLintPluginRunnerConfig = {\n  targets: ESLintTarget[];\n  slugs: string[];\n};\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/groups.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/groups.ts\";import type { Rule } from 'eslint';\nimport type { Group, GroupRef } from '@code-pushup/models';\nimport { objectToKeys, slugify } from '@code-pushup/utils';\nimport { ruleToSlug } from './hash.js';\nimport { type RuleData, parseRuleId } from './parse.js';\n\ntype RuleType = NonNullable<Rule.RuleMetaData['type']>;\n\n// docs on meta.type: https://eslint.org/docs/latest/extend/custom-rules#rule-structure\nconst typeGroups: Record<RuleType, Omit<Group, 'refs'>> = {\n  problem: {\n    slug: 'problems',\n    title: 'Problems',\n    description:\n      'Code that either will cause an error or may cause confusing behavior. Developers should consider this a high priority to resolve.',\n  },\n  suggestion: {\n    slug: 'suggestions',\n    title: 'Suggestions',\n    description:\n      \"Something that could be done in a better way but no errors will occur if the code isn't changed.\",\n  },\n  layout: {\n    slug: 'formatting',\n    title: 'Formatting',\n    description:\n      'Primarily about whitespace, semicolons, commas, and parentheses, all the parts of the program that determine how the code looks rather than how it executes.',\n  },\n};\n\nexport function groupsFromRuleTypes(rules: RuleData[]): Group[] {\n  const allTypes = objectToKeys(typeGroups);\n\n  const auditSlugsMap = rules.reduce<Partial<Record<RuleType, string[]>>>(\n    (acc, rule) =>\n      rule.meta.type == null\n        ? acc\n        : {\n            ...acc,\n            [rule.meta.type]: [\n              ...(acc[rule.meta.type] ?? []),\n              ruleToSlug(rule),\n            ],\n          },\n    {},\n  );\n\n  return allTypes\n    .map(type => ({\n      ...typeGroups[type],\n      refs:\n        auditSlugsMap[type]?.map((slug): GroupRef => ({ slug, weight: 1 })) ??\n        [],\n    }))\n    .filter(group => group.refs.length);\n}\n\nexport function groupsFromRuleCategories(rules: RuleData[]): Group[] {\n  const categoriesMap = rules.reduce<Record<string, Record<string, string[]>>>(\n    (acc, rule) => {\n      // meta.docs.category still used by some popular plugins (e.g. import, react, functional)\n      const category = rule.meta.docs?.category;\n      if (!category) {\n        return acc;\n      }\n      const { plugin = '' } = parseRuleId(rule.id);\n      return {\n        ...acc,\n        [plugin]: {\n          ...acc[plugin],\n          [category]: [...(acc[plugin]?.[category] ?? []), ruleToSlug(rule)],\n        },\n      };\n    },\n    {},\n  );\n\n  const groups = Object.entries(categoriesMap).flatMap(([plugin, categories]) =>\n    Object.entries(categories).map(\n      ([category, slugs]): Group => ({\n        slug: `${slugify(plugin)}-${slugify(category)}`,\n        title: `${category} (${plugin})`,\n        refs: slugs.map(slug => ({ slug, weight: 1 })),\n      }),\n    ),\n  );\n\n  return groups.toSorted((a, b) => a.slug.localeCompare(b.slug));\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/hash.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/hash.ts\";import { createHash } from 'node:crypto';\nimport { slugify } from '@code-pushup/utils';\nimport { type RuleData, resolveRuleOptions } from './parse.js';\n\nexport function ruleToSlug(rule: RuleData): string {\n  return ruleIdToSlug(rule.id, resolveRuleOptions(rule));\n}\n\nexport function ruleIdToSlug(\n  ruleId: string,\n  options: unknown[] | undefined,\n): string {\n  const slug = slugify(ruleId);\n  if (!options?.length) {\n    return slug;\n  }\n  return `${slug}-${jsonHash(options)}`;\n}\n\nexport function jsonHash(data: unknown, bytes = 8): string {\n  return createHash('shake256', { outputLength: bytes })\n    .update(JSON.stringify(data) || 'null')\n    .digest('hex');\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/parse.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/parse.ts\";import type { Linter, Rule } from 'eslint';\nimport { toArray } from '@code-pushup/utils';\n\nexport type RuleData = {\n  id: string;\n  meta: Rule.RuleMetaData;\n  options: unknown[] | undefined;\n};\n\nexport function parseRuleId(ruleId: string): { plugin?: string; name: string } {\n  const i = ruleId.startsWith('@')\n    ? ruleId.lastIndexOf('/')\n    : ruleId.indexOf('/');\n  if (i === -1) {\n    return { name: ruleId };\n  }\n  return {\n    plugin: ruleId.slice(0, i),\n    name: ruleId.slice(i + 1),\n  };\n}\n\nexport function isRuleOff(entry: Linter.RuleEntry<unknown[]>): boolean {\n  const level = Array.isArray(entry) ? entry[0] : entry;\n\n  switch (level) {\n    case 0:\n    case 'off':\n      return true;\n    case 1:\n    case 2:\n    case 'warn':\n    case 'error':\n      return false;\n  }\n}\n\nexport function optionsFromRuleEntry(\n  entry: Linter.RuleEntry<unknown[]>,\n): unknown[] {\n  return toArray(entry).slice(1);\n}\n\nexport function resolveRuleOptions(rule: RuleData): unknown[] | undefined {\n  if (rule.options?.length) {\n    return rule.options;\n  }\n  return rule.meta.defaultOptions;\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/versions/flat.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/versions\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/versions/flat.ts\";import type { Linter, Rule } from 'eslint';\nimport { builtinRules } from 'eslint/use-at-your-own-risk';\nimport path from 'node:path';\nimport { pathToFileURL } from 'node:url';\nimport { exists, findNearestFile, toArray, ui } from '@code-pushup/utils';\nimport type { ESLintTarget } from '../../config.js';\nimport { jsonHash } from '../hash.js';\nimport {\n  type RuleData,\n  isRuleOff,\n  optionsFromRuleEntry,\n  parseRuleId,\n} from '../parse.js';\n\nexport async function loadRulesForFlatConfig({\n  eslintrc,\n}: Pick<ESLintTarget, 'eslintrc'>): Promise<RuleData[]> {\n  const config = eslintrc\n    ? await loadConfigByPath(eslintrc)\n    : await loadConfigByDefaultLocation();\n  const configs = toArray(config);\n\n  const rules = findEnabledRulesWithOptions(configs);\n  return rules\n    .map(rule => {\n      const meta = findRuleMeta(rule.id, configs);\n      if (!meta) {\n        ui().logger.warning(`Cannot find metadata for rule ${rule.id}`);\n        return null;\n      }\n      return { ...rule, meta };\n    })\n    .filter(exists);\n}\n\ntype FlatConfig = Linter.Config | Linter.Config[];\n\nasync function loadConfigByDefaultLocation(): Promise<FlatConfig> {\n  const flatConfigFileNames = [\n    'eslint.config.js',\n    'eslint.config.mjs',\n    'eslint.config.cjs',\n  ];\n  const configPath = await findNearestFile(flatConfigFileNames);\n  if (configPath) {\n    return loadConfigByPath(configPath);\n  }\n  throw new Error(\n    [\n      `ESLint config file not found - expected ${flatConfigFileNames.join('/')} in ${process.cwd()} or some parent directory`,\n      'If your ESLint config is in a non-standard location, use the `eslintrc` parameter to specify the path.',\n    ].join('\\n'),\n  );\n}\n\nasync function loadConfigByPath(configPath: string): Promise<FlatConfig> {\n  const absolutePath = path.isAbsolute(configPath)\n    ? configPath\n    : path.join(process.cwd(), configPath);\n  const url = pathToFileURL(absolutePath).toString();\n  const mod = (await import(url)) as FlatConfig | { default: FlatConfig };\n  return 'default' in mod ? mod.default : mod;\n}\n\nfunction findEnabledRulesWithOptions(\n  configs: Linter.Config[],\n): Omit<RuleData, 'meta'>[] {\n  const enabledRules = configs\n    .flatMap(({ rules }) => Object.entries(rules ?? {}))\n    .filter(([, entry]) => entry != null && !isRuleOff(entry))\n    .map(([id, entry]) => ({\n      id,\n      options: entry ? optionsFromRuleEntry(entry) : [],\n    }));\n  const uniqueRulesMap = new Map(\n    enabledRules.map(({ id, options }) => [\n      `${id}::${jsonHash(options)}`,\n      { id, options },\n    ]),\n  );\n  return [...uniqueRulesMap.values()];\n}\n\nfunction findRuleMeta(\n  ruleId: string,\n  configs: Linter.Config[],\n): Rule.RuleMetaData | undefined {\n  const { plugin, name } = parseRuleId(ruleId);\n  if (!plugin) {\n    return findBuiltinRuleMeta(name);\n  }\n  return findPluginRuleMeta(plugin, name, configs);\n}\n\nfunction findBuiltinRuleMeta(name: string): Rule.RuleMetaData | undefined {\n  const rule = builtinRules.get(name);\n  return rule?.meta;\n}\n\nfunction findPluginRuleMeta(\n  plugin: string,\n  name: string,\n  configs: Linter.Config[],\n): Rule.RuleMetaData | undefined {\n  const config = configs.find(({ plugins = {} }) => plugin in plugins);\n  const rule = config?.plugins?.[plugin]?.rules?.[name];\n\n  if (typeof rule === 'function') {\n    ui().logger.warning(\n      `Cannot parse metadata for rule ${plugin}/${name}, plugin registers it as a function`,\n    );\n    return undefined;\n  }\n\n  return rule?.meta;\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/versions/legacy.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/versions\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/versions/legacy.ts\";import type { ESLint, Linter } from 'eslint';\nimport { distinct, exists, toArray, ui } from '@code-pushup/utils';\nimport type { ESLintTarget } from '../../config.js';\nimport { setupESLint } from '../../setup.js';\nimport { type RuleData, isRuleOff, optionsFromRuleEntry } from '../parse.js';\n\nexport async function loadRulesForLegacyConfig({\n  eslintrc,\n  patterns,\n}: ESLintTarget): Promise<RuleData[]> {\n  const eslint = await setupESLint(eslintrc);\n\n  const configs = await toArray(patterns).reduce(\n    async (acc, pattern) => [\n      ...(await acc),\n      (await eslint.calculateConfigForFile(pattern)) as Linter.LegacyConfig,\n    ],\n    Promise.resolve<Linter.LegacyConfig[]>([]),\n  );\n\n  const rulesIds = distinct(\n    configs.flatMap(config => Object.keys(config.rules ?? {})),\n  );\n  const rulesMeta = eslint.getRulesMetaForResults([\n    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n    {\n      messages: rulesIds.map(ruleId => ({ ruleId })),\n      suppressedMessages: [] as Linter.SuppressedLintMessage[],\n    } as ESLint.LintResult,\n  ]);\n\n  return configs\n    .flatMap(config => Object.entries(config.rules ?? {}))\n    .map(([id, entry]): RuleData | null => {\n      if (entry == null || isRuleOff(entry)) {\n        return null;\n      }\n      const ruleMeta = rulesMeta[id];\n      if (!ruleMeta) {\n        ui().logger.warning(`Metadata not found for ESLint rule ${id}`);\n        return null;\n      }\n      // ignoring meta.defaultOptions to match legacy config handling in calculateConfigForFile\n      const { defaultOptions: _, ...meta } = ruleMeta;\n      const options = optionsFromRuleEntry(entry);\n      return { id, meta, options };\n    })\n    .filter(exists);\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/setup.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/setup.ts\";import { ESLint } from 'eslint';\nimport type { ESLintTarget } from './config.js';\n\nexport async function setupESLint(eslintrc: ESLintTarget['eslintrc']) {\n  const eslintConstructor = await loadESLint();\n  return new eslintConstructor({\n    overrideConfigFile: eslintrc,\n    errorOnUnmatchedPattern: false,\n  });\n}\n\nasync function loadESLint() {\n  const eslint = await import('eslint');\n  // loadESLint added to public API in v9, selects ESLint or LegacyESLint based on environment\n  if ('loadESLint' in eslint && typeof eslint.loadESLint === 'function') {\n    return (await eslint.loadESLint()) as typeof ESLint;\n  }\n  return ESLint;\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/versions/detect.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/versions\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/versions/detect.ts\";import { ESLint } from 'eslint';\nimport { fileExists } from '@code-pushup/utils';\nimport type { ConfigFormat } from './formats.js';\n\n// relevant ESLint docs:\n// - https://eslint.org/docs/latest/use/configure/configuration-files\n// - https://eslint.org/docs/latest/use/configure/configuration-files-deprecated\n// - https://eslint.org/docs/v8.x/use/configure/configuration-files-new\n\nexport async function detectConfigVersion(): Promise<ConfigFormat> {\n  if (process.env['ESLINT_USE_FLAT_CONFIG'] === 'true') {\n    return 'flat';\n  }\n  if (process.env['ESLINT_USE_FLAT_CONFIG'] === 'false') {\n    return 'legacy';\n  }\n  if (ESLint.version.startsWith('8.')) {\n    if (await fileExists('eslint.config.js')) {\n      return 'flat';\n    }\n    return 'legacy';\n  }\n  return 'flat';\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/transform.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/meta/transform.ts\";import type { Audit } from '@code-pushup/models';\nimport { truncateDescription, truncateTitle } from '@code-pushup/utils';\nimport { ruleToSlug } from './hash.js';\nimport type { RuleData } from './parse.js';\n\nexport function ruleToAudit(rule: RuleData): Audit {\n  const name = rule.id.split('/').at(-1) ?? rule.id;\n  const plugin =\n    name === rule.id ? null : rule.id.slice(0, rule.id.lastIndexOf('/'));\n  const pluginContext = plugin ? `, from _${plugin}_ plugin` : '';\n\n  const lines: string[] = [\n    `ESLint rule **${name}**${pluginContext}.`,\n    ...(rule.options?.length ? ['Custom options:'] : []),\n    ...(rule.options?.map(option =>\n      ['```json', JSON.stringify(option, null, 2), '```'].join('\\n'),\n    ) ?? []),\n  ];\n\n  return {\n    slug: ruleToSlug(rule),\n    title: truncateTitle(rule.meta.docs?.description ?? name),\n    description: truncateDescription(lines.join('\\n\\n')),\n    ...(rule.meta.docs?.url && {\n      docsUrl: rule.meta.docs.url,\n    }),\n  };\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/runner/index.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/runner\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/runner/index.ts\";import { writeFile } from 'node:fs/promises';\nimport path from 'node:path';\nimport type { Audit, AuditOutput, RunnerConfig } from '@code-pushup/models';\nimport {\n  ensureDirectoryExists,\n  filePathToCliArg,\n  pluginWorkDir,\n  readJsonFile,\n} from '@code-pushup/utils';\nimport type { ESLintPluginRunnerConfig, ESLintTarget } from '../config.js';\nimport { lint } from './lint.js';\nimport { lintResultsToAudits, mergeLinterOutputs } from './transform.js';\nimport type { LinterOutput } from './types.js';\n\nexport const WORKDIR = pluginWorkDir('eslint');\nexport const RUNNER_OUTPUT_PATH = path.join(WORKDIR, 'runner-output.json');\nexport const PLUGIN_CONFIG_PATH = path.join(\n  process.cwd(),\n  WORKDIR,\n  'plugin-config.json',\n);\n\nexport async function executeRunner(): Promise<void> {\n  const { slugs, targets } =\n    await readJsonFile<ESLintPluginRunnerConfig>(PLUGIN_CONFIG_PATH);\n\n  const linterOutputs = await targets.reduce(\n    async (acc, target) => [...(await acc), await lint(target)],\n    Promise.resolve<LinterOutput[]>([]),\n  );\n  const lintResults = mergeLinterOutputs(linterOutputs);\n  const failedAudits = lintResultsToAudits(lintResults);\n\n  const audits = slugs.map(\n    (slug): AuditOutput =>\n      failedAudits.find(audit => audit.slug === slug) ?? {\n        slug,\n        score: 1,\n        value: 0,\n        displayValue: 'passed',\n        details: { issues: [] },\n      },\n  );\n\n  await ensureDirectoryExists(path.dirname(RUNNER_OUTPUT_PATH));\n  await writeFile(RUNNER_OUTPUT_PATH, JSON.stringify(audits));\n}\n\nexport async function createRunnerConfig(\n  scriptPath: string,\n  audits: Audit[],\n  targets: ESLintTarget[],\n): Promise<RunnerConfig> {\n  const config: ESLintPluginRunnerConfig = {\n    targets,\n    slugs: audits.map(audit => audit.slug),\n  };\n  await ensureDirectoryExists(path.dirname(PLUGIN_CONFIG_PATH));\n  await writeFile(PLUGIN_CONFIG_PATH, JSON.stringify(config));\n\n  return {\n    command: 'node',\n    args: [filePathToCliArg(scriptPath)],\n    outputFile: RUNNER_OUTPUT_PATH,\n  };\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/runner/lint.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/runner\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/runner/lint.ts\";import type { ESLint, Linter } from 'eslint';\nimport { platform } from 'node:os';\nimport {\n  distinct,\n  executeProcess,\n  filePathToCliArg,\n  toArray,\n} from '@code-pushup/utils';\nimport type { ESLintTarget } from '../config.js';\nimport { setupESLint } from '../setup.js';\nimport type { LinterOutput, RuleOptionsPerFile } from './types.js';\n\nexport async function lint({\n  eslintrc,\n  patterns,\n}: ESLintTarget): Promise<LinterOutput> {\n  const results = await executeLint({ eslintrc, patterns });\n  const eslint = await setupESLint(eslintrc);\n  const ruleOptionsPerFile = await loadRuleOptionsPerFile(eslint, results);\n  return { results, ruleOptionsPerFile };\n}\n\nasync function executeLint({\n  eslintrc,\n  patterns,\n}: ESLintTarget): Promise<ESLint.LintResult[]> {\n  // running as CLI because ESLint#lintFiles() runs out of memory\n  const { stdout } = await executeProcess({\n    command: 'npx',\n    args: [\n      'eslint',\n      ...(eslintrc ? [`--config=${filePathToCliArg(eslintrc)}`] : []),\n      ...(typeof eslintrc === 'object' ? ['--no-eslintrc'] : []),\n      '--no-error-on-unmatched-pattern',\n      '--format=json',\n      ...toArray(patterns).map(pattern =>\n        // globs need to be escaped on Unix\n        platform() === 'win32' ? pattern : `'${pattern}'`,\n      ),\n    ],\n    ignoreExitCode: true,\n    cwd: process.cwd(),\n  });\n\n  return JSON.parse(stdout) as ESLint.LintResult[];\n}\n\nfunction loadRuleOptionsPerFile(\n  eslint: ESLint,\n  results: ESLint.LintResult[],\n): Promise<RuleOptionsPerFile> {\n  return results.reduce(async (acc, { filePath, messages }) => {\n    const filesMap = await acc;\n    const config = (await eslint.calculateConfigForFile(\n      filePath,\n    )) as Linter.Config;\n    const ruleIds = distinct(\n      messages\n        .map(({ ruleId }) => ruleId)\n        .filter((ruleId): ruleId is string => ruleId != null),\n    );\n    const rulesMap = Object.fromEntries(\n      ruleIds.map(ruleId => [\n        ruleId,\n        toArray(config.rules?.[ruleId] ?? []).slice(1),\n      ]),\n    );\n    return {\n      ...filesMap,\n      [filePath]: {\n        ...filesMap[filePath],\n        ...rulesMap,\n      },\n    };\n  }, Promise.resolve<RuleOptionsPerFile>({}));\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/runner/transform.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/runner\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/runner/transform.ts\";import type { Linter } from 'eslint';\nimport type { AuditOutput, Issue, IssueSeverity } from '@code-pushup/models';\nimport {\n  compareIssueSeverity,\n  countOccurrences,\n  objectToEntries,\n  pluralizeToken,\n  truncateIssueMessage,\n  ui,\n} from '@code-pushup/utils';\nimport { ruleIdToSlug } from '../meta/index.js';\nimport type { LinterOutput } from './types.js';\n\ntype LintIssue = Linter.LintMessage & {\n  filePath: string;\n};\n\nexport function mergeLinterOutputs(outputs: LinterOutput[]): LinterOutput {\n  return outputs.reduce<LinterOutput>(\n    (acc, { results, ruleOptionsPerFile }) => ({\n      results: [...acc.results, ...results],\n      ruleOptionsPerFile: { ...acc.ruleOptionsPerFile, ...ruleOptionsPerFile },\n    }),\n    { results: [], ruleOptionsPerFile: {} },\n  );\n}\n\nexport function lintResultsToAudits({\n  results,\n  ruleOptionsPerFile,\n}: LinterOutput): AuditOutput[] {\n  const issuesPerAudit = results\n    .flatMap(({ messages, filePath }) =>\n      messages.map((message): LintIssue => ({ ...message, filePath })),\n    )\n    .reduce<Record<string, LintIssue[]>>((acc, issue) => {\n      const { ruleId, message, filePath } = issue;\n      if (!ruleId) {\n        ui().logger.warning(\n          `ESLint core error - ${message} (file: ${filePath})`,\n        );\n        return acc;\n      }\n      const options = ruleOptionsPerFile[filePath]?.[ruleId] ?? [];\n      const auditSlug = ruleIdToSlug(ruleId, options);\n      return { ...acc, [auditSlug]: [...(acc[auditSlug] ?? []), issue] };\n    }, {});\n\n  return Object.entries(issuesPerAudit).map(entry => toAudit(...entry));\n}\n\nfunction toAudit(slug: string, issues: LintIssue[]): AuditOutput {\n  const auditIssues = issues.map(convertIssue);\n  const severityCounts = countOccurrences(\n    auditIssues.map(({ severity }) => severity),\n  );\n  const severities = objectToEntries(severityCounts);\n  const summaryText = severities\n    .toSorted((a, b) => -compareIssueSeverity(a[0], b[0]))\n    .map(([severity, count = 0]) => pluralizeToken(severity, count))\n    .join(', ');\n\n  return {\n    slug,\n    score: Number(auditIssues.length === 0),\n    value: auditIssues.length,\n    displayValue: summaryText,\n    details: {\n      issues: auditIssues,\n    },\n  };\n}\n\nfunction convertIssue(issue: LintIssue): Issue {\n  return {\n    message: truncateIssueMessage(issue.message),\n    severity: convertSeverity(issue.severity),\n    source: {\n      file: issue.filePath,\n      ...(issue.line > 0 && {\n        position: {\n          startLine: issue.line,\n          ...(issue.column > 0 && { startColumn: issue.column }),\n          ...(issue.endLine &&\n            issue.endLine > 0 && {\n              endLine: issue.endLine,\n            }),\n          ...(issue.endColumn &&\n            issue.endColumn > 0 && { endColumn: issue.endColumn }),\n        },\n      }),\n    },\n  };\n}\n\nfunction convertSeverity(severity: Linter.Severity): IssueSeverity {\n  switch (severity) {\n    case 2:\n      return 'error';\n    case 1:\n      return 'warning';\n    case 0:\n      // shouldn't happen\n      throw new Error(`Unexpected severity ${severity} in ESLint results`);\n  }\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/nx/utils.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/nx\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-eslint/src/lib/nx/utils.ts\";import type { ProjectConfiguration } from '@nx/devkit';\nimport path from 'node:path';\nimport { fileExists, toArray } from '@code-pushup/utils';\nimport type { ConfigFormat } from '../meta/index.js';\n\nconst ESLINT_CONFIG_EXTENSIONS: Record<ConfigFormat, string[]> = {\n  // https://eslint.org/docs/latest/use/configure/configuration-files#configuration-file-formats\n  flat: ['js', 'mjs', 'cjs'],\n  // https://eslint.org/docs/latest/use/configure/configuration-files-deprecated\n  legacy: ['json', 'js', 'cjs', 'yml', 'yaml'],\n};\nconst ESLINT_CONFIG_NAMES: Record<ConfigFormat, string[]> = {\n  // https://eslint.org/docs/latest/use/configure/configuration-files#configuration-file-formats\n  flat: ['eslint.config'],\n  // https://eslint.org/docs/latest/use/configure/configuration-files-deprecated\n  legacy: ['.eslintrc'],\n};\n\nconst CP_ESLINT_CONFIG_NAMES: Record<ConfigFormat, string[]> = {\n  flat: [\n    'code-pushup.eslint.config',\n    'eslint.code-pushup.config',\n    'eslint.config.code-pushup',\n    'eslint.strict.config',\n    'eslint.config.strict',\n  ],\n  legacy: ['code-pushup.eslintrc', '.eslintrc.code-pushup', '.eslintrc.strict'],\n};\n\nexport async function findCodePushupEslintConfig(\n  project: ProjectConfiguration,\n  format: ConfigFormat,\n): Promise<string | undefined> {\n  return findProjectFile(project, {\n    names: CP_ESLINT_CONFIG_NAMES[format],\n    extensions: ESLINT_CONFIG_EXTENSIONS[format],\n  });\n}\n\nexport async function findEslintConfig(\n  project: ProjectConfiguration,\n  format: ConfigFormat,\n): Promise<string | undefined> {\n  const options = project.targets?.['lint']?.options as\n    | { eslintConfig?: string }\n    | undefined;\n  return (\n    options?.eslintConfig ??\n    (await findProjectFile(project, {\n      names: ESLINT_CONFIG_NAMES[format],\n      extensions: ESLINT_CONFIG_EXTENSIONS[format],\n    }))\n  );\n}\n\nexport function getLintFilePatterns(\n  project: ProjectConfiguration,\n  format: ConfigFormat,\n): string[] {\n  const options = project.targets?.['lint']?.options as\n    | { lintFilePatterns?: string | string[] }\n    | undefined;\n  // lintFilePatterns defaults to [\"{projectRoot}\"] - https://github.com/nrwl/nx/pull/20313\n  const defaultPatterns =\n    format === 'legacy'\n      ? `${project.root}/**/*` // files not folder needed for legacy because rules detected with ESLint.calculateConfigForFile\n      : project.root;\n  const patterns =\n    options?.lintFilePatterns == null\n      ? [defaultPatterns]\n      : toArray(options.lintFilePatterns);\n  if (format === 'legacy') {\n    return [\n      ...patterns,\n      // HACK: ESLint.calculateConfigForFile won't find rules included only for subsets of *.ts when globs used\n      // so we explicitly provide additional patterns used by @code-pushup/eslint-config to ensure those rules are included\n      // this workaround is only necessary for legacy configs (rules are detected more reliably in flat configs)\n      `${project.root}/*.spec.ts`, // jest/* and vitest/* rules\n      `${project.root}/*.cy.ts`, // cypress/* rules\n      `${project.root}/*.stories.ts`, // storybook/* rules\n      `${project.root}/.storybook/main.ts`, // storybook/no-uninstalled-addons rule\n    ];\n  }\n  return patterns;\n}\n\nasync function findProjectFile(\n  project: ProjectConfiguration,\n  file: {\n    names: string[];\n    extensions: string[];\n  },\n): Promise<string | undefined> {\n  // eslint-disable-next-line functional/no-loop-statements\n  for (const name of file.names) {\n    // eslint-disable-next-line functional/no-loop-statements\n    for (const ext of file.extensions) {\n      const filename = `./${project.root}/${name}.${ext}`;\n      if (await fileExists(path.join(process.cwd(), filename))) {\n        return filename;\n      }\n    }\n  }\n  return undefined;\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/js-packages-plugin.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/js-packages-plugin.ts\";import { createRequire } from 'node:module';\nimport path from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport type { Audit, Group, PluginConfig } from '@code-pushup/models';\nimport {\n  type DependencyGroup,\n  type JSPackagesPluginConfig,\n  type PackageCommand,\n  type PackageManagerId,\n  dependencyGroups,\n} from './config.js';\nimport { dependencyDocs, dependencyGroupWeights } from './constants.js';\nimport { packageManagers } from './package-managers/package-managers.js';\nimport { createRunnerConfig } from './runner/index.js';\nimport { normalizeConfig } from './utils.js';\n\n/**\n * Instantiates Code PushUp JS packages plugin for core config.\n *\n * @example\n * import jsPackagesPlugin from '@code-pushup/js-packages-plugin'\n *\n * export default {\n *   // ... core config ...\n *   plugins: [\n *     // ... other plugins ...\n *     await jsPackagesPlugin({ packageManager: 'npm' })\n *   ]\n * }\n *\n * @returns Plugin configuration.\n */\n\nexport async function jsPackagesPlugin(\n  config?: JSPackagesPluginConfig,\n): Promise<PluginConfig> {\n  const { packageManager, checks, depGroups, ...jsPackagesPluginConfigRest } =\n    await normalizeConfig(config);\n\n  const runnerScriptPath = path.join(\n    fileURLToPath(path.dirname(import.meta.url)),\n    '..',\n    'bin.js',\n  );\n\n  const packageJson = createRequire(import.meta.url)(\n    '../../package.json',\n  ) as typeof import('../../package.json');\n\n  return {\n    slug: 'js-packages',\n    title: 'JS Packages',\n    icon: packageManager.icon,\n    description:\n      'This plugin runs audit to uncover vulnerabilities and lists outdated dependencies. It supports npm, yarn classic, yarn modern, and pnpm package managers.',\n    docsUrl: packageManager.docs.homepage,\n    packageName: packageJson.name,\n    version: packageJson.version,\n    audits: createAudits(packageManager.slug, checks, depGroups),\n    groups: createGroups(packageManager.slug, checks, depGroups),\n    runner: await createRunnerConfig(runnerScriptPath, {\n      ...jsPackagesPluginConfigRest,\n      checks,\n      packageManager: packageManager.slug,\n      dependencyGroups: depGroups,\n    }),\n  };\n}\n\nfunction createGroups(\n  id: PackageManagerId,\n  checks: PackageCommand[],\n  depGroups: DependencyGroup[],\n): Group[] {\n  const pm = packageManagers[id];\n  const supportedAuditDepGroups =\n    pm.audit.supportedDepGroups ?? dependencyGroups;\n  const compatibleAuditDepGroups = depGroups.filter(group =>\n    supportedAuditDepGroups.includes(group),\n  );\n\n  const groups: Record<PackageCommand, Group> = {\n    audit: {\n      slug: `${pm.slug}-audit`,\n      title: `${pm.name} audit`,\n      description: `Group containing ${pm.name} vulnerabilities.`,\n      docsUrl: pm.docs.audit,\n      refs: compatibleAuditDepGroups.map(depGroup => ({\n        slug: `${pm.slug}-audit-${depGroup}`,\n        weight: dependencyGroupWeights[depGroup],\n      })),\n    },\n    outdated: {\n      slug: `${pm.slug}-outdated`,\n      title: `${pm.name} outdated dependencies`,\n      description: `Group containing outdated ${pm.name} dependencies.`,\n      docsUrl: pm.docs.outdated,\n      refs: depGroups.map(depGroup => ({\n        slug: `${pm.slug}-outdated-${depGroup}`,\n        weight: dependencyGroupWeights[depGroup],\n      })),\n    },\n  };\n\n  return checks.map(check => groups[check]);\n}\n\nfunction createAudits(\n  id: PackageManagerId,\n  checks: PackageCommand[],\n  depGroups: DependencyGroup[],\n): Audit[] {\n  const { slug } = packageManagers[id];\n  return checks.flatMap(check => {\n    const supportedAuditDepGroups =\n      packageManagers[id].audit.supportedDepGroups ?? dependencyGroups;\n\n    const compatibleDepGroups =\n      check === 'audit'\n        ? depGroups.filter(group => supportedAuditDepGroups.includes(group))\n        : depGroups;\n\n    return compatibleDepGroups.map(depGroup => ({\n      slug: `${slug}-${check}-${depGroup}`,\n      title: getAuditTitle(slug, check, depGroup),\n      description: getAuditDescription(check, depGroup),\n      docsUrl: dependencyDocs[depGroup],\n    }));\n  });\n}\n\nfunction getAuditTitle(\n  id: PackageManagerId,\n  check: PackageCommand,\n  depGroup: DependencyGroup,\n) {\n  const pm = packageManagers[id];\n  return check === 'audit'\n    ? `Vulnerabilities for ${pm.name} ${depGroup} dependencies.`\n    : `Outdated ${pm.name} ${depGroup} dependencies.`;\n}\n\nfunction getAuditDescription(check: PackageCommand, depGroup: DependencyGroup) {\n  return check === 'audit'\n    ? `Runs security audit on ${depGroup} dependencies.`\n    : `Checks for outdated ${depGroup} dependencies`;\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/config.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/config.ts\";import { z } from 'zod';\nimport { type IssueSeverity, issueSeveritySchema } from '@code-pushup/models';\nimport { defaultAuditLevelMapping } from './constants.js';\n\nexport const dependencyGroups = ['prod', 'dev', 'optional'] as const;\nconst dependencyGroupSchema = z.enum(dependencyGroups);\nexport type DependencyGroup = (typeof dependencyGroups)[number];\n\nconst packageCommandSchema = z.enum(['audit', 'outdated']);\nexport type PackageCommand = z.infer<typeof packageCommandSchema>;\n\nconst packageManagerIdSchema = z.enum([\n  'npm',\n  'yarn-classic',\n  'yarn-modern',\n  'pnpm',\n]);\nexport type PackageManagerId = z.infer<typeof packageManagerIdSchema>;\n\nconst packageJsonPathSchema = z\n  .union([\n    z.array(z.string()).min(1),\n    z.object({ autoSearch: z.literal(true) }),\n  ])\n  .describe(\n    'File paths to package.json. Looks only at root package.json by default',\n  )\n  .default(['package.json']);\n\nexport type PackageJsonPaths = z.infer<typeof packageJsonPathSchema>;\n\nexport const packageAuditLevels = [\n  'critical',\n  'high',\n  'moderate',\n  'low',\n  'info',\n] as const;\nconst packageAuditLevelSchema = z.enum(packageAuditLevels);\nexport type PackageAuditLevel = z.infer<typeof packageAuditLevelSchema>;\n\nexport type AuditSeverity = Record<PackageAuditLevel, IssueSeverity>;\n\nexport function fillAuditLevelMapping(\n  mapping: Partial<AuditSeverity>,\n): AuditSeverity {\n  return {\n    critical: mapping.critical ?? defaultAuditLevelMapping.critical,\n    high: mapping.high ?? defaultAuditLevelMapping.high,\n    moderate: mapping.moderate ?? defaultAuditLevelMapping.moderate,\n    low: mapping.low ?? defaultAuditLevelMapping.low,\n    info: mapping.info ?? defaultAuditLevelMapping.info,\n  };\n}\n\nexport const jsPackagesPluginConfigSchema = z.object({\n  checks: z\n    .array(packageCommandSchema, {\n      description:\n        'Package manager commands to be run. Defaults to both audit and outdated.',\n    })\n    .min(1)\n    .default(['audit', 'outdated']),\n  packageManager: packageManagerIdSchema\n    .describe('Package manager to be used.')\n    .optional(),\n  dependencyGroups: z\n    .array(dependencyGroupSchema)\n    .min(1)\n    .default(['prod', 'dev']),\n  auditLevelMapping: z\n    .record(packageAuditLevelSchema, issueSeveritySchema, {\n      description:\n        'Mapping of audit levels to issue severity. Custom mapping or overrides may be entered manually, otherwise has a default preset.',\n    })\n    .default(defaultAuditLevelMapping)\n    .transform(fillAuditLevelMapping),\n  packageJsonPaths: packageJsonPathSchema,\n});\n\nexport type JSPackagesPluginConfig = z.input<\n  typeof jsPackagesPluginConfigSchema\n>;\n\nexport type FinalJSPackagesPluginConfig = Required<\n  z.infer<typeof jsPackagesPluginConfigSchema>\n>;\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/constants.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/constants.ts\";import type { IssueSeverity } from '@code-pushup/models';\nimport type { DependencyGroup, PackageAuditLevel } from './config.js';\nimport type { DependencyGroupLong } from './runner/outdated/types.js';\n\nexport const defaultAuditLevelMapping: Record<\n  PackageAuditLevel,\n  IssueSeverity\n> = {\n  critical: 'error',\n  high: 'error',\n  moderate: 'warning',\n  low: 'warning',\n  info: 'info',\n};\n\nexport const dependencyGroupToLong: Record<\n  DependencyGroup,\n  DependencyGroupLong\n> = {\n  prod: 'dependencies',\n  dev: 'devDependencies',\n  optional: 'optionalDependencies',\n};\n\nexport const dependencyGroupWeights: Record<DependencyGroup, number> = {\n  /* eslint-disable @typescript-eslint/no-magic-numbers */\n  prod: 80,\n  dev: 15,\n  optional: 5,\n  /* eslint-enable @typescript-eslint/no-magic-numbers */\n};\n\nexport const dependencyDocs: Record<DependencyGroup, string> = {\n  prod: 'https://classic.yarnpkg.com/docs/dependency-types#toc-dependencies',\n  dev: 'https://classic.yarnpkg.com/docs/dependency-types#toc-devdependencies',\n  optional:\n    'https://classic.yarnpkg.com/docs/dependency-types#toc-optionaldependencies',\n};\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/npm/npm.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/npm\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/npm/npm.ts\";import { objectToKeys } from '@code-pushup/utils';\nimport type { DependencyGroup } from '../../config.js';\nimport { filterAuditResult } from '../../runner/utils.js';\nimport { COMMON_AUDIT_ARGS, COMMON_OUTDATED_ARGS } from '../constants.js';\nimport type { AuditResults, PackageManager } from '../types.js';\nimport { npmToAuditResult } from './audit-result.js';\nimport { npmToOutdatedResult } from './outdated-result.js';\n\nconst npmDependencyOptions: Record<DependencyGroup, string[]> = {\n  prod: ['--omit=dev', '--omit=optional'],\n  dev: ['--include=dev', '--omit=optional'],\n  optional: ['--include=optional', '--omit=dev'],\n};\n\nexport const npmPackageManager: PackageManager = {\n  slug: 'npm',\n  name: 'NPM',\n  command: 'npm',\n  icon: 'npm',\n  docs: {\n    homepage: 'https://docs.npmjs.com/',\n    audit: 'https://docs.npmjs.com/cli/commands/npm-audit',\n    outdated: 'https://docs.npmjs.com/cli/commands/npm-outdated',\n  },\n  audit: {\n    getCommandArgs: groupDep => [\n      ...COMMON_AUDIT_ARGS,\n      ...npmDependencyOptions[groupDep],\n      '--audit-level=none',\n    ],\n    unifyResult: npmToAuditResult,\n    // prod dependencies need to be filtered out manually since v10\n    postProcessResult: (results: AuditResults) => {\n      const depGroups = objectToKeys(results);\n      const devFilter =\n        results.dev && results.prod\n          ? filterAuditResult(results.dev, 'name', results.prod)\n          : results.dev;\n      const optionalFilter =\n        results.optional && results.prod\n          ? filterAuditResult(results.optional, 'name', results.prod)\n          : results.optional;\n\n      return {\n        ...(depGroups.includes('prod') && { prod: results.prod }),\n        ...(depGroups.includes('dev') && { dev: devFilter }),\n        ...(depGroups.includes('optional') && { optional: optionalFilter }),\n      };\n    },\n  },\n  outdated: {\n    commandArgs: [...COMMON_OUTDATED_ARGS, '--long'],\n    unifyResult: npmToOutdatedResult,\n  },\n};\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/utils.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/utils.ts\";import path from 'node:path';\nimport {\n  crawlFileSystem,\n  objectFromEntries,\n  objectToKeys,\n  readJsonFile,\n} from '@code-pushup/utils';\nimport type { AuditResult, Vulnerability } from './audit/types.js';\nimport {\n  type DependencyGroupLong,\n  type DependencyTotals,\n  type PackageJson,\n  dependencyGroupLong,\n} from './outdated/types.js';\n\nexport function filterAuditResult(\n  result: AuditResult,\n  key: keyof Vulnerability,\n  referenceResult?: AuditResult,\n): AuditResult {\n  if (result.vulnerabilities.length === 0) {\n    return result;\n  }\n\n  const uniqueResult = result.vulnerabilities.reduce<AuditResult>(\n    (acc, ref) => {\n      const matchReference = referenceResult ?? acc;\n      const isMatch = matchReference.vulnerabilities\n        .map(vulnerability => vulnerability[key])\n        .includes(ref[key]);\n\n      if (isMatch) {\n        return {\n          vulnerabilities: acc.vulnerabilities,\n          summary: {\n            ...acc.summary,\n            [ref.severity]: acc.summary[ref.severity] - 1,\n            total: acc.summary.total - 1,\n          },\n        };\n      }\n\n      return {\n        vulnerabilities: [...acc.vulnerabilities, ref],\n        summary: acc.summary,\n      };\n    },\n    { vulnerabilities: [], summary: result.summary },\n  );\n\n  return {\n    vulnerabilities: uniqueResult.vulnerabilities,\n    summary: uniqueResult.summary,\n  };\n}\n\n// TODO: use .gitignore\nexport async function findAllPackageJson(): Promise<string[]> {\n  return (\n    await crawlFileSystem({\n      directory: '.',\n      pattern: /(^|[\\\\/])package\\.json$/,\n    })\n  ).filter(\n    filePath =>\n      !filePath.startsWith(`node_modules${path.sep}`) &&\n      !filePath.includes(`${path.sep}node_modules${path.sep}`) &&\n      !filePath.startsWith(`.nx${path.sep}`),\n  );\n}\n\nexport async function getTotalDependencies(\n  packageJsonPaths: string[],\n): Promise<DependencyTotals> {\n  const parsedDeps = await Promise.all(\n    packageJsonPaths.map(readJsonFile<PackageJson>),\n  );\n\n  const mergedDeps = parsedDeps.reduce<Record<DependencyGroupLong, string[]>>(\n    (acc, depMapper) =>\n      objectFromEntries(\n        dependencyGroupLong.map(group => {\n          const deps = depMapper[group];\n          return [\n            group,\n            [...acc[group], ...(deps == null ? [] : objectToKeys(deps))],\n          ];\n        }),\n      ),\n    { dependencies: [], devDependencies: [], optionalDependencies: [] },\n  );\n  return objectFromEntries(\n    objectToKeys(mergedDeps).map(deps => [\n      deps,\n      new Set(mergedDeps[deps]).size,\n    ]),\n  );\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/constants.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/constants.ts\";export const COMMON_AUDIT_ARGS = ['audit', '--json'];\nexport const COMMON_OUTDATED_ARGS = ['outdated', '--json'];\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/npm/audit-result.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/npm\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/npm/audit-result.ts\";import { objectToEntries } from '@code-pushup/utils';\nimport type { AuditResult, Vulnerability } from '../../runner/audit/types.js';\nimport type {\n  NpmAdvisory,\n  NpmAuditResultJson,\n  NpmFixInformation,\n  NpmVulnerabilities,\n} from './types.js';\n\nexport function npmToAuditResult(output: string): AuditResult {\n  const npmAudit = JSON.parse(output) as NpmAuditResultJson;\n\n  const vulnerabilities = objectToEntries(npmAudit.vulnerabilities).map(\n    ([name, detail]): Vulnerability => {\n      const advisory = npmToAdvisory(name, npmAudit.vulnerabilities);\n      return {\n        name: name.toString(),\n        severity: detail.severity,\n        versionRange: detail.range,\n        directDependency: detail.isDirect ? true : (detail.effects[0] ?? ''),\n        fixInformation: npmToFixInformation(detail.fixAvailable),\n        ...(advisory != null && {\n          title: advisory.title,\n          url: advisory.url,\n        }),\n      };\n    },\n  );\n\n  return {\n    vulnerabilities,\n    summary: npmAudit.metadata.vulnerabilities,\n  };\n}\n\nexport function npmToFixInformation(\n  fixAvailable: boolean | NpmFixInformation,\n): string {\n  if (typeof fixAvailable === 'boolean') {\n    return fixAvailable ? 'Fix is available.' : '';\n  }\n\n  return `Fix available: Update \\`${fixAvailable.name}\\` to version **${\n    fixAvailable.version\n  }**${fixAvailable.isSemVerMajor ? ' (breaking change).' : '.'}`;\n}\n\nexport function npmToAdvisory(\n  name: string,\n  vulnerabilities: NpmVulnerabilities,\n  prevNodes = new Set<string>(),\n): NpmAdvisory | null {\n  const advisory = vulnerabilities[name]?.via;\n\n  if (\n    Array.isArray(advisory) &&\n    advisory.length > 0 &&\n    typeof advisory[0] === 'object'\n  ) {\n    return { title: advisory[0].title, url: advisory[0].url };\n  }\n\n  // Cross-references another vulnerability\n  if (\n    Array.isArray(advisory) &&\n    advisory.length > 0 &&\n    advisory.every((value): value is string => typeof value === 'string')\n  ) {\n    /* eslint-disable functional/no-let, functional/immutable-data, functional/no-loop-statements, prefer-const */\n    let advisoryInfo: NpmAdvisory | null = null;\n    let newReferences: string[] = [];\n    let advisoryInfoFound = false;\n    /* eslint-enable functional/no-let, prefer-const */\n\n    for (const via of advisory) {\n      if (!prevNodes.has(via)) {\n        newReferences.push(via);\n      }\n    }\n\n    while (newReferences.length > 0 && !advisoryInfoFound) {\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      const ref = newReferences.pop()!;\n      prevNodes.add(ref);\n      const result = npmToAdvisory(ref, vulnerabilities, prevNodes);\n\n      if (result != null) {\n        advisoryInfo = { title: result.title, url: result.url };\n        advisoryInfoFound = true;\n      }\n    }\n    /* eslint-enable functional/immutable-data, functional/no-loop-statements */\n\n    return advisoryInfo;\n  }\n\n  return null;\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/npm/outdated-result.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/npm\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/npm/outdated-result.ts\";import { objectToEntries } from '@code-pushup/utils';\nimport type { OutdatedResult } from '../../runner/outdated/types.js';\nimport type { NpmNormalizedOverview, NpmOutdatedResultJson } from './types.js';\n\nexport function npmToOutdatedResult(output: string): OutdatedResult {\n  const npmOutdated = JSON.parse(output) as NpmOutdatedResultJson;\n  // current might be missing in some cases\n  // https://stackoverflow.com/questions/42267101/npm-outdated-command-shows-missing-in-current-version\n  return objectToEntries(npmOutdated)\n    .filter(\n      (entry): entry is [string, NpmNormalizedOverview] =>\n        entry[1].current != null,\n    )\n    .map(([name, overview]) => ({\n      name,\n      current: overview.current,\n      latest: overview.latest,\n      type: overview.type,\n      ...(overview.homepage != null && { url: overview.homepage }),\n    }));\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/pnpm/pnpm.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/pnpm\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/pnpm/pnpm.ts\";import { objectToKeys } from '@code-pushup/utils';\nimport type { DependencyGroup } from '../../config.js';\nimport { filterAuditResult } from '../../runner/utils.js';\nimport { COMMON_AUDIT_ARGS, COMMON_OUTDATED_ARGS } from '../constants.js';\nimport type { AuditResults, PackageManager } from '../types.js';\nimport { pnpmToAuditResult } from './audit-result.js';\nimport { pnpmToOutdatedResult } from './outdated-result.js';\n\nconst pnpmDependencyOptions: Record<DependencyGroup, string[]> = {\n  prod: ['--prod', '--no-optional'],\n  dev: ['--dev', '--no-optional'],\n  optional: [],\n};\n\nexport const pnpmPackageManager: PackageManager = {\n  slug: 'pnpm',\n  name: 'pnpm',\n  command: 'pnpm',\n  icon: 'pnpm',\n  docs: {\n    homepage: 'https://pnpm.io/pnpm-cli',\n    audit: 'https://pnpm.io/cli/audit/',\n    outdated: 'https://pnpm.io/cli/outdated',\n  },\n  audit: {\n    getCommandArgs: groupDep => [\n      ...COMMON_AUDIT_ARGS,\n      ...pnpmDependencyOptions[groupDep],\n    ],\n    ignoreExitCode: true,\n    unifyResult: pnpmToAuditResult,\n    // optional dependencies don't have an exclusive option so they need duplicates filtered out\n    postProcessResult: (results: AuditResults) => {\n      const depGroups = objectToKeys(results);\n      const prodFilter =\n        results.optional && results.prod\n          ? filterAuditResult(results.optional, 'id', results.prod)\n          : results.optional;\n      const devFilter =\n        prodFilter && results.dev\n          ? filterAuditResult(prodFilter, 'id', results.dev)\n          : results.optional;\n\n      return {\n        ...(depGroups.includes('prod') && { prod: results.prod }),\n        ...(depGroups.includes('dev') && { dev: results.dev }),\n        ...(results.optional && { optional: devFilter }),\n      };\n    },\n  },\n  outdated: {\n    commandArgs: COMMON_OUTDATED_ARGS,\n    unifyResult: pnpmToOutdatedResult,\n  },\n};\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/pnpm/outdated-result.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/pnpm\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/pnpm/outdated-result.ts\";import { objectToEntries } from '@code-pushup/utils';\nimport type { OutdatedResult } from '../../runner/outdated/types.js';\nimport type { PnpmOutdatedResultJson } from './types.js';\nimport { filterOutWarnings } from './utils.js';\n\nexport function pnpmToOutdatedResult(output: string): OutdatedResult {\n  const pnpmOutdated = JSON.parse(\n    filterOutWarnings(output),\n  ) as PnpmOutdatedResultJson;\n\n  return objectToEntries(pnpmOutdated).map(\n    ([name, { current, latest, dependencyType: type }]) => ({\n      name,\n      current,\n      latest,\n      type,\n    }),\n  );\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/yarn-classic/audit-result.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/yarn-classic\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/yarn-classic/audit-result.ts\";import { fromJsonLines } from '@code-pushup/utils';\nimport type { AuditResult, Vulnerability } from '../../runner/audit/types.js';\nimport { filterAuditResult } from '../../runner/utils.js';\nimport type {\n  Yarnv1AuditAdvisory,\n  Yarnv1AuditResultJson,\n  Yarnv1AuditSummary,\n} from './types.js';\n\nexport function yarnv1ToAuditResult(output: string): AuditResult {\n  const yarnv1Result = fromJsonLines<Yarnv1AuditResultJson>(output);\n  const [yarnv1Advisory, yarnv1Summary] = validateYarnv1Result(yarnv1Result);\n\n  const vulnerabilities = yarnv1Advisory.map(\n    ({ data: { resolution, advisory } }): Vulnerability => {\n      const { id, path } = resolution;\n      const directDependency = path.slice(0, path.indexOf('>'));\n\n      const {\n        module_name: name,\n        title,\n        url,\n        severity,\n        vulnerable_versions: versionRange,\n        recommendation: fixInformation,\n      } = advisory;\n\n      return {\n        name,\n        title,\n        id,\n        url,\n        severity,\n        versionRange,\n        directDependency: name === directDependency ? true : directDependency,\n        fixInformation,\n      };\n    },\n  );\n\n  const summary = {\n    ...yarnv1Summary.data.vulnerabilities,\n    total: Object.values(yarnv1Summary.data.vulnerabilities).reduce(\n      (acc, amount) => acc + amount,\n      0,\n    ),\n  };\n\n  // duplicates are filtered out based on their ID\n  return filterAuditResult({ vulnerabilities, summary }, 'id');\n}\n\nfunction validateYarnv1Result(\n  result: Yarnv1AuditResultJson,\n): [Yarnv1AuditAdvisory[], Yarnv1AuditSummary] {\n  const summary = result.at(-1);\n  if (summary?.type !== 'auditSummary') {\n    throw new Error('Invalid Yarn v1 audit result - no summary found.');\n  }\n\n  const vulnerabilities = result.filter(\n    (item): item is Yarnv1AuditAdvisory => item.type === 'auditAdvisory',\n  );\n\n  return [vulnerabilities, summary];\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/yarn-classic/outdated-result.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/yarn-classic\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/yarn-classic/outdated-result.ts\";import {\n  fromJsonLines,\n  objectFromEntries,\n  objectToEntries,\n  objectToKeys,\n} from '@code-pushup/utils';\nimport type {\n  OutdatedDependency,\n  OutdatedResult,\n} from '../../runner/outdated/types.js';\nimport {\n  REQUIRED_OUTDATED_FIELDS,\n  outdatedtoFieldMapper,\n} from './constants.js';\nimport {\n  type Yarnv1FieldName,\n  type Yarnv1OutdatedResultJson,\n  yarnv1FieldNames,\n} from './types.js';\n\nexport function yarnv1ToOutdatedResult(output: string): OutdatedResult {\n  const yarnv1Outdated = fromJsonLines<Yarnv1OutdatedResultJson>(output);\n  const fields = yarnv1Outdated[1].data.head;\n  const dependencies = yarnv1Outdated[1].data.body;\n\n  // no outdated dependencies\n  if (dependencies.length === 0) {\n    return [];\n  }\n\n  // map dynamic fields\n  validateOutdatedFields(fields);\n  const indexMapping = getOutdatedFieldIndexes(fields);\n\n  return dependencies.map(\n    dep =>\n      objectFromEntries(\n        objectToKeys(indexMapping)\n          .map(field => [field, dep[indexMapping[field]]] as const)\n          .filter(\n            (entry): entry is [keyof OutdatedDependency, string] =>\n              entry[1] != null,\n          ),\n      ) as OutdatedDependency,\n  );\n}\n\nexport function validateOutdatedFields(head: string[]) {\n  const relevantFields = head.filter(isYarnv1FieldName);\n  if (hasAllRequiredFields(relevantFields)) {\n    return true;\n  }\n\n  throw new Error(\n    `Yarn v1 outdated: Template [${head.join(\n      ', ',\n    )}] does not contain all required fields [${yarnv1FieldNames.join(', ')}]`,\n  );\n}\n\nfunction isYarnv1FieldName(value: string): value is Yarnv1FieldName {\n  const names: readonly string[] = yarnv1FieldNames;\n  return names.includes(value);\n}\n\nfunction hasAllRequiredFields(head: Yarnv1FieldName[]) {\n  return REQUIRED_OUTDATED_FIELDS.every(field => head.includes(field));\n}\n\nexport function getOutdatedFieldIndexes(all: string[]) {\n  return objectFromEntries(\n    objectToEntries(outdatedtoFieldMapper).map(([outdatedField, yarnField]) => [\n      outdatedField,\n      all.indexOf(yarnField),\n    ]),\n  );\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/index.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/index.ts\";import { writeFile } from 'node:fs/promises';\nimport path from 'node:path';\nimport type { RunnerConfig } from '@code-pushup/models';\nimport {\n  ensureDirectoryExists,\n  executeProcess,\n  filePathToCliArg,\n  isPromiseFulfilledResult,\n  isPromiseRejectedResult,\n  objectFromEntries,\n  readJsonFile,\n} from '@code-pushup/utils';\nimport {\n  type AuditSeverity,\n  type DependencyGroup,\n  type FinalJSPackagesPluginConfig,\n  type PackageJsonPaths,\n  type PackageManagerId,\n  dependencyGroups,\n} from '../config.js';\nimport { dependencyGroupToLong } from '../constants.js';\nimport { packageManagers } from '../package-managers/package-managers.js';\nimport { auditResultToAuditOutput } from './audit/transform.js';\nimport type { AuditResult } from './audit/types.js';\nimport { PLUGIN_CONFIG_PATH, RUNNER_OUTPUT_PATH } from './constants.js';\nimport { outdatedResultToAuditOutput } from './outdated/transform.js';\nimport { findAllPackageJson, getTotalDependencies } from './utils.js';\n\nexport async function createRunnerConfig(\n  scriptPath: string,\n  config: FinalJSPackagesPluginConfig,\n): Promise<RunnerConfig> {\n  await ensureDirectoryExists(path.dirname(PLUGIN_CONFIG_PATH));\n  await writeFile(PLUGIN_CONFIG_PATH, JSON.stringify(config));\n\n  return {\n    command: 'node',\n    args: [filePathToCliArg(scriptPath)],\n    outputFile: RUNNER_OUTPUT_PATH,\n  };\n}\n\nexport async function executeRunner(): Promise<void> {\n  const {\n    packageManager,\n    checks,\n    auditLevelMapping,\n    packageJsonPaths,\n    dependencyGroups: depGroups,\n  } = await readJsonFile<FinalJSPackagesPluginConfig>(PLUGIN_CONFIG_PATH);\n\n  const auditResults = checks.includes('audit')\n    ? await processAudit(packageManager, depGroups, auditLevelMapping)\n    : [];\n\n  const outdatedResults = checks.includes('outdated')\n    ? await processOutdated(packageManager, depGroups, packageJsonPaths)\n    : [];\n  const checkResults = [...auditResults, ...outdatedResults];\n\n  await ensureDirectoryExists(path.dirname(RUNNER_OUTPUT_PATH));\n  await writeFile(RUNNER_OUTPUT_PATH, JSON.stringify(checkResults));\n}\n\nasync function processOutdated(\n  id: PackageManagerId,\n  depGroups: DependencyGroup[],\n  packageJsonPaths: PackageJsonPaths,\n) {\n  const pm = packageManagers[id];\n  const { stdout, stderr } = await executeProcess({\n    command: pm.command,\n    args: pm.outdated.commandArgs,\n    cwd: process.cwd(),\n    ignoreExitCode: true, // outdated returns exit code 1 when outdated dependencies are found\n  });\n\n  // Successful outdated check has empty stderr\n  if (stderr) {\n    throw new Error(`JS packages plugin: outdated error: ${stderr}`);\n  }\n\n  // Locate all package.json files in the repository if not provided\n  const finalPaths = Array.isArray(packageJsonPaths)\n    ? packageJsonPaths\n    : await findAllPackageJson();\n  const depTotals = await getTotalDependencies(finalPaths);\n\n  const normalizedResult = pm.outdated.unifyResult(stdout);\n  return depGroups.map(depGroup =>\n    outdatedResultToAuditOutput(\n      normalizedResult,\n      id,\n      depGroup,\n      depTotals[dependencyGroupToLong[depGroup]],\n    ),\n  );\n}\n\nasync function processAudit(\n  id: PackageManagerId,\n  depGroups: DependencyGroup[],\n  auditLevelMapping: AuditSeverity,\n) {\n  const pm = packageManagers[id];\n  const supportedAuditDepGroups =\n    pm.audit.supportedDepGroups ?? dependencyGroups;\n  const compatibleAuditDepGroups = depGroups.filter(group =>\n    supportedAuditDepGroups.includes(group),\n  );\n\n  const auditResults = await Promise.allSettled(\n    compatibleAuditDepGroups.map(\n      async (depGroup): Promise<[DependencyGroup, AuditResult]> => {\n        const { stdout, stderr } = await executeProcess({\n          command: pm.command,\n          args: pm.audit.getCommandArgs(depGroup),\n          cwd: process.cwd(),\n          ignoreExitCode: pm.audit.ignoreExitCode,\n        });\n        // Successful audit check has empty stderr\n        if (stderr) {\n          throw new Error(`JS packages plugin: audit error: ${stderr}`);\n        }\n        return [depGroup, pm.audit.unifyResult(stdout)];\n      },\n    ),\n  );\n\n  const rejected = auditResults.filter(isPromiseRejectedResult);\n  if (rejected.length > 0) {\n    rejected.forEach(result => {\n      console.error(result.reason);\n    });\n\n    throw new Error(`JS Packages plugin: Running ${pm.name} audit failed.`);\n  }\n\n  const fulfilled = objectFromEntries(\n    auditResults.filter(isPromiseFulfilledResult).map(x => x.value),\n  );\n\n  const uniqueResults = pm.audit.postProcessResult?.(fulfilled) ?? fulfilled;\n\n  return compatibleAuditDepGroups.map(depGroup =>\n    auditResultToAuditOutput(\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      uniqueResults[depGroup]!,\n      id,\n      depGroup,\n      auditLevelMapping,\n    ),\n  );\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/audit/transform.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/audit\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/audit/transform.ts\";import { md } from 'build-md';\nimport type { AuditOutput, Issue } from '@code-pushup/models';\nimport { objectToEntries } from '@code-pushup/utils';\nimport {\n  type AuditSeverity,\n  type DependencyGroup,\n  type PackageManagerId,\n  packageAuditLevels,\n} from '../../config.js';\nimport { auditScoreModifiers } from './constants.js';\nimport type { AuditResult, AuditSummary, Vulnerability } from './types.js';\n\nexport function auditResultToAuditOutput(\n  result: AuditResult,\n  id: PackageManagerId,\n  depGroup: DependencyGroup,\n  auditLevelMapping: AuditSeverity,\n): AuditOutput {\n  const issues = vulnerabilitiesToIssues(\n    result.vulnerabilities,\n    auditLevelMapping,\n  );\n\n  return {\n    slug: `${id}-audit-${depGroup}`,\n    score: calculateAuditScore(result.summary),\n    value: result.summary.total,\n    displayValue: summaryToDisplayValue(result.summary),\n    details: { issues },\n  };\n}\n\nexport function calculateAuditScore(stats: AuditSummary) {\n  if (stats.total === 0) {\n    return 1;\n  }\n\n  return objectToEntries(stats).reduce<number>(\n    (score, [level, vulnerabilities]) => {\n      if (level === 'total') {\n        return score;\n      }\n\n      const reducedScore = score - auditScoreModifiers[level] * vulnerabilities;\n      return Math.max(reducedScore, 0);\n    },\n    1,\n  );\n}\n\nexport function summaryToDisplayValue(summary: AuditSummary): string {\n  if (summary.total === 0) {\n    return '0 vulnerabilities';\n  }\n\n  const vulnerabilityStats = packageAuditLevels\n    .map(level => (summary[level] > 0 ? `${summary[level]} ${level}` : ''))\n    .filter(text => text !== '')\n    .join(', ');\n  return `${summary.total} ${\n    summary.total === 1 ? 'vulnerability' : 'vulnerabilities'\n  } (${vulnerabilityStats})`;\n}\n\nexport function vulnerabilitiesToIssues(\n  vulnerabilities: Vulnerability[],\n  auditLevelMapping: AuditSeverity,\n): Issue[] {\n  if (vulnerabilities.length === 0) {\n    return [];\n  }\n\n  return vulnerabilities.map((detail): Issue => {\n    const versionRange =\n      detail.versionRange === '*'\n        ? md`${md.bold('all')} versions`\n        : md`versions ${md.bold(detail.versionRange)}`;\n    const directDependency =\n      typeof detail.directDependency === 'string' &&\n      detail.directDependency !== ''\n        ? md.code(detail.directDependency)\n        : '';\n    const depHierarchy = directDependency\n      ? md`${directDependency}'s dependency ${md.code(detail.name)}`\n      : md`${md.code(detail.name)} dependency`;\n\n    const vulnerabilitySummary = md`has a ${md.bold(\n      detail.severity,\n    )} vulnerability in ${versionRange}.`;\n    const fixInfo = detail.fixInformation ? ` ${detail.fixInformation}` : '';\n    const additionalInfo =\n      detail.title != null && detail.url != null\n        ? md` More information: ${md.link(detail.url, detail.title)}`\n        : '';\n\n    return {\n      message:\n        md`${depHierarchy} ${vulnerabilitySummary}${fixInfo}${additionalInfo}`.toString(),\n      severity: auditLevelMapping[detail.severity],\n    };\n  });\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/constants.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/constants.ts\";import path from 'node:path';\nimport { pluginWorkDir } from '@code-pushup/utils';\n\nexport const WORKDIR = pluginWorkDir('js-packages');\nexport const RUNNER_OUTPUT_PATH = path.join(WORKDIR, 'runner-output.json');\nexport const PLUGIN_CONFIG_PATH = path.join(\n  process.cwd(),\n  WORKDIR,\n  'plugin-config.json',\n);\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/outdated/transform.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/outdated\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/outdated/transform.ts\";import { md } from 'build-md';\nimport { clean, diff, neq } from 'semver';\nimport type { AuditOutput, Issue } from '@code-pushup/models';\nimport { objectFromEntries, pluralize } from '@code-pushup/utils';\nimport type { DependencyGroup, PackageManagerId } from '../../config.js';\nimport { dependencyGroupToLong } from '../../constants.js';\nimport { RELEASE_TYPES, outdatedSeverity } from './constants.js';\nimport type { OutdatedResult, PackageVersion } from './types.js';\n\nexport function outdatedResultToAuditOutput(\n  result: OutdatedResult,\n  packageManager: PackageManagerId,\n  depGroup: DependencyGroup,\n  totalDeps: number,\n): AuditOutput {\n  const relevantDependencies: OutdatedResult = result.filter(\n    dep => dep.type === dependencyGroupToLong[depGroup],\n  );\n\n  const validDependencies = relevantDependencies\n    .map(dep => ({\n      ...dep,\n      current: clean(dep.current),\n      latest: clean(dep.latest),\n    }))\n    .filter(\n      (dep): dep is OutdatedResult[number] =>\n        dep.current != null && dep.latest != null,\n    );\n\n  const outdatedDependencies = validDependencies.filter(dep =>\n    neq(dep.current, dep.latest),\n  );\n\n  const outdatedStats = outdatedDependencies.reduce(\n    (acc, dep) => {\n      const outdatedLevel = diff(dep.current, dep.latest);\n      if (outdatedLevel == null) {\n        return acc;\n      }\n      return { ...acc, [outdatedLevel]: acc[outdatedLevel] + 1 };\n    },\n    objectFromEntries(RELEASE_TYPES.map(versionType => [versionType, 0])),\n  );\n\n  const issues =\n    outdatedDependencies.length === 0\n      ? []\n      : outdatedToIssues(outdatedDependencies);\n\n  return {\n    slug: `${packageManager}-outdated-${depGroup}`,\n    score: calculateOutdatedScore(outdatedStats.major, totalDeps),\n    value: outdatedDependencies.length,\n    displayValue: outdatedToDisplayValue(outdatedStats),\n    details: { issues },\n  };\n}\n\nexport function calculateOutdatedScore(\n  majorOutdated: number,\n  totalDeps: number,\n) {\n  return totalDeps > 0 ? (totalDeps - majorOutdated) / totalDeps : 1;\n}\n\nexport function outdatedToDisplayValue(stats: PackageVersion) {\n  const total = Object.values(stats).reduce((acc, value) => acc + value, 0);\n\n  const versionBreakdown = RELEASE_TYPES.map(version =>\n    stats[version] > 0 ? `${stats[version]} ${version}` : '',\n  ).filter(text => text !== '');\n\n  if (versionBreakdown.length === 0) {\n    return 'all dependencies are up to date';\n  }\n\n  if (versionBreakdown.length > 1) {\n    return `${total} outdated package versions (${versionBreakdown.join(\n      ', ',\n    )})`;\n  }\n\n  return `${versionBreakdown[0]} outdated package ${pluralize(\n    'version',\n    total,\n  )}`;\n}\n\nexport function outdatedToIssues(dependencies: OutdatedResult): Issue[] {\n  return dependencies.map<Issue>(dep => {\n    const { name, current, latest, url } = dep;\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const outdatedLevel = diff(current, latest)!;\n    const packageReference =\n      url == null ? md.code(name) : md.link(url, md.code(name));\n\n    return {\n      message: md`Package ${packageReference} requires a ${md.bold(\n        outdatedLevel,\n      )} update from ${md.bold(current)} to ${md.bold(latest)}.`.toString(),\n      severity: outdatedSeverity[outdatedLevel],\n    };\n  });\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/outdated/constants.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/outdated\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/runner/outdated/constants.ts\";import type { ReleaseType } from 'semver';\nimport type { IssueSeverity } from '@code-pushup/models';\nimport { objectToKeys } from '@code-pushup/utils';\n\nexport const outdatedSeverity: Record<ReleaseType, IssueSeverity> = {\n  major: 'error',\n  premajor: 'info',\n  minor: 'warning',\n  preminor: 'info',\n  patch: 'info',\n  prepatch: 'info',\n  prerelease: 'info',\n};\n\n// RELEASE_TYPES directly exported from semver don't work out of the box\nexport const RELEASE_TYPES = objectToKeys(outdatedSeverity);\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/derive-package-manager.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/derive-package-manager.ts\";import { readFile } from 'node:fs/promises';\nimport path from 'node:path';\nimport { fileExists } from '@code-pushup/utils';\nimport type { PackageManagerId } from '../config.js';\nimport { deriveYarnVersion } from './derive-yarn.js';\n\nexport async function derivePackageManagerInPackageJson(\n  currentDir = process.cwd(),\n) {\n  if (await fileExists(path.join(currentDir, 'package.json'))) {\n    const content = JSON.parse(\n      (await readFile(path.join('package.json'))).toString(),\n    ) as { packageManager?: string };\n    const { packageManager: packageManagerData = '' } = content;\n\n    const [manager = '', version = ''] = packageManagerData.split('@');\n\n    if (manager === 'npm') {\n      return manager;\n    }\n    if (manager === 'pnpm') {\n      return manager;\n    }\n    if (manager === 'yarn') {\n      const majorVersion = Number(version.split('.')[0]);\n      return majorVersion > 1 ? 'yarn-modern' : 'yarn-classic';\n    }\n  }\n  return false;\n}\n\nexport async function derivePackageManager(\n  currentDir = process.cwd(),\n): Promise<PackageManagerId> {\n  const pkgManagerFromPackageJson =\n    await derivePackageManagerInPackageJson(currentDir);\n  if (pkgManagerFromPackageJson) {\n    return pkgManagerFromPackageJson;\n  }\n\n  // Check for lock files\n  if (await fileExists(path.join(currentDir, 'package-lock.json'))) {\n    return 'npm';\n  } else if (await fileExists(path.join(currentDir, 'pnpm-lock.yaml'))) {\n    return 'pnpm';\n  } else if (await fileExists(path.join(currentDir, 'yarn.lock'))) {\n    const yarnVersion = await deriveYarnVersion();\n    if (yarnVersion) {\n      return yarnVersion;\n    }\n  }\n\n  throw new Error(\n    'Could not detect package manager. Please provide it in the js-packages plugin config.',\n  );\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/derive-yarn.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-js-packages/src/lib/package-managers/derive-yarn.ts\";import { executeProcess } from '@code-pushup/utils';\n\nexport async function deriveYarnVersion() {\n  const { stdout } = await executeProcess({\n    command: 'yarn',\n    args: ['-v'],\n  });\n\n  const yarnVersion = Number.parseInt(stdout.toString().trim().at(0) ?? '', 10);\n  if (yarnVersion >= 2) {\n    return 'yarn-modern';\n  } else if (yarnVersion === 1) {\n    return 'yarn-classic';\n  }\n  return false;\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/lighthouse-plugin.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/lighthouse-plugin.ts\";import { createRequire } from 'node:module';\nimport type { PluginConfig } from '@code-pushup/models';\nimport { LIGHTHOUSE_PLUGIN_SLUG } from './constants.js';\nimport { normalizeFlags } from './normalize-flags.js';\nimport {\n  LIGHTHOUSE_GROUPS,\n  LIGHTHOUSE_NAVIGATION_AUDITS,\n} from './runner/constants.js';\nimport { createRunnerFunction } from './runner/runner.js';\nimport type { LighthouseOptions } from './types.js';\nimport { filterAuditsAndGroupsByOnlyOptions } from './utils.js';\n\nexport function lighthousePlugin(\n  url: string,\n  flags?: LighthouseOptions,\n): PluginConfig {\n  const { skipAudits, onlyAudits, onlyCategories, ...unparsedFlags } =\n    normalizeFlags(flags ?? {});\n\n  const { audits, groups } = filterAuditsAndGroupsByOnlyOptions(\n    LIGHTHOUSE_NAVIGATION_AUDITS,\n    LIGHTHOUSE_GROUPS,\n    { skipAudits, onlyAudits, onlyCategories },\n  );\n\n  const packageJson = createRequire(import.meta.url)(\n    '../../package.json',\n  ) as typeof import('../../package.json');\n\n  return {\n    slug: LIGHTHOUSE_PLUGIN_SLUG,\n    packageName: packageJson.name,\n    version: packageJson.version,\n    title: 'Lighthouse',\n    icon: 'lighthouse',\n    audits,\n    groups,\n    runner: createRunnerFunction(url, {\n      skipAudits,\n      onlyAudits,\n      onlyCategories,\n      ...unparsedFlags,\n    }),\n  };\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/constants.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/constants.ts\";import { DEFAULT_FLAGS } from 'chrome-launcher/dist/flags.js';\nimport path from 'node:path';\nimport { DEFAULT_PERSIST_OUTPUT_DIR } from '@code-pushup/models';\n\n// headless is needed to pass CI on Linux and Windows (locally it works without headless too)\nexport const DEFAULT_CHROME_FLAGS = [...DEFAULT_FLAGS, '--headless'];\n\nexport const LIGHTHOUSE_PLUGIN_SLUG = 'lighthouse';\nexport const LIGHTHOUSE_OUTPUT_PATH = path.join(\n  DEFAULT_PERSIST_OUTPUT_DIR,\n  LIGHTHOUSE_PLUGIN_SLUG,\n);\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/normalize-flags.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/normalize-flags.ts\";import { bold, yellow } from 'ansis';\nimport { ui } from '@code-pushup/utils';\nimport { LIGHTHOUSE_PLUGIN_SLUG } from './constants.js';\nimport { DEFAULT_CLI_FLAGS } from './runner/constants.js';\nimport type { LighthouseCliFlags } from './runner/types.js';\nimport type { LighthouseOptions } from './types.js';\n\nconst { onlyCategories, ...originalDefaultCliFlags } = DEFAULT_CLI_FLAGS;\nexport const DEFAULT_LIGHTHOUSE_OPTIONS = {\n  ...originalDefaultCliFlags,\n  onlyGroups: onlyCategories,\n} satisfies LighthouseOptions;\n\n// NOTE:\n// This is an intermediate variable to get `UnsupportedCliFlags`. For unknown reasons `typescript@5.3.3` doesn't work otherwise.\nconst lighthouseUnsupportedCliFlags = [\n  'precomputedLanternDataPath', // Path to the file where precomputed lantern data should be read from.\n  'chromeIgnoreDefaultFlags', // ignore default flags from Lighthouse CLI\n  // No error reporting implemented as in the source Sentry was involved\n  // See: https://github.com/GoogleChrome/lighthouse/blob/d8ccf70692216b7fa047a4eaa2d1277b0b7fe947/cli/bin.js#L124\n  'enableErrorReporting', // enable error reporting\n  // lighthouse CLI specific debug logs\n  'list-all-audits', // Prints a list of all available audits and exits.\n  'list-locales', // Prints a list of all supported locales and exits.\n  'list-trace-categories', // Prints a list of all required trace categories and exits.\n] as const;\ntype UnsupportedCliFlags = (typeof lighthouseUnsupportedCliFlags)[number];\n\nconst LIGHTHOUSE_UNSUPPORTED_CLI_FLAGS = new Set(lighthouseUnsupportedCliFlags);\n\nconst REFINED_STRING_OR_STRING_ARRAY = new Set([\n  'onlyAudits',\n  'onlyCategories',\n  'skipAudits',\n  'budgets',\n  'chromeFlags',\n]);\n\nexport function normalizeFlags(flags?: LighthouseOptions): LighthouseCliFlags {\n  const prefilledFlags = { ...DEFAULT_LIGHTHOUSE_OPTIONS, ...flags };\n\n  logUnsupportedFlagsInUse(prefilledFlags);\n\n  return Object.fromEntries(\n    Object.entries(prefilledFlags)\n      .filter(\n        ([flagName]) =>\n          !LIGHTHOUSE_UNSUPPORTED_CLI_FLAGS.has(\n            flagName as UnsupportedCliFlags,\n          ),\n      )\n      // in code-pushup lighthouse categories are mapped as groups, therefor we had to rename \"onlyCategories\" to \"onlyGroups\" for the user of the plugin as it was confusing\n      .map(([key, v]) => [key === 'onlyGroups' ? 'onlyCategories' : key, v])\n      // onlyAudits and onlyCategories cannot be empty arrays, otherwise skipAudits is ignored by lighthouse\n      .filter(([_, v]) => !(Array.isArray(v) && v.length === 0))\n      // undefined | string | string[] => string[] (empty for undefined)\n      .map(([key, v]) => {\n        if (!REFINED_STRING_OR_STRING_ARRAY.has(key as never)) {\n          return [key, v];\n        }\n        return [key, Array.isArray(v) ? v : v == null ? [] : [v]];\n      }),\n  ) as LighthouseCliFlags;\n}\n\nexport function logUnsupportedFlagsInUse(\n  flags: LighthouseOptions,\n  displayCount = 3,\n) {\n  const unsupportedFlagsInUse = Object.keys(flags).filter(flag =>\n    LIGHTHOUSE_UNSUPPORTED_CLI_FLAGS.has(flag as UnsupportedCliFlags),\n  );\n  if (unsupportedFlagsInUse.length > 0) {\n    const postFix = (count: number) =>\n      count > displayCount ? ` and ${count - displayCount} more.` : '';\n    ui().logger.debug(\n      `${yellow('\u26A0')} Plugin ${bold(\n        LIGHTHOUSE_PLUGIN_SLUG,\n      )} used unsupported flags: ${bold(\n        unsupportedFlagsInUse.slice(0, displayCount).join(', '),\n      )}${postFix(unsupportedFlagsInUse.length)}`,\n    );\n  }\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/constants.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/constants.ts\";import {\n  type CliFlags,\n  type Config,\n  type IcuMessage,\n  type Audit as LHAudit,\n  defaultConfig,\n} from 'lighthouse';\nimport path from 'node:path';\nimport type { Audit, Group } from '@code-pushup/models';\nimport { DEFAULT_CHROME_FLAGS, LIGHTHOUSE_OUTPUT_PATH } from '../constants.js';\n\nconst { audits, categories } = defaultConfig;\n\n// internal intermediate variable to derive the relevant audits\nconst allRawLighthouseAudits = await Promise.all(\n  (audits ?? []).map(loadLighthouseAudit),\n);\n\nexport const PLUGIN_SLUG = 'lighthouse';\nexport const LIGHTHOUSE_NAVIGATION_AUDITS: Audit[] = allRawLighthouseAudits\n  // This plugin only supports the \"navigation\" mode of Lighthouse in the current implementation\n  // If we don't exclude other audits we throw in the plugin output validation as some of the provided audits are not included in `lighthouse-report.json`\n  .filter(\n    audit =>\n      audit.meta.supportedModes == null ||\n      (Array.isArray(audit.meta.supportedModes) &&\n        audit.meta.supportedModes.includes('navigation')),\n  )\n  .map(audit => ({\n    slug: audit.meta.id,\n    title: getMetaString(audit.meta.title),\n    description: getMetaString(audit.meta.description),\n  }));\n\nconst navigationAuditSlugs = new Set(\n  LIGHTHOUSE_NAVIGATION_AUDITS.map(({ slug }) => slug),\n);\nexport const LIGHTHOUSE_GROUPS: Group[] = Object.entries(categories ?? {}).map(\n  ([id, category]) => ({\n    slug: id,\n    title: getMetaString(category.title),\n    ...(category.description && {\n      description: getMetaString(category.description),\n    }),\n    refs: category.auditRefs\n      .filter(({ id: auditSlug }) => navigationAuditSlugs.has(auditSlug))\n      .map(ref => ({\n        slug: ref.id,\n        weight: ref.weight,\n      })),\n  }),\n);\n\nfunction getMetaString(value: string | IcuMessage): string {\n  if (typeof value === 'string') {\n    return value;\n  }\n  return value.formattedDefault;\n}\n\nasync function loadLighthouseAudit(\n  value: Config.AuditJson,\n): Promise<typeof LHAudit> {\n  // the passed value directly includes the implementation as JS object\n  //   shape: { implementation: typeof LHAudit; options?: {}; }\n  if (typeof value === 'object' && 'implementation' in value) {\n    return value.implementation;\n  }\n  // the passed value is a `LH.Audit` class instance\n  //   shape: LHAudit\n  if (typeof value === 'function') {\n    return value;\n  }\n  // the passed value is the path directly\n  //   shape: string\n  // otherwise it is a JS object maintaining a `path` property\n  //   shape: { path: string, options?: {}; }\n  const file = typeof value === 'string' ? value : value.path;\n  const module = (await import(`lighthouse/core/audits/${file}.js`)) as {\n    default: typeof LHAudit;\n  };\n  return module.default;\n}\n\nexport const LIGHTHOUSE_REPORT_NAME = 'lighthouse-report.json';\n\nexport const DEFAULT_CLI_FLAGS = {\n  // default values extracted from\n  // https://github.com/GoogleChrome/lighthouse/blob/7d80178c37a1b600ea8f092fc0b098029799a659/cli/cli-flags.js#L80\n  verbose: false,\n  saveAssets: false,\n  chromeFlags: DEFAULT_CHROME_FLAGS,\n  port: 0,\n  hostname: '127.0.0.1',\n  view: false,\n  channel: 'cli',\n  // custom overwrites in favour of the plugin\n  // hide logs by default\n  quiet: true,\n  onlyAudits: [],\n  skipAudits: [],\n  onlyCategories: [],\n  output: ['json'],\n  outputPath: path.join(LIGHTHOUSE_OUTPUT_PATH, LIGHTHOUSE_REPORT_NAME),\n} satisfies Partial<CliFlags>;\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/runner.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/runner.ts\";import type { RunnerResult } from 'lighthouse';\nimport { runLighthouse } from 'lighthouse/cli/run.js';\nimport path from 'node:path';\nimport type { AuditOutputs, RunnerFunction } from '@code-pushup/models';\nimport { ensureDirectoryExists } from '@code-pushup/utils';\nimport { DEFAULT_CLI_FLAGS } from './constants.js';\nimport type { LighthouseCliFlags } from './types.js';\nimport {\n  determineAndSetLogLevel,\n  getConfig,\n  normalizeAuditOutputs,\n  toAuditOutputs,\n} from './utils.js';\n\nexport function createRunnerFunction(\n  urlUnderTest: string,\n  flags: LighthouseCliFlags = DEFAULT_CLI_FLAGS,\n): RunnerFunction {\n  return async (): Promise<AuditOutputs> => {\n    const {\n      configPath,\n      preset,\n      outputPath,\n      ...parsedFlags\n    }: Partial<LighthouseCliFlags> = flags;\n\n    const logLevel = determineAndSetLogLevel(parsedFlags);\n\n    const config = await getConfig({ configPath, preset });\n    if (outputPath) {\n      await ensureDirectoryExists(path.dirname(outputPath));\n    }\n\n    const enrichedFlags = {\n      ...parsedFlags,\n      logLevel,\n      outputPath,\n    };\n\n    const runnerResult: unknown = await runLighthouse(\n      urlUnderTest,\n      enrichedFlags,\n      config,\n    );\n\n    if (runnerResult == null) {\n      throw new Error('Lighthouse did not produce a result.');\n    }\n\n    const { lhr } = runnerResult as RunnerResult;\n    const auditOutputs = toAuditOutputs(Object.values(lhr.audits), flags);\n\n    return normalizeAuditOutputs(auditOutputs, enrichedFlags);\n  };\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/utils.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/utils.ts\";import { bold } from 'ansis';\nimport type { Config, FormattedIcu } from 'lighthouse';\nimport log from 'lighthouse-logger';\nimport desktopConfig from 'lighthouse/core/config/desktop-config.js';\nimport experimentalConfig from 'lighthouse/core/config/experimental-config.js';\nimport perfConfig from 'lighthouse/core/config/perf-config.js';\nimport type Details from 'lighthouse/types/lhr/audit-details';\nimport type { Result } from 'lighthouse/types/lhr/audit-result';\nimport type { AuditOutput, AuditOutputs } from '@code-pushup/models';\nimport {\n  formatReportScore,\n  importModule,\n  readJsonFile,\n  ui,\n} from '@code-pushup/utils';\nimport type { LighthouseOptions } from '../types.js';\nimport { logUnsupportedDetails, toAuditDetails } from './details/details.js';\nimport type { LighthouseCliFlags } from './types.js';\n\nexport function normalizeAuditOutputs(\n  auditOutputs: AuditOutputs,\n  flags: LighthouseOptions = { skipAudits: [] },\n): AuditOutputs {\n  const toSkip = new Set(flags.skipAudits ?? []);\n  return auditOutputs.filter(({ slug }) => !toSkip.has(slug));\n}\n\nexport class LighthouseAuditParsingError extends Error {\n  constructor(slug: string, error: Error) {\n    super(`\\nAudit ${bold(slug)} failed parsing details: \\n${error.message}`);\n  }\n}\n\nfunction formatBaseAuditOutput(lhrAudit: Result): AuditOutput {\n  const {\n    id: slug,\n    score,\n    numericValue,\n    displayValue,\n    scoreDisplayMode,\n  } = lhrAudit;\n  return {\n    slug,\n    score: score ?? 1,\n    value: numericValue ?? score ?? 0,\n    displayValue:\n      displayValue ??\n      (scoreDisplayMode === 'binary'\n        ? score === 1\n          ? 'passed'\n          : 'failed'\n        : score\n          ? `${formatReportScore(score)}%`\n          : undefined),\n  };\n}\n\nfunction processAuditDetails(\n  auditOutput: AuditOutput,\n  details: FormattedIcu<Details>,\n): AuditOutput {\n  try {\n    const parsedDetails = toAuditDetails(details);\n    return Object.keys(parsedDetails).length > 0\n      ? { ...auditOutput, details: parsedDetails }\n      : auditOutput;\n  } catch (error) {\n    throw new LighthouseAuditParsingError(auditOutput.slug, error as Error);\n  }\n}\n\nexport function toAuditOutputs(\n  lhrAudits: Result[],\n  { verbose = false }: { verbose?: boolean } = {},\n): AuditOutputs {\n  if (verbose) {\n    logUnsupportedDetails(lhrAudits);\n  }\n  return lhrAudits.map(audit => {\n    const auditOutput = formatBaseAuditOutput(audit);\n\n    return audit.details == null\n      ? auditOutput\n      : processAuditDetails(auditOutput, audit.details);\n  });\n}\n\nexport type LighthouseLogLevel =\n  | 'verbose'\n  | 'error'\n  | 'info'\n  | 'silent'\n  | 'warn'\n  | undefined;\nexport function determineAndSetLogLevel({\n  verbose,\n  quiet,\n}: {\n  verbose?: boolean;\n  quiet?: boolean;\n} = {}): LighthouseLogLevel {\n  // eslint-disable-next-line functional/no-let\n  let logLevel: LighthouseLogLevel = 'info';\n  // set logging preferences\n  if (verbose) {\n    logLevel = 'verbose';\n  } else if (quiet) {\n    logLevel = 'silent';\n  }\n\n  log.setLevel(logLevel);\n\n  return logLevel;\n}\n\nexport type ConfigOptions = Partial<\n  Pick<LighthouseCliFlags, 'configPath' | 'preset'>\n>;\n\nexport async function getConfig(\n  options: ConfigOptions = {},\n): Promise<Config | undefined> {\n  const { configPath: filepath, preset } = options;\n\n  if (filepath != null) {\n    if (filepath.endsWith('.json')) {\n      // Resolve the config file path relative to where cli was called.\n      return readJsonFile<Config>(filepath);\n    } else if (/\\.(ts|js|mjs)$/.test(filepath)) {\n      return importModule<Config>({ filepath, format: 'esm' });\n    } else {\n      ui().logger.info(`Format of file ${filepath} not supported`);\n    }\n  } else if (preset != null) {\n    switch (preset) {\n      case 'desktop':\n        return desktopConfig;\n      case 'perf':\n        return perfConfig as Config;\n      case 'experimental':\n        return experimentalConfig as Config;\n      default:\n        // as preset is a string literal the default case here is normally caught by TS and not possible to happen. Now in reality it can happen and preset could be a string not included in the literal.\n        // Therefore, we have to use `as string`. Otherwise, it will consider preset as type never\n        ui().logger.info(`Preset \"${preset as string}\" is not supported`);\n    }\n  }\n  return undefined;\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details/details.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details/details.ts\";import { bold, yellow } from 'ansis';\nimport type { FormattedIcu } from 'lighthouse';\nimport type Details from 'lighthouse/types/lhr/audit-details';\nimport type { Result } from 'lighthouse/types/lhr/audit-result';\nimport type { AuditDetails, Table } from '@code-pushup/models';\nimport { ui } from '@code-pushup/utils';\nimport { PLUGIN_SLUG } from '../constants.js';\nimport { parseOpportunityToAuditDetailsTable } from './opportunity.type.js';\nimport { parseTableToAuditDetailsTable } from './table.type.js';\n\nexport function toAuditDetails<T extends FormattedIcu<Details>>(\n  details: T | undefined,\n): AuditDetails {\n  if (details == null) {\n    return {};\n  }\n\n  const { type } = details;\n\n  switch (type) {\n    case 'table':\n      const table: Table | undefined = parseTableToAuditDetailsTable(details);\n      return table ? { table } : {};\n    case 'opportunity':\n      const opportunity: Table | undefined =\n        parseOpportunityToAuditDetailsTable(details);\n      return opportunity ? { table: opportunity } : {};\n  }\n  return {};\n}\n\n// @TODO implement all details\nexport const unsupportedDetailTypes = new Set([\n  'debugdata',\n  'treemap-data',\n  'screenshot',\n  'filmstrip',\n  'criticalrequestchain',\n]);\n\nexport function logUnsupportedDetails(\n  lhrAudits: Result[],\n  { displayCount = 3 }: { displayCount?: number } = {},\n) {\n  const slugsWithDetailParsingErrors = [\n    ...new Set(\n      lhrAudits\n        .filter(({ details }) =>\n          unsupportedDetailTypes.has(details?.type as string),\n        )\n        .map(({ details }) => details?.type),\n    ),\n  ];\n  if (slugsWithDetailParsingErrors.length > 0) {\n    const postFix = (count: number) =>\n      count > displayCount ? ` and ${count - displayCount} more.` : '';\n    ui().logger.debug(\n      `${yellow('\u26A0')} Plugin ${bold(\n        PLUGIN_SLUG,\n      )} skipped parsing of unsupported audit details: ${bold(\n        slugsWithDetailParsingErrors.slice(0, displayCount).join(', '),\n      )}${postFix(slugsWithDetailParsingErrors.length)}`,\n    );\n  }\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details/opportunity.type.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details/opportunity.type.ts\";import type Details from 'lighthouse/types/lhr/audit-details';\nimport {\n  type Table,\n  type TableRowObject,\n  tableSchema,\n} from '@code-pushup/models';\nimport { formatBytes, formatDuration, html } from '@code-pushup/utils';\nimport { parseTableColumns, parseTableEntry } from './table.type.js';\nimport { LighthouseAuditDetailsParsingError } from './utils.js';\n\nexport function parseOpportunityToAuditDetailsTable(\n  details: Details.Opportunity,\n): Table | undefined {\n  const { headings: rawHeadings, items } = details;\n\n  if (items.length === 0) {\n    return undefined;\n  }\n\n  try {\n    return tableSchema().parse({\n      title: 'Opportunity',\n      columns: parseTableColumns(rawHeadings),\n      rows: items.map(row => parseOpportunityItemToTableRow(row, rawHeadings)),\n    });\n  } catch (error) {\n    throw new LighthouseAuditDetailsParsingError(\n      'opportunity',\n      { items, headings: rawHeadings },\n      (error as Error).message.toString(),\n    );\n  }\n}\n\nexport function parseOpportunityItemToTableRow(\n  opportunityItem: Details.OpportunityItem,\n  headings: Details.TableColumnHeading[],\n): TableRowObject {\n  const keys = new Set(headings.map(({ key }) => key));\n  const valueTypesByKey = new Map(\n    headings.map(({ key, valueType }) => [key, valueType]),\n  );\n\n  return {\n    ...(Object.fromEntries(\n      Object.entries(opportunityItem)\n        // forward only properties with a given value\n        .filter(([key]) => keys.has(key))\n        .map(([key, value]) => {\n          const valueType = valueTypesByKey.get(key) as Details.ItemValueType;\n          return parseOpportunityEntry([key, value], valueType);\n        }),\n    ) as TableRowObject),\n  };\n}\n\nexport function parseOpportunityEntry(\n  [key, value]: [\n    keyof Details.OpportunityItem,\n    Details.OpportunityItem[string],\n  ],\n  valueType: Details.ItemValueType,\n) {\n  switch (key) {\n    case 'url':\n      return [key, html.link(String(value))];\n    case 'wastedPercent':\n      return [key, `${Number(value).toFixed(2)} %`];\n    case 'totalBytes':\n    case 'wastedBytes':\n      return [key, formatBytes(Number(value))];\n    case 'wastedMs':\n      return [key, formatDuration(Number(value))];\n    default:\n      return parseTableEntry([key, value], valueType);\n  }\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details/table.type.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details/table.type.ts\";import type Details from 'lighthouse/types/lhr/audit-details';\nimport {\n  type Table,\n  type TableColumnObject,\n  type TableRowObject,\n  tableSchema,\n} from '@code-pushup/models';\nimport { formatTableItemPropertyValue } from './item-value.js';\nimport { LighthouseAuditDetailsParsingError } from './utils.js';\n\nexport function parseTableToAuditDetailsTable(\n  details: Details.Table,\n): Table | undefined {\n  const { headings: rawHeadings, items } = details;\n\n  if (items.length === 0) {\n    return undefined;\n  }\n\n  try {\n    return tableSchema().parse({\n      columns: parseTableColumns(rawHeadings),\n      rows: items.map(row => parseTableRow(row, rawHeadings)),\n    });\n  } catch (error) {\n    throw new LighthouseAuditDetailsParsingError(\n      'table',\n      { items, headings: rawHeadings },\n      (error as Error).message.toString(),\n    );\n  }\n}\n\nexport function parseTableColumns(\n  rawHeadings: Details.TableColumnHeading[],\n): TableColumnObject[] {\n  return rawHeadings.map(({ key, label }) => ({\n    key: key ?? '',\n    ...(typeof label === 'string' && label.length > 0 ? { label } : {}),\n    align: 'left',\n  }));\n}\n\nexport function parseTableRow(\n  tableItem: Details.TableItem,\n  headings: Details.TableColumnHeading[],\n): TableRowObject {\n  const keys = new Set(headings.map(({ key }) => key));\n  const valueTypesByKey = new Map(\n    headings.map(({ key, valueType }) => [key, valueType]),\n  );\n\n  return Object.fromEntries(\n    Object.entries(tableItem)\n      .filter(([key]) => keys.has(key))\n      .map(([key, value]) => {\n        const valueType = valueTypesByKey.get(key);\n        return parseTableEntry([key, value], valueType);\n      }),\n  ) as TableRowObject;\n}\n\nexport function parseTableEntry<T extends Details.TableItem>(\n  [key, value]: [keyof T, T[keyof T]],\n  valueType?: Details.ItemValueType,\n): [keyof T, Details.ItemValue | undefined] {\n  if (value == null) {\n    return [key, value];\n  }\n\n  return [key, formatTableItemPropertyValue(value, valueType)];\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details/item-value.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details/item-value.ts\";import { bold } from 'ansis';\nimport type { IcuMessage } from 'lighthouse';\nimport type Details from 'lighthouse/types/lhr/audit-details';\nimport {\n  formatBytes,\n  formatDuration,\n  html,\n  truncateText,\n  ui,\n} from '@code-pushup/utils';\n\nexport type PrimitiveItemValue = string | number | boolean;\nexport type ObjectItemValue = Exclude<\n  Details.ItemValue,\n  PrimitiveItemValue | IcuMessage\n>;\nexport type SimpleItemValue =\n  | Extract<\n      ObjectItemValue,\n      Details.NumericValue | Details.CodeValue | Details.UrlValue\n    >\n  | PrimitiveItemValue;\n\nexport function trimSlice(item?: PrimitiveItemValue, maxLength = 0) {\n  const str = String(item).trim();\n  return maxLength > 0 ? str.slice(0, maxLength) : str;\n}\n\nexport function parseNodeValue(node?: Details.NodeValue): string {\n  const { selector = '' } = node ?? {};\n  return selector;\n}\n\n// eslint-disable-next-line max-lines-per-function\nexport function formatTableItemPropertyValue(\n  itemValue?: Details.ItemValue,\n  itemValueFormat?: Details.ItemValueType,\n) {\n  // null\n  if (itemValue == null) {\n    return '';\n  }\n\n  // Primitive Values\n  if (itemValueFormat == null) {\n    if (typeof itemValue === 'string') {\n      return trimSlice(itemValue);\n    }\n\n    if (typeof itemValue === 'number') {\n      return Number(itemValue);\n    }\n\n    if (typeof itemValue === 'boolean') {\n      return itemValue;\n    }\n  }\n\n  const parsedItemValue = parseTableItemPropertyValue(itemValue);\n\n  /* eslint-disable @typescript-eslint/no-magic-numbers */\n  switch (itemValueFormat) {\n    case 'bytes':\n      return formatBytes(Number(parsedItemValue));\n    case 'code':\n      return html.code(trimSlice(parsedItemValue as string));\n    case 'link':\n      const link = parsedItemValue as Details.LinkValue;\n      return html.link(link.url, link.text);\n    case 'url':\n      const url = parsedItemValue as string;\n      return html.link(url);\n    case 'timespanMs':\n    case 'ms':\n      return formatDuration(Number(parsedItemValue));\n    case 'node':\n      return parseNodeValue(itemValue as Details.NodeValue);\n    case 'source-location':\n      return truncateText(String(parsedItemValue), 200);\n    case 'numeric':\n      const num = Number(parsedItemValue);\n      if (num.toFixed(3).toString().endsWith('.000')) {\n        return String(num);\n      }\n      return String(num.toFixed(3));\n    case 'text':\n      return truncateText(String(parsedItemValue), 500);\n    case 'multi': // @TODO\n      // @TODO log verbose first, then implement data type\n      ui().logger.info(`Format type ${bold('multi')} is not implemented`);\n      return '';\n    case 'thumbnail': // @TODO\n      // @TODO log verbose first, then implement data type\n      ui().logger.info(`Format type ${bold('thumbnail')} is not implemented`);\n      return '';\n  }\n  /* eslint-enable @typescript-eslint/no-magic-numbers */\n\n  return itemValue;\n}\n\nexport function parseSimpleItemValue(\n  item: SimpleItemValue,\n): PrimitiveItemValue {\n  if (typeof item === 'object') {\n    const value = item.value;\n    if (typeof value === 'object') {\n      return value.formattedDefault;\n    }\n    return value;\n  }\n  return item;\n}\n\n// @TODO extract Link type from logic\nexport function parseTableItemPropertyValue(\n  itemValue?: Details.ItemValue,\n): PrimitiveItemValue | Details.LinkValue {\n  if (itemValue == null) {\n    return '';\n  }\n\n  // Primitive Values\n  if (\n    typeof itemValue === 'string' ||\n    typeof itemValue === 'number' ||\n    typeof itemValue === 'boolean'\n  ) {\n    return parseSimpleItemValue(itemValue);\n  }\n\n  // Object Values\n  const objectValue = itemValue as ObjectItemValue;\n  const { type } = objectValue;\n  switch (type) {\n    case 'code':\n    case 'url':\n      return String(parseSimpleItemValue(objectValue));\n    case 'node':\n      return parseNodeValue(objectValue);\n    case 'link':\n      return objectValue;\n    case 'numeric':\n      return Number(parseSimpleItemValue(objectValue));\n    case 'source-location':\n      const { url } = objectValue;\n      return String(url);\n    case 'subitems':\n      // @TODO log verbose first, then implement data type\n      ui().logger.info(`Value type ${bold('subitems')} is not implemented`);\n      return '';\n    case 'debugdata':\n      // @TODO log verbose first, then implement data type\n      ui().logger.info(`Value type ${bold('debugdata')} is not implemented`, {\n        silent: true,\n      });\n      return '';\n  }\n  // IcuMessage\n  return parseSimpleItemValue(objectValue as SimpleItemValue);\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details/utils.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/runner/details/utils.ts\";import { bold } from 'ansis';\nimport type Details from 'lighthouse/types/lhr/audit-details';\n\nexport class LighthouseAuditDetailsParsingError extends Error {\n  constructor(\n    type: Details['type'],\n    rawTable: Record<string, unknown>,\n    error: string,\n  ) {\n    super(\n      `Parsing lighthouse report details ${bold(\n        type,\n      )} failed: \\nRaw data:\\n ${JSON.stringify(rawTable, null, 2)}\\n${error}`,\n    );\n  }\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/utils.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/plugin-lighthouse/src/lib/utils.ts\";import type { Audit, CategoryRef, Group } from '@code-pushup/models';\nimport { filterItemRefsBy, toArray } from '@code-pushup/utils';\nimport { LIGHTHOUSE_PLUGIN_SLUG } from './constants.js';\nimport type { LighthouseCliFlags } from './runner/types.js';\n\nexport type LighthouseGroupSlugs =\n  | 'performance'\n  | 'accessibility'\n  | 'best-practices'\n  | 'seo'\n  | 'pwa';\n\nexport function lighthouseGroupRef(\n  groupSlug: LighthouseGroupSlugs,\n  weight = 1,\n): CategoryRef {\n  return {\n    plugin: LIGHTHOUSE_PLUGIN_SLUG,\n    slug: groupSlug,\n    type: 'group',\n    weight,\n  };\n}\n\nexport function lighthouseAuditRef(auditSlug: string, weight = 1): CategoryRef {\n  return {\n    plugin: LIGHTHOUSE_PLUGIN_SLUG,\n    slug: auditSlug,\n    type: 'audit',\n    weight,\n  };\n}\n\nexport class AuditsNotImplementedError extends Error {\n  constructor(auditSlugs: string[]) {\n    super(`audits: \"${auditSlugs.join(', ')}\" not implemented`);\n  }\n}\n\nexport function validateAudits(audits: Audit[], onlyAudits: string[]): boolean {\n  const missingAudtis = toArray(onlyAudits).filter(\n    slug => !audits.some(audit => audit.slug === slug),\n  );\n  if (missingAudtis.length > 0) {\n    throw new AuditsNotImplementedError(missingAudtis);\n  }\n  return true;\n}\n\nexport class CategoriesNotImplementedError extends Error {\n  constructor(categorySlugs: string[]) {\n    super(`categories: \"${categorySlugs.join(', ')}\" not implemented`);\n  }\n}\n\nexport function validateOnlyCategories(\n  groups: Group[],\n  onlyCategories: string | string[],\n): boolean {\n  const missingCategories = toArray(onlyCategories).filter(slug =>\n    groups.every(group => group.slug !== slug),\n  );\n  if (missingCategories.length > 0) {\n    throw new CategoriesNotImplementedError(missingCategories);\n  }\n  return true;\n}\n\nexport type FilterOptions = Partial<\n  Pick<LighthouseCliFlags, 'onlyAudits' | 'onlyCategories' | 'skipAudits'>\n>;\n\nexport function filterAuditsAndGroupsByOnlyOptions(\n  audits: Audit[],\n  groups: Group[],\n  options?: FilterOptions,\n): {\n  audits: Audit[];\n  groups: Group[];\n} {\n  const {\n    onlyAudits = [],\n    skipAudits = [],\n    onlyCategories = [],\n  } = options ?? {};\n\n  // category wins over audits\n  if (onlyCategories.length > 0) {\n    validateOnlyCategories(groups, onlyCategories);\n\n    const categorySlugs = new Set(onlyCategories);\n    const filteredGroups: Group[] = groups.filter(({ slug }) =>\n      categorySlugs.has(slug),\n    );\n    const auditSlugsFromRemainingGroups = new Set(\n      filteredGroups.flatMap(({ refs }) => refs.map(({ slug }) => slug)),\n    );\n    return {\n      audits: audits.filter(({ slug }) =>\n        auditSlugsFromRemainingGroups.has(slug),\n      ),\n      groups: filteredGroups,\n    };\n  } else if (onlyAudits.length > 0 || skipAudits.length > 0) {\n    validateAudits(audits, onlyAudits);\n    validateAudits(audits, skipAudits);\n    const onlyAuditSlugs = new Set(onlyAudits);\n    const skipAuditSlugs = new Set(skipAudits);\n    const filterAudits = ({ slug }: Pick<Audit, 'slug'>) =>\n      !(\n        // audit is NOT in given onlyAuditSlugs\n        (\n          (onlyAudits.length > 0 && !onlyAuditSlugs.has(slug)) ||\n          // audit IS in given skipAuditSlugs\n          (skipAudits.length > 0 && skipAuditSlugs.has(slug))\n        )\n      );\n    return {\n      audits: audits.filter(filterAudits),\n      groups: filterItemRefsBy(groups, filterAudits),\n    };\n  }\n  // return unchanged\n  return {\n    audits,\n    groups,\n  };\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/code-pushup.preset.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/code-pushup.preset.ts\";import type {\n  CategoryConfig,\n  CoreConfig,\n} from './packages/models/src/index.js';\nimport coveragePlugin, {\n  getNxCoveragePaths,\n} from './packages/plugin-coverage/src/index.js';\nimport docCoveragePlugin, { DocCoveragePluginConfig } from './packages/plugin-doc-coverage/src/index.js';\nimport { groups, PLUGIN_SLUG } from './packages/plugin-doc-coverage/src/lib/constants.js';\nimport { filterGroupsByOnlyAudits } from './packages/plugin-doc-coverage/src/lib/utils.js';\nimport eslintPlugin, {\n  eslintConfigFromAllNxProjects,\n  eslintConfigFromNxProject,\n} from './packages/plugin-eslint/src/index.js';\nimport jsPackagesPlugin from './packages/plugin-js-packages/src/index.js';\nimport lighthousePlugin, {\n  lighthouseGroupRef,\n} from './packages/plugin-lighthouse/src/index.js';\n\nexport const jsPackagesCategories: CategoryConfig[] = [\n  {\n    slug: 'security',\n    title: 'Security',\n    description: 'Finds known **vulnerabilities** in 3rd-party packages.',\n    refs: [\n      {\n        type: 'group',\n        plugin: 'js-packages',\n        slug: 'npm-audit',\n        weight: 1,\n      },\n    ],\n  },\n  {\n    slug: 'updates',\n    title: 'Updates',\n    description: 'Finds **outdated** 3rd-party packages.',\n    refs: [\n      {\n        type: 'group',\n        plugin: 'js-packages',\n        slug: 'npm-outdated',\n        weight: 1,\n      },\n    ],\n  },\n];\n\nexport const lighthouseCategories: CategoryConfig[] = [\n  {\n    slug: 'performance',\n    title: 'Performance',\n    refs: [lighthouseGroupRef('performance')],\n  },\n  {\n    slug: 'a11y',\n    title: 'Accessibility',\n    refs: [lighthouseGroupRef('accessibility')],\n  },\n  {\n    slug: 'best-practices',\n    title: 'Best Practices',\n    refs: [lighthouseGroupRef('best-practices')],\n  },\n  {\n    slug: 'seo',\n    title: 'SEO',\n    refs: [lighthouseGroupRef('seo')],\n  },\n];\n\nexport const eslintCategories: CategoryConfig[] = [\n  {\n    slug: 'bug-prevention',\n    title: 'Bug prevention',\n    description: 'Lint rules that find **potential bugs** in your code.',\n    refs: [{ type: 'group', plugin: 'eslint', slug: 'problems', weight: 1 }],\n  },\n  {\n    slug: 'code-style',\n    title: 'Code style',\n    description:\n      'Lint rules that promote **good practices** and consistency in your code.',\n    refs: [{ type: 'group', plugin: 'eslint', slug: 'suggestions', weight: 1 }],\n  },\n];\n\nexport function getDocCoverageCategories(config: DocCoveragePluginConfig): CategoryConfig[] {\n  return [{\n    slug: 'doc-coverage-cat',\n    title: 'Documentation coverage',\n    description: 'Measures how much of your code is **documented**.',\n    refs: filterGroupsByOnlyAudits(groups, config).map(group => ({\n      weight: 1,\n      type: 'group',\n      plugin: PLUGIN_SLUG,\n      slug: group.slug,\n    })),\n  }];\n}\n\n\n\nexport const coverageCategories: CategoryConfig[] = [\n  {\n    slug: 'code-coverage',\n    title: 'Code coverage',\n    description: 'Measures how much of your code is **covered by tests**.',\n    refs: [\n      {\n        type: 'group',\n        plugin: 'coverage',\n        slug: 'coverage',\n        weight: 1,\n      },\n    ],\n  },\n];\n\nexport const jsPackagesCoreConfig = async (): Promise<CoreConfig> => {\n  return {\n    plugins: [await jsPackagesPlugin()],\n    categories: jsPackagesCategories,\n  };\n};\n\nexport const lighthouseCoreConfig = async (\n  url: string,\n): Promise<CoreConfig> => {\n  return {\n    plugins: [await lighthousePlugin(url)],\n    categories: lighthouseCategories,\n  };\n};\n\nexport const docCoverageCoreConfig = async (config: DocCoveragePluginConfig): Promise<CoreConfig> => {\n  return {\n    plugins: [await docCoveragePlugin(config)],\n    categories: getDocCoverageCategories(config),\n  };\n};\n\nexport const eslintCoreConfigNx = async (\n  projectName?: string,\n): Promise<CoreConfig> => {\n  return {\n    plugins: [\n      await eslintPlugin(\n        await (projectName\n          ? eslintConfigFromNxProject(projectName)\n          : eslintConfigFromAllNxProjects()),\n      ),\n    ],\n    categories: eslintCategories,\n  };\n};\n\nexport const coverageCoreConfigNx = async (\n  projectName?: string,\n): Promise<CoreConfig> => {\n  if (projectName) {\n    throw new Error('coverageCoreConfigNx for single projects not implemented');\n  }\n  const targetNames = ['unit-test', 'integration-test'];\n  const targetArgs = [\n    '-t',\n    'unit-test',\n    'integration-test',\n    '--coverage.enabled',\n    '--skipNxCache',\n  ];\n  return {\n    plugins: [\n      await coveragePlugin({\n        coverageToolCommand: {\n          command: 'npx',\n          args: [\n            'nx',\n            projectName ? `run --project ${projectName}` : 'run-many',\n            ...targetArgs,\n          ],\n        },\n        reports: await getNxCoveragePaths(targetNames),\n      }),\n    ],\n    categories: coverageCategories,\n  };\n};\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/index.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/index.ts\";export { exists } from '@code-pushup/models';\nexport { comparePairs, matchArrayItemsByKey, type Diff } from './lib/diff.js';\nexport { stringifyError } from './lib/errors.js';\nexport {\n  ProcessError,\n  executeProcess,\n  type ProcessConfig,\n  type ProcessObserver,\n  type ProcessResult,\n} from './lib/execute-process.js';\nexport {\n  crawlFileSystem,\n  directoryExists,\n  ensureDirectoryExists,\n  fileExists,\n  filePathToCliArg,\n  findLineNumberInText,\n  findNearestFile,\n  importModule,\n  logMultipleFileResults,\n  pluginWorkDir,\n  projectToFilename,\n  readJsonFile,\n  readTextFile,\n  removeDirectoryIfExists,\n  type CrawlFileSystemOptions,\n  type FileResult,\n  type MultipleFileResults,\n} from './lib/file-system.js';\nexport { filterItemRefsBy } from './lib/filter.js';\nexport {\n  formatBytes,\n  formatDuration,\n  pluralize,\n  pluralizeToken,\n  slugify,\n  truncateDescription,\n  truncateIssueMessage,\n  truncateText,\n  truncateTitle,\n} from './lib/formatting.js';\nexport {\n  getCurrentBranchOrTag,\n  getHashFromTag,\n  getHashes,\n  getLatestCommit,\n  getSemverTags,\n  type LogResult,\n} from './lib/git/git.commits-and-tags.js';\nexport {\n  formatGitPath,\n  getGitRoot,\n  guardAgainstLocalChanges,\n  safeCheckout,\n  toGitPath,\n} from './lib/git/git.js';\nexport { groupByStatus } from './lib/group-by-status.js';\nexport {\n  isPromiseFulfilledResult,\n  isPromiseRejectedResult,\n  hasNoNullableProps,\n} from './lib/guards.js';\nexport { logMultipleResults } from './lib/log-results.js';\nexport { link, ui, type CliUi, type Column } from './lib/logging.js';\nexport { mergeConfigs } from './lib/merge-configs.js';\nexport { getProgressBar, type ProgressBar } from './lib/progress.js';\nexport {\n  CODE_PUSHUP_DOMAIN,\n  CODE_PUSHUP_UNICODE_LOGO,\n  FOOTER_PREFIX,\n  README_LINK,\n  TERMINAL_WIDTH,\n} from './lib/reports/constants.js';\nexport {\n  listAuditsFromAllPlugins,\n  listGroupsFromAllPlugins,\n} from './lib/reports/flatten-plugins.js';\nexport { generateMdReport } from './lib/reports/generate-md-report.js';\nexport {\n  generateMdReportsDiff,\n  generateMdReportsDiffForMonorepo,\n} from './lib/reports/generate-md-reports-diff.js';\nexport { loadReport } from './lib/reports/load-report.js';\nexport { logStdoutSummary } from './lib/reports/log-stdout-summary.js';\nexport { scoreReport } from './lib/reports/scoring.js';\nexport { sortReport } from './lib/reports/sorting.js';\nexport type {\n  ScoredCategoryConfig,\n  ScoredGroup,\n  ScoredReport,\n} from './lib/reports/types.js';\nexport {\n  calcDuration,\n  compareIssueSeverity,\n  formatReportScore,\n} from './lib/reports/utils.js';\nexport { isSemver, normalizeSemver, sortSemvers } from './lib/semver.js';\nexport * from './lib/text-formats/index.js';\nexport {\n  capitalize,\n  countOccurrences,\n  distinct,\n  factorOf,\n  fromJsonLines,\n  objectFromEntries,\n  objectToCliArgs,\n  objectToEntries,\n  objectToKeys,\n  toArray,\n  toJsonLines,\n  toNumberPrecision,\n  toOrdinal,\n  toUnixNewlines,\n  toUnixPath,\n  type CliArgsObject,\n} from './lib/transform.js';\nexport type {\n  ExcludeNullableProps,\n  ExtractArray,\n  ExtractArrays,\n  ItemOrArray,\n  Prettify,\n  WithRequired,\n} from './lib/types.js';\nexport { verboseUtils } from './lib/verbose-utils.js';\nexport { zodErrorMessageBuilder } from './lib/zod-validation.js';\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/execute-process.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/execute-process.ts\";import {\n  type ChildProcess,\n  type ChildProcessByStdio,\n  type SpawnOptionsWithStdioTuple,\n  type StdioPipe,\n  spawn,\n} from 'node:child_process';\nimport type { Readable, Writable } from 'node:stream';\nimport { calcDuration } from './reports/utils.js';\n\n/**\n * Represents the process result.\n * @category Types\n * @public\n * @property {string} stdout - The stdout of the process.\n * @property {string} stderr - The stderr of the process.\n * @property {number | null} code - The exit code of the process.\n */\nexport type ProcessResult = {\n  stdout: string;\n  stderr: string;\n  code: number | null;\n  date: string;\n  duration: number;\n};\n\n/**\n * Error class for process errors.\n * Contains additional information about the process result.\n * @category Error\n * @public\n * @class\n * @extends Error\n * @example\n * const result = await executeProcess({})\n * .catch((error) => {\n *   if (error instanceof ProcessError) {\n *   console.error(error.code);\n *   console.error(error.stderr);\n *   console.error(error.stdout);\n *   }\n * });\n *\n */\nexport class ProcessError extends Error {\n  code: number | null;\n  stderr: string;\n  stdout: string;\n\n  constructor(result: ProcessResult) {\n    super(result.stderr);\n    this.code = result.code;\n    this.stderr = result.stderr;\n    this.stdout = result.stdout;\n  }\n}\n\n/**\n * Process config object. Contains the command, args and observer.\n * @param cfg - process config object with command, args and observer (optional)\n * @category Types\n * @public\n * @property {string} command - The command to execute.\n * @property {string[]} args - The arguments for the command.\n * @property {ProcessObserver} observer - The observer for the process.\n *\n * @example\n *\n * // bash command\n * const cfg = {\n *   command: 'bash',\n *   args: ['-c', 'echo \"hello world\"']\n * };\n *\n * // node command\n * const cfg = {\n * command: 'node',\n * args: ['--version']\n * };\n *\n * // npx command\n * const cfg = {\n * command: 'npx',\n * args: ['--version']\n *\n */\nexport type ProcessConfig = Omit<\n  SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>,\n  'stdio'\n> & {\n  command: string;\n  args?: string[];\n  observer?: ProcessObserver;\n  ignoreExitCode?: boolean;\n};\n\n/**\n * Process observer object. Contains the onStdout, error and complete function.\n * @category Types\n * @public\n * @property {function} onStdout - The onStdout function of the observer (optional).\n * @property {function} onError - The error function of the observer (optional).\n * @property {function} onComplete - The complete function of the observer (optional).\n *\n * @example\n * const observer = {\n *  onStdout: (stdout) => console.info(stdout)\n *  }\n */\nexport type ProcessObserver = {\n  onStdout?: (stdout: string, sourceProcess?: ChildProcess) => void;\n  onStderr?: (stderr: string, sourceProcess?: ChildProcess) => void;\n  onError?: (error: ProcessError) => void;\n  onComplete?: () => void;\n};\n\n/**\n * Executes a process and returns a promise with the result as `ProcessResult`.\n *\n * @example\n *\n * // sync process execution\n * const result = await executeProcess({\n *  command: 'node',\n *  args: ['--version']\n * });\n *\n * console.info(result);\n *\n * // async process execution\n * const result = await executeProcess({\n *    command: 'node',\n *    args: ['download-data.js'],\n *    observer: {\n *      onStdout: updateProgress,\n *      error: handleError,\n *      complete: cleanLogs,\n *    }\n * });\n *\n * console.info(result);\n *\n * @param cfg - see {@link ProcessConfig}\n */\nexport function executeProcess(cfg: ProcessConfig): Promise<ProcessResult> {\n  const { command, args, observer, ignoreExitCode = false, ...options } = cfg;\n  const { onStdout, onStderr, onError, onComplete } = observer ?? {};\n  const date = new Date().toISOString();\n  const start = performance.now();\n\n  return new Promise((resolve, reject) => {\n    // shell:true tells Windows to use shell command for spawning a child process\n    const spawnedProcess = spawn(command, args ?? [], {\n      shell: true,\n      windowsHide: true,\n      ...options,\n    }) as ChildProcessByStdio<Writable, Readable, Readable>;\n\n    // eslint-disable-next-line functional/no-let\n    let stdout = '';\n    // eslint-disable-next-line functional/no-let\n    let stderr = '';\n\n    spawnedProcess.stdout.on('data', data => {\n      stdout += String(data);\n      onStdout?.(String(data), spawnedProcess);\n    });\n\n    spawnedProcess.stderr.on('data', data => {\n      stderr += String(data);\n      onStderr?.(String(data), spawnedProcess);\n    });\n\n    spawnedProcess.on('error', err => {\n      stderr += err.toString();\n    });\n\n    spawnedProcess.on('close', code => {\n      const timings = { date, duration: calcDuration(start) };\n      if (code === 0 || ignoreExitCode) {\n        onComplete?.();\n        resolve({ code, stdout, stderr, ...timings });\n      } else {\n        const errorMsg = new ProcessError({ code, stdout, stderr, ...timings });\n        onError?.(errorMsg);\n        reject(errorMsg);\n      }\n    });\n  });\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/utils.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/utils.ts\";import ansis, { type Ansis } from 'ansis';\nimport { type InlineText, md } from 'build-md';\nimport type {\n  AuditDiff,\n  AuditReport,\n  CategoryRef,\n  IssueSeverity as CliIssueSeverity,\n  Group,\n  Issue,\n} from '@code-pushup/models';\nimport { SCORE_COLOR_RANGE } from './constants.js';\nimport type {\n  ScoredReport,\n  SortableAuditReport,\n  SortableGroup,\n} from './types.js';\n\nexport function formatReportScore(score: number): string {\n  const scaledScore = score * 100;\n  const roundedScore = Math.round(scaledScore);\n\n  return roundedScore === 100 && score !== 1\n    ? Math.floor(scaledScore).toString()\n    : roundedScore.toString();\n}\n\nexport function formatScoreWithColor(\n  score: number,\n  options?: { skipBold?: boolean },\n): InlineText {\n  const styledNumber = options?.skipBold\n    ? formatReportScore(score)\n    : md.bold(formatReportScore(score));\n  return md`${scoreMarker(score)} ${styledNumber}`;\n}\n\nexport type MarkerShape = 'circle' | 'square';\nexport type ScoreColors = 'red' | 'yellow' | 'green';\nexport const MARKERS: Record<MarkerShape, Record<ScoreColors, string>> = {\n  circle: {\n    red: '\uD83D\uDD34',\n    yellow: '\uD83D\uDFE1',\n    green: '\uD83D\uDFE2',\n  },\n  square: {\n    red: '\uD83D\uDFE5',\n    yellow: '\uD83D\uDFE8',\n    green: '\uD83D\uDFE9',\n  },\n};\n\nexport function scoreMarker(\n  score: number,\n  markerType: MarkerShape = 'circle',\n): string {\n  if (score >= SCORE_COLOR_RANGE.GREEN_MIN) {\n    return MARKERS[markerType].green;\n  }\n  if (score >= SCORE_COLOR_RANGE.YELLOW_MIN) {\n    return MARKERS[markerType].yellow;\n  }\n  return MARKERS[markerType].red;\n}\n\nexport function getDiffMarker(diff: number): string {\n  if (diff > 0) {\n    return '\u2191';\n  }\n  if (diff < 0) {\n    return '\u2193';\n  }\n  return '';\n}\n\nexport function colorByScoreDiff(text: string, diff: number): InlineText {\n  const color = diff > 0 ? 'green' : diff < 0 ? 'red' : 'gray';\n  return shieldsBadge(text, color);\n}\n\nexport function shieldsBadge(text: string, color: string): InlineText {\n  return md.image(\n    `https://img.shields.io/badge/${encodeURIComponent(text)}-${color}`,\n    text,\n  );\n}\n\nexport function formatDiffNumber(diff: number): string {\n  const number =\n    Math.abs(diff) === Number.POSITIVE_INFINITY ? '\u221E' : `${Math.abs(diff)}`;\n  const sign = diff < 0 ? '\u2212' : '+';\n  return `${sign}${number}`;\n}\n\nexport function severityMarker(severity: 'info' | 'warning' | 'error'): string {\n  if (severity === 'error') {\n    return '\uD83D\uDEA8';\n  }\n  if (severity === 'warning') {\n    return '\u26A0\uFE0F';\n  }\n  return '\u2139\uFE0F';\n}\n\nconst MIN_NON_ZERO_RESULT = 0.1;\n\nexport function roundValue(value: number): number {\n  const roundedValue = Math.round(value * 10) / 10; // round with max 1 decimal\n  if (roundedValue === 0 && value !== 0) {\n    return MIN_NON_ZERO_RESULT * Math.sign(value);\n  }\n  return roundedValue;\n}\n\nexport function formatScoreChange(diff: number): InlineText {\n  const marker = getDiffMarker(diff);\n  const text = formatDiffNumber(roundValue(diff * 100));\n  return colorByScoreDiff(`${marker} ${text}`, diff);\n}\n\nexport function formatValueChange({\n  values,\n  scores,\n}: Pick<AuditDiff, 'values' | 'scores'>): InlineText {\n  const marker = getDiffMarker(values.diff);\n  const percentage =\n    values.before === 0\n      ? values.diff > 0\n        ? Number.POSITIVE_INFINITY\n        : Number.NEGATIVE_INFINITY\n      : roundValue((values.diff / values.before) * 100);\n  // eslint-disable-next-line no-irregular-whitespace\n  const text = `${formatDiffNumber(percentage)}\u2009%`;\n  return colorByScoreDiff(`${marker} ${text}`, scores.diff);\n}\n\nexport function calcDuration(start: number, stop?: number): number {\n  return Math.round((stop ?? performance.now()) - start);\n}\n\nexport function countWeightedRefs(refs: CategoryRef[]) {\n  return refs\n    .filter(({ weight }) => weight > 0)\n    .reduce((sum, { weight }) => sum + weight, 0);\n}\n\nexport function countCategoryAudits(\n  refs: CategoryRef[],\n  plugins: ScoredReport['plugins'],\n): number {\n  // Create lookup object for groups within each plugin\n  const groupLookup = plugins.reduce<Record<string, Record<string, Group>>>(\n    (lookup, plugin) => {\n      if (plugin.groups == null || plugin.groups.length === 0) {\n        return lookup;\n      }\n\n      return {\n        ...lookup,\n        [plugin.slug]: Object.fromEntries(\n          plugin.groups.map(group => [group.slug, group]),\n        ),\n      };\n    },\n    {},\n  );\n\n  // Count audits\n  return refs.reduce((acc, ref) => {\n    if (ref.type === 'group') {\n      const groupRefs = groupLookup[ref.plugin]?.[ref.slug]?.refs;\n      return acc + (groupRefs?.length ?? 0);\n    }\n    return acc + 1;\n  }, 0);\n}\n\nexport function compareCategoryAuditsAndGroups(\n  a: SortableAuditReport | SortableGroup,\n  b: SortableAuditReport | SortableGroup,\n): number {\n  if (a.score !== b.score) {\n    return a.score - b.score;\n  }\n\n  if (a.weight !== b.weight) {\n    return b.weight - a.weight;\n  }\n\n  if ('value' in a && 'value' in b && a.value !== b.value) {\n    return b.value - a.value;\n  }\n\n  return a.title.localeCompare(b.title);\n}\n\nexport function compareAudits(a: AuditReport, b: AuditReport): number {\n  if (a.score !== b.score) {\n    return a.score - b.score;\n  }\n\n  if (a.value !== b.value) {\n    return b.value - a.value;\n  }\n\n  return a.title.localeCompare(b.title);\n}\n\nexport function compareIssueSeverity(\n  severity1: CliIssueSeverity,\n  severity2: CliIssueSeverity,\n): number {\n  const levels: Record<CliIssueSeverity, number> = {\n    info: 0,\n    warning: 1,\n    error: 2,\n  };\n  return levels[severity1] - levels[severity2];\n}\n\nexport function throwIsNotPresentError(\n  itemName: string,\n  presentPlace: string,\n): never {\n  throw new Error(`${itemName} is not present in ${presentPlace}`);\n}\n\nexport function getPluginNameFromSlug(\n  slug: string,\n  plugins: ScoredReport['plugins'],\n): string {\n  return (\n    plugins.find(({ slug: pluginSlug }) => pluginSlug === slug)?.title || slug\n  );\n}\n\nexport function compareIssues(a: Issue, b: Issue): number {\n  if (a.severity !== b.severity) {\n    return -compareIssueSeverity(a.severity, b.severity);\n  }\n  if (!a.source && b.source) {\n    return -1;\n  }\n  if (a.source && !b.source) {\n    return 1;\n  }\n  if (a.source?.file !== b.source?.file) {\n    return a.source?.file.localeCompare(b.source?.file || '') ?? 0;\n  }\n  return compareSourceFilePosition(a.source?.position, b.source?.position);\n}\n\nfunction compareSourceFilePosition(\n  a: NonNullable<Issue['source']>['position'],\n  b: NonNullable<Issue['source']>['position'],\n): number {\n  if (!a && b) {\n    return -1;\n  }\n  if (a && !b) {\n    return 1;\n  }\n  if (a?.startLine !== b?.startLine) {\n    return (a?.startLine ?? 0) - (b?.startLine ?? 0);\n  }\n  return 0;\n}\n\n// @TODO rethink implementation\nexport function applyScoreColor(\n  { score, text }: { score: number; text?: string },\n  style: Ansis = ansis,\n) {\n  const formattedScore = text ?? formatReportScore(score);\n\n  if (score >= SCORE_COLOR_RANGE.GREEN_MIN) {\n    return text\n      ? style.green(formattedScore)\n      : style.bold(style.green(formattedScore));\n  }\n\n  if (score >= SCORE_COLOR_RANGE.YELLOW_MIN) {\n    return text\n      ? style.yellow(formattedScore)\n      : style.bold(style.yellow(formattedScore));\n  }\n\n  return text\n    ? style.red(formattedScore)\n    : style.bold(style.red(formattedScore));\n}\n\nexport function targetScoreIcon(\n  score: number,\n  targetScore?: number,\n  options: {\n    passIcon?: string;\n    failIcon?: string;\n    prefix?: string;\n    postfix?: string;\n  } = {},\n): string {\n  if (targetScore != null) {\n    const {\n      passIcon = '\u2705',\n      failIcon = '\u274C',\n      prefix = '',\n      postfix = '',\n    } = options;\n    if (score >= targetScore) {\n      return `${prefix}${passIcon}${postfix}`;\n    }\n    return `${prefix}${failIcon}${postfix}`;\n  }\n  return '';\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/file-system.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/file-system.ts\";import { bold, gray } from 'ansis';\nimport { type Options, bundleRequire } from 'bundle-require';\nimport { mkdir, readFile, readdir, rm, stat } from 'node:fs/promises';\nimport path from 'node:path';\nimport { formatBytes } from './formatting.js';\nimport { logMultipleResults } from './log-results.js';\nimport { ui } from './logging.js';\n\nexport async function readTextFile(filePath: string): Promise<string> {\n  const buffer = await readFile(filePath);\n  return buffer.toString();\n}\n\nexport async function readJsonFile<T = unknown>(filePath: string): Promise<T> {\n  const text = await readTextFile(filePath);\n  return JSON.parse(text) as T;\n}\n\nexport async function fileExists(filePath: string): Promise<boolean> {\n  try {\n    const stats = await stat(filePath);\n    return stats.isFile();\n  } catch {\n    return false;\n  }\n}\n\nexport async function directoryExists(filePath: string): Promise<boolean> {\n  try {\n    const stats = await stat(filePath);\n    return stats.isDirectory();\n  } catch {\n    return false;\n  }\n}\n\nexport async function ensureDirectoryExists(baseDir: string) {\n  try {\n    await mkdir(baseDir, { recursive: true });\n    return;\n  } catch (error) {\n    ui().logger.info((error as { code: string; message: string }).message);\n    if ((error as { code: string }).code !== 'EEXIST') {\n      throw error;\n    }\n  }\n}\n\nexport async function removeDirectoryIfExists(dir: string) {\n  if (await directoryExists(dir)) {\n    await rm(dir, { recursive: true, force: true });\n  }\n}\n\nexport type FileResult = readonly [string] | readonly [string, number];\nexport type MultipleFileResults = PromiseSettledResult<FileResult>[];\n\nexport function logMultipleFileResults(\n  fileResults: MultipleFileResults,\n  messagePrefix: string,\n): void {\n  const succeededTransform = (result: PromiseFulfilledResult<FileResult>) => {\n    const [fileName, size] = result.value;\n    const formattedSize = size ? ` (${gray(formatBytes(size))})` : '';\n    return `- ${bold(fileName)}${formattedSize}`;\n  };\n  const failedTransform = (result: PromiseRejectedResult) =>\n    `- ${bold(result.reason as string)}`;\n\n  logMultipleResults<FileResult>(\n    fileResults,\n    messagePrefix,\n    succeededTransform,\n    failedTransform,\n  );\n}\n\nexport async function importModule<T = unknown>(options: Options): Promise<T> {\n  const { mod } = await bundleRequire<object>(options);\n\n  if (typeof mod === 'object' && 'default' in mod) {\n    return mod.default as T;\n  }\n  return mod as T;\n}\n\nexport function pluginWorkDir(slug: string): string {\n  return path.join('node_modules', '.code-pushup', slug);\n}\n\nexport type CrawlFileSystemOptions<T> = {\n  directory: string;\n  pattern?: string | RegExp;\n  fileTransform?: (filePath: string) => Promise<T> | T;\n};\nexport async function crawlFileSystem<T = string>(\n  options: CrawlFileSystemOptions<T>,\n): Promise<T[]> {\n  const {\n    directory,\n    pattern,\n    fileTransform = (filePath: string) => filePath as T,\n  } = options;\n\n  const files = await readdir(directory);\n  const promises = files.map(async (file): Promise<T | T[]> => {\n    const filePath = path.join(directory, file);\n    const stats = await stat(filePath);\n\n    if (stats.isDirectory()) {\n      return crawlFileSystem({ directory: filePath, pattern, fileTransform });\n    }\n    if (stats.isFile() && (!pattern || new RegExp(pattern).test(file))) {\n      return fileTransform(filePath);\n    }\n    return [];\n  });\n\n  const resultsNestedArray = await Promise.all(promises);\n  return resultsNestedArray.flat() as T[];\n}\n\nexport async function findNearestFile(\n  fileNames: string[],\n  cwd = process.cwd(),\n): Promise<string | undefined> {\n  // eslint-disable-next-line functional/no-loop-statements\n  for (\n    // eslint-disable-next-line functional/no-let\n    let directory = cwd;\n    directory !== path.dirname(directory);\n    directory = path.dirname(directory)\n  ) {\n    // eslint-disable-next-line functional/no-loop-statements\n    for (const file of fileNames) {\n      if (await fileExists(path.join(directory, file))) {\n        return path.join(directory, file);\n      }\n    }\n  }\n  return undefined;\n}\n\nexport function findLineNumberInText(\n  content: string,\n  pattern: string,\n): number | null {\n  const lines = content.split(/\\r?\\n/); // Split lines, handle both Windows and UNIX line endings\n\n  const lineNumber = lines.findIndex(line => line.includes(pattern)) + 1; // +1 because line numbers are 1-based\n  return lineNumber === 0 ? null : lineNumber; // If the package isn't found, return null\n}\n\nexport function filePathToCliArg(filePath: string): string {\n  // needs to be escaped if spaces included\n  return `\"${filePath}\"`;\n}\n\nexport function projectToFilename(project: string): string {\n  return project.replace(/[/\\\\\\s]+/g, '-').replace(/@/g, '');\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/formatting.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/formatting.ts\";import {\n  MAX_DESCRIPTION_LENGTH,\n  MAX_ISSUE_MESSAGE_LENGTH,\n  MAX_TITLE_LENGTH,\n} from '@code-pushup/models';\n\nexport function slugify(text: string): string {\n  return text\n    .trim()\n    .toLowerCase()\n    .replace(/\\s+|\\//g, '-')\n    .replace(/[^a-z\\d-]/g, '');\n}\n\nexport function pluralize(text: string, amount?: number): string {\n  if (amount != null && Math.abs(amount) === 1) {\n    return text;\n  }\n\n  if (text.endsWith('y')) {\n    return `${text.slice(0, -1)}ies`;\n  }\n  if (text.endsWith('s')) {\n    return `${text}es`;\n  }\n  return `${text}s`;\n}\n\nexport function formatBytes(bytes: number, decimals = 2) {\n  const positiveBytes = Math.max(bytes, 0);\n\n  // early exit\n  if (positiveBytes === 0) {\n    return '0 B';\n  }\n\n  const k = 1024;\n  const dm = Math.max(decimals, 0);\n  const sizes = ['B', 'kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];\n\n  const i = Math.floor(Math.log(positiveBytes) / Math.log(k));\n\n  return `${Number.parseFloat((positiveBytes / Math.pow(k, i)).toFixed(dm))} ${\n    sizes[i]\n  }`;\n}\n\nexport function pluralizeToken(token: string, times: number): string {\n  return `${times} ${Math.abs(times) === 1 ? token : pluralize(token)}`;\n}\n\nexport function formatDuration(duration: number, granularity = 0): string {\n  if (duration < 1000) {\n    return `${granularity ? duration.toFixed(granularity) : duration} ms`;\n  }\n  return `${(duration / 1000).toFixed(2)} s`;\n}\n\nexport function formatDate(date: Date): string {\n  const locale = 'en-US'; // fixed locale to ensure consistency across local defaults execution\n  return date\n    .toLocaleString(locale, {\n      weekday: 'short',\n      month: 'short',\n      day: 'numeric',\n      year: 'numeric',\n      hour: 'numeric',\n      minute: '2-digit',\n      timeZoneName: 'short',\n    })\n    .replace(/\\u202F/g, ' '); // see https://github.com/nodejs/node/issues/45171\n}\n\nexport function truncateText(\n  text: string,\n  options:\n    | number\n    | {\n        maxChars: number;\n        position?: 'start' | 'middle' | 'end';\n        ellipsis?: string;\n      },\n): string {\n  const {\n    maxChars,\n    position = 'end',\n    ellipsis = '...',\n  } = typeof options === 'number' ? { maxChars: options } : options;\n  if (text.length <= maxChars) {\n    return text;\n  }\n\n  const maxLength = maxChars - ellipsis.length;\n  switch (position) {\n    case 'start':\n      return ellipsis + text.slice(-maxLength).trim();\n    case 'middle':\n      const halfMaxChars = Math.floor(maxLength / 2);\n      return (\n        text.slice(0, halfMaxChars).trim() +\n        ellipsis +\n        text.slice(-halfMaxChars).trim()\n      );\n    case 'end':\n      return text.slice(0, maxLength).trim() + ellipsis;\n  }\n}\n\nexport function truncateTitle(text: string): string {\n  return truncateText(text, MAX_TITLE_LENGTH);\n}\n\nexport function truncateDescription(text: string): string {\n  return truncateText(text, MAX_DESCRIPTION_LENGTH);\n}\n\nexport function truncateIssueMessage(text: string): string {\n  return truncateText(text, MAX_ISSUE_MESSAGE_LENGTH);\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/logging.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/logging.ts\";import isaacs_cliui from '@isaacs/cliui';\nimport { cliui } from '@poppinss/cliui';\nimport { underline } from 'ansis';\nimport { TERMINAL_WIDTH } from './reports/constants.js';\n\n// eslint-disable-next-line  @typescript-eslint/no-explicit-any\ntype ArgumentsType<T> = T extends (...args: infer U) => any ? U : never;\nexport type CliUiBase = ReturnType<typeof cliui>;\ntype UI = ReturnType<typeof isaacs_cliui>;\ntype CliExtension = {\n  row: (r: ArgumentsType<UI['div']>) => void;\n};\nexport type Column = {\n  text: string;\n  width?: number;\n  align?: 'right' | 'left' | 'center';\n  padding: number[];\n  border?: boolean;\n};\nexport type CliUi = CliUiBase & CliExtension;\n\n// eslint-disable-next-line import/no-mutable-exports,functional/no-let\nexport let singletonUiInstance: CliUiBase | undefined;\n\nexport function ui(): CliUi {\n  if (singletonUiInstance === undefined) {\n    singletonUiInstance = cliui();\n  }\n  return {\n    ...singletonUiInstance,\n    row: args => {\n      logListItem(args);\n    },\n  };\n}\n\n// eslint-disable-next-line functional/no-let\nlet singletonisaacUi: UI | undefined;\nexport function logListItem(args: ArgumentsType<UI['div']>) {\n  if (singletonisaacUi === undefined) {\n    singletonisaacUi = isaacs_cliui({ width: TERMINAL_WIDTH });\n  }\n  singletonisaacUi.div(...args);\n  const content = singletonisaacUi.toString();\n  // eslint-disable-next-line functional/immutable-data\n  singletonisaacUi.rows = [];\n  singletonUiInstance?.logger.log(content);\n}\n\nexport function link(text: string) {\n  return underline.blueBright(text);\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/git/git.commits-and-tags.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/git\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/git/git.commits-and-tags.ts\";import { type LogOptions as SimpleGitLogOptions, simpleGit } from 'simple-git';\nimport { type Commit, commitSchema } from '@code-pushup/models';\nimport { isSemver } from '../semver.js';\n\nexport async function getLatestCommit(\n  git = simpleGit(),\n): Promise<Commit | null> {\n  const log = await git.log({\n    maxCount: 1,\n    // git log -1 --pretty=format:\"%H %s %an %aI\" - See: https://git-scm.com/docs/pretty-formats\n    format: { hash: '%H', message: '%s', author: '%an', date: '%aI' },\n  });\n  return commitSchema.parse(log.latest);\n}\n\nexport async function getCurrentBranchOrTag(\n  git = simpleGit(),\n): Promise<string> {\n  return (\n    (await git.branch().then(r => r.current)) ||\n    // If no current branch, try to get the tag\n    // @TODO use simple git\n    (await git\n      .raw(['describe', '--tags', '--exact-match'])\n      .then(out => out.trim()))\n  );\n}\n\nexport type LogResult = { hash: string; message: string };\n\nfunction validateFilter({ from, to }: LogOptions) {\n  if (to && !from) {\n    // throw more user-friendly error instead of:\n    // fatal: ambiguous argument '...a': unknown revision or path not in the working tree.\n    // Use '--' to separate paths from revisions, like this:\n    // 'git <command> [<revision>...] -- [<file>...]'\n    throw new Error(\n      `filter needs the \"from\" option defined to accept the \"to\" option.\\n`,\n    );\n  }\n}\n\nexport function filterLogs(\n  allTags: string[],\n  opt?: Pick<LogOptions, 'from' | 'to' | 'maxCount'>,\n) {\n  if (!opt) {\n    return allTags;\n  }\n  validateFilter(opt);\n  const { from, to, maxCount } = opt;\n  const finIndex = <T>(tagName?: string, fallback?: T) => {\n    const idx = allTags.indexOf(tagName ?? '');\n    if (idx !== -1) {\n      return idx;\n    }\n    return fallback;\n  };\n  const fromIndex = finIndex(from, 0);\n  const toIndex = finIndex(to, undefined);\n  return allTags\n    .slice(fromIndex, toIndex ? toIndex + 1 : toIndex)\n    .slice(0, maxCount ?? undefined);\n}\n\nexport async function getHashFromTag(\n  tag: string,\n  git = simpleGit(),\n): Promise<LogResult> {\n  const tagDetails = await git.show(['--no-patch', '--format=%H', tag]);\n  const hash = tagDetails.trim(); // Remove quotes and trim whitespace\n  return {\n    hash: hash.split('\\n').at(-1) ?? '',\n    message: tag,\n  };\n}\n\nexport type LogOptions = {\n  targetBranch?: string;\n  from?: string;\n  to?: string;\n  maxCount?: number;\n};\n\nexport async function getSemverTags(\n  opt: LogOptions = {},\n  git = simpleGit(),\n): Promise<LogResult[]> {\n  validateFilter(opt);\n  const { targetBranch, ...options } = opt;\n  // make sure we have a target branch\n  // eslint-disable-next-line functional/no-let\n  let currentBranch;\n  if (targetBranch) {\n    currentBranch = await getCurrentBranchOrTag(git);\n    await git.checkout(targetBranch);\n  }\n\n  // Fetch all tags merged into the target branch\n  const tagsRaw = await git.tag([\n    '--merged',\n    targetBranch ?? (await getCurrentBranchOrTag(git)),\n  ]);\n\n  const allTags = tagsRaw\n    .split(/\\n/)\n    .map(tag => tag.trim())\n    .filter(Boolean)\n    .filter(isSemver);\n\n  const relevantTags = filterLogs(allTags, options);\n\n  const tagsWithHashes: LogResult[] = await Promise.all(\n    relevantTags.map(tag => getHashFromTag(tag, git)),\n  );\n\n  if (currentBranch) {\n    await git.checkout(currentBranch);\n  }\n\n  return tagsWithHashes;\n}\n\n/**\n * `getHashes` returns a list of commit hashes. Internally it uses `git.log()` to determine the commits within a range.\n * The amount can be limited to a maximum number of commits specified by `maxCount`.\n * With `from` and `to`, you can specify a range of commits.\n *\n * **NOTE:**\n * In Git, specifying a range with two dots (`from..to`) selects commits that are reachable from `to` but not from `from`.\n * Essentially, it shows the commits that are in `to` but not in `from`, excluding the commits unique to `from`.\n *\n * Example:\n *\n * Let's consider the following commit history:\n *\n *   A---B---C---D---E (main)\n *\n * Using `git log B..D`, you would get the commits C and D:\n *\n *   C---D\n *\n * This is because these commits are reachable from D but not from B.\n *\n * ASCII Representation:\n *\n *   Main Branch:    A---B---C---D---E\n *                       \\       \\\n *                        \\       +--- Commits included in `git log B..D`\n *                         \\\n *                          +--- Excluded by the `from` parameter\n *\n * With `simple-git`, when you specify a `from` and `to` range like this:\n *\n *   git.log({ from: 'B', to: 'D' });\n *\n * It interprets it similarly, selecting commits between B and D, inclusive of D but exclusive of B.\n * For `git.log({ from: 'B', to: 'D' })` or `git log B..D`, commits C and D are selected.\n *\n * @param options Object containing `from`, `to`, and optionally `maxCount` to specify the commit range and limit.\n * @param git The `simple-git` instance used to execute Git commands.\n */\nexport async function getHashes(\n  options: SimpleGitLogOptions & Pick<LogOptions, 'targetBranch'> = {},\n  git = simpleGit(),\n): Promise<LogResult[]> {\n  const { targetBranch, from, to, maxCount, ...opt } = options;\n\n  validateFilter({ from, to });\n\n  // Ensure you are on the correct branch\n  // eslint-disable-next-line functional/no-let\n  let currentBranch;\n  if (targetBranch) {\n    currentBranch = await getCurrentBranchOrTag(git);\n    await git.checkout(targetBranch);\n  }\n\n  const logs = await git.log({\n    ...opt,\n    format: {\n      hash: '%H',\n      message: '%s',\n    },\n    from,\n    to,\n    maxCount,\n  });\n\n  // Ensure you are back to the initial branch\n  if (targetBranch) {\n    await git.checkout(currentBranch as string);\n  }\n\n  return [...logs.all];\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/semver.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/semver.ts\";import { rcompare, valid } from 'semver';\n\nexport function normalizeSemver(semverString: string): string {\n  if (semverString.startsWith('v') || semverString.startsWith('V')) {\n    return semverString.slice(1);\n  }\n\n  if (semverString.includes('@')) {\n    return semverString.split('@').at(-1) ?? '';\n  }\n\n  return semverString;\n}\n\nexport function isSemver(semverString = ''): boolean {\n  return valid(normalizeSemver(semverString)) != null;\n}\n\nexport function sortSemvers(semverStrings: string[]): string[] {\n  return semverStrings.map(normalizeSemver).filter(isSemver).sort(rcompare);\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/git/git.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/git\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/git/git.ts\";import path from 'node:path';\nimport { type StatusResult, simpleGit } from 'simple-git';\nimport { ui } from '../logging.js';\nimport { toUnixPath } from '../transform.js';\n\nexport function getGitRoot(git = simpleGit()): Promise<string> {\n  return git.revparse('--show-toplevel');\n}\n\nexport function formatGitPath(filePath: string, gitRoot: string): string {\n  const absolutePath = path.isAbsolute(filePath)\n    ? filePath\n    : path.join(process.cwd(), filePath);\n  const relativePath = path.relative(gitRoot, absolutePath);\n  return toUnixPath(relativePath);\n}\n\nexport async function toGitPath(\n  filePath: string,\n  git = simpleGit(),\n): Promise<string> {\n  const gitRoot = await getGitRoot(git);\n  return formatGitPath(filePath, gitRoot);\n}\n\nexport class GitStatusError extends Error {\n  static ignoredProps = new Set(['current', 'tracking']);\n\n  static getReducedStatus(status: StatusResult) {\n    return Object.fromEntries(\n      Object.entries(status)\n        .filter(([key]) => !this.ignoredProps.has(key))\n        .filter(\n          (\n            entry: [\n              string,\n              number | string | boolean | null | undefined | unknown[],\n            ],\n          ) => {\n            const value = entry[1];\n            if (value == null) {\n              return false;\n            }\n            if (Array.isArray(value) && value.length === 0) {\n              return false;\n            }\n            if (typeof value === 'number' && value === 0) {\n              return false;\n            }\n            return !(typeof value === 'boolean' && !value);\n          },\n        ),\n    );\n  }\n\n  constructor(status: StatusResult) {\n    super(\n      `Working directory needs to be clean before we you can proceed. Commit your local changes or stash them: \\n ${JSON.stringify(\n        GitStatusError.getReducedStatus(status),\n        null,\n        2,\n      )}`,\n    );\n  }\n}\n\nexport async function guardAgainstLocalChanges(\n  git = simpleGit(),\n): Promise<void> {\n  const status = await git.status(['-s']);\n  if (status.files.length > 0) {\n    throw new GitStatusError(status);\n  }\n}\n\nexport async function safeCheckout(\n  branchOrHash: string,\n  forceCleanStatus = false,\n  git = simpleGit(),\n): Promise<void> {\n  // git requires a clean history to check out a branch\n  if (forceCleanStatus) {\n    await git.raw(['reset', '--hard']);\n    await git.clean(['f', 'd']);\n    ui().logger.info(`git status cleaned`);\n  }\n  await guardAgainstLocalChanges(git);\n  await git.checkout(branchOrHash);\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/transform.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/transform.ts\";import { platform } from 'node:os';\n\nexport function toArray<T>(val: T | T[]): T[] {\n  return Array.isArray(val) ? val : [val];\n}\n\nexport function objectToKeys<T extends object>(obj: T) {\n  return Object.keys(obj) as (keyof T)[];\n}\n\nexport function objectToEntries<T extends object>(obj: T) {\n  return Object.entries(obj) as [keyof T, T[keyof T]][];\n}\n\nexport function objectFromEntries<K extends PropertyKey, V>(entries: [K, V][]) {\n  return Object.fromEntries(entries) as Record<K, V>;\n}\n\nexport function countOccurrences<T extends PropertyKey>(\n  values: T[],\n): Partial<Record<T, number>> {\n  return values.reduce<Partial<Record<T, number>>>(\n    (acc, value) => ({ ...acc, [value]: (acc[value] ?? 0) + 1 }),\n    {},\n  );\n}\n\nexport function distinct<T extends string | number | boolean>(array: T[]): T[] {\n  return [...new Set(array)];\n}\n\nexport function deepClone<T>(obj: T): T {\n  return obj == null || typeof obj !== 'object' ? obj : structuredClone(obj);\n}\n\nexport function factorOf<T>(items: T[], filterFn: (i: T) => boolean): number {\n  const itemCount = items.length;\n  // early exit for empty rows\n  if (!itemCount) {\n    return 1;\n  }\n  const filterCount = items.filter(filterFn).length;\n  // if no rows result from the filter fn we forward return 1 as factor\n  return filterCount === 0 ? 1 : (itemCount - filterCount) / itemCount;\n}\n\ntype ArgumentValue = number | string | boolean | string[];\nexport type CliArgsObject<T extends object = Record<string, ArgumentValue>> =\n  T extends never\n    ? Record<string, ArgumentValue | undefined> | { _: string }\n    : T;\n\n/**\n * Converts an object with different types of values into an array of command-line arguments.\n *\n * @example\n * const args = objectToProcessArgs({\n *   _: ['node', 'index.js'], // node index.js\n *   name: 'Juanita', // --name=Juanita\n *   formats: ['json', 'md'] // --format=json --format=md\n * });\n */\nexport function objectToCliArgs<\n  T extends object = Record<string, ArgumentValue>,\n>(params?: CliArgsObject<T>): string[] {\n  if (!params) {\n    return [];\n  }\n\n  return Object.entries(params).flatMap(([key, value]) => {\n    // process/file/script\n    if (key === '_') {\n      return Array.isArray(value) ? value : [`${value}`];\n    }\n    const prefix = key.length === 1 ? '-' : '--';\n    // \"-*\" arguments (shorthands)\n    if (Array.isArray(value)) {\n      return value.map(v => `${prefix}${key}=\"${v}\"`);\n    }\n    // \"--*\" arguments ==========\n\n    if (Array.isArray(value)) {\n      return value.map(v => `${prefix}${key}=\"${v}\"`);\n    }\n\n    if (typeof value === 'object') {\n      return Object.entries(value as Record<string, ArgumentValue>).flatMap(\n        // transform nested objects to the dot notation `key.subkey`\n        ([k, v]) => objectToCliArgs({ [`${key}.${k}`]: v }),\n      );\n    }\n\n    if (typeof value === 'string') {\n      return [`${prefix}${key}=\"${value}\"`];\n    }\n\n    if (typeof value === 'number') {\n      return [`${prefix}${key}=${value}`];\n    }\n\n    if (typeof value === 'boolean') {\n      return [`${prefix}${value ? '' : 'no-'}${key}`];\n    }\n\n    throw new Error(`Unsupported type ${typeof value} for key ${key}`);\n  });\n}\n\nexport function toUnixPath(path: string): string {\n  return path.replace(/\\\\/g, '/');\n}\n\nexport function toUnixNewlines(text: string): string {\n  return platform() === 'win32' ? text.replace(/\\r\\n/g, '\\n') : text;\n}\n\nexport function fromJsonLines<T = unknown>(jsonLines: string) {\n  const unifiedNewLines = toUnixNewlines(jsonLines).trim();\n  return JSON.parse(`[${unifiedNewLines.split('\\n').join(',')}]`) as T;\n}\n\nexport function toJsonLines<T>(json: T[]) {\n  return json.map(item => JSON.stringify(item)).join('\\n');\n}\n\nexport function capitalize<T extends string>(text: T): Capitalize<T> {\n  return `${text.charAt(0).toLocaleUpperCase()}${text.slice(\n    1,\n  )}` as Capitalize<T>;\n}\n\nexport function toNumberPrecision(\n  value: number,\n  decimalPlaces: number,\n): number {\n  return Number(\n    `${Math.round(\n      Number.parseFloat(`${value}e${decimalPlaces}`),\n    )}e-${decimalPlaces}`,\n  );\n}\n\nexport function toOrdinal(value: number): string {\n  /* eslint-disable @typescript-eslint/no-magic-numbers */\n  if (value % 10 === 1 && value % 100 !== 11) {\n    return `${value}st`;\n  }\n\n  if (value % 10 === 2 && value % 100 !== 12) {\n    return `${value}nd`;\n  }\n\n  if (value % 10 === 3 && value % 100 !== 13) {\n    return `${value}rd`;\n  }\n  /* eslint-enable @typescript-eslint/no-magic-numbers */\n\n  return `${value}th`;\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/merge-configs.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/merge-configs.ts\";import type {\n  CategoryConfig,\n  CoreConfig,\n  PersistConfig,\n  PluginConfig,\n  UploadConfig,\n} from '@code-pushup/models';\n\nexport function mergeConfigs(\n  config: CoreConfig,\n  ...configs: Partial<CoreConfig>[]\n): Partial<CoreConfig> {\n  return configs.reduce(\n    (acc, obj) => ({\n      ...acc,\n      ...mergeCategories(acc.categories, obj.categories),\n      ...mergePlugins(acc.plugins, obj.plugins),\n      ...mergePersist(acc.persist, obj.persist),\n      ...mergeUpload(acc.upload, obj.upload),\n    }),\n    config,\n  );\n}\n\nfunction mergeCategories(\n  a: CategoryConfig[] | undefined,\n  b: CategoryConfig[] | undefined,\n): Pick<CoreConfig, 'categories'> {\n  if (!a && !b) {\n    return {};\n  }\n\n  const mergedMap = new Map<string, CategoryConfig>();\n\n  const addToMap = (categories: CategoryConfig[]) => {\n    categories.forEach(newObject => {\n      if (mergedMap.has(newObject.slug)) {\n        const existingObject: CategoryConfig | undefined = mergedMap.get(\n          newObject.slug,\n        );\n\n        mergedMap.set(newObject.slug, {\n          ...existingObject,\n          ...newObject,\n\n          refs: mergeByUniqueCategoryRefCombination(\n            existingObject?.refs,\n            newObject.refs,\n          ),\n        });\n      } else {\n        mergedMap.set(newObject.slug, newObject);\n      }\n    });\n  };\n\n  if (a) {\n    addToMap(a);\n  }\n  if (b) {\n    addToMap(b);\n  }\n\n  // Convert the map back to an array\n  return { categories: [...mergedMap.values()] };\n}\n\nfunction mergePlugins(\n  a: PluginConfig[] | undefined,\n  b: PluginConfig[] | undefined,\n): Pick<CoreConfig, 'plugins'> {\n  if (!a && !b) {\n    return { plugins: [] };\n  }\n\n  const mergedMap = new Map<string, PluginConfig>();\n\n  const addToMap = (plugins: PluginConfig[]) => {\n    plugins.forEach(newObject => {\n      mergedMap.set(newObject.slug, newObject);\n    });\n  };\n\n  if (a) {\n    addToMap(a);\n  }\n  if (b) {\n    addToMap(b);\n  }\n\n  return { plugins: [...mergedMap.values()] };\n}\n\nfunction mergePersist(\n  a: PersistConfig | undefined,\n  b: PersistConfig | undefined,\n): Pick<CoreConfig, 'persist'> {\n  if (!a && !b) {\n    return {};\n  }\n\n  if (a) {\n    return b ? { persist: { ...a, ...b } } : {};\n  } else {\n    return { persist: b };\n  }\n}\n\nfunction mergeByUniqueCategoryRefCombination<\n  T extends { slug: string; type: string; plugin: string },\n>(a: T[] | undefined, b: T[] | undefined) {\n  const map = new Map<string, T>();\n\n  const addToMap = (refs: T[]) => {\n    refs.forEach(ref => {\n      const uniqueIdentification = `${ref.type}:${ref.plugin}:${ref.slug}`;\n      if (map.has(uniqueIdentification)) {\n        map.set(uniqueIdentification, {\n          ...map.get(uniqueIdentification),\n          ...ref,\n        });\n      } else {\n        map.set(uniqueIdentification, ref);\n      }\n    });\n  };\n\n  // Add objects from both arrays to the map\n  if (a) {\n    addToMap(a);\n  }\n  if (b) {\n    addToMap(b);\n  }\n\n  return [...map.values()];\n}\n\nfunction mergeUpload(\n  a: UploadConfig | undefined,\n  b: UploadConfig | undefined,\n): Pick<CoreConfig, 'upload'> {\n  if (!a && !b) {\n    return {};\n  }\n\n  if (a) {\n    return b ? { upload: { ...a, ...b } } : {};\n  } else {\n    return { upload: b };\n  }\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/progress.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/progress.ts\";import { black, bold, gray, green } from 'ansis';\nimport { type CtorOptions, MultiProgressBars } from 'multi-progress-bars';\nimport { TERMINAL_WIDTH } from './reports/constants.js';\n\ntype BarStyles = 'active' | 'done' | 'idle';\ntype StatusStyles = Record<BarStyles, (s: string) => string>;\nexport const barStyles: StatusStyles = {\n  active: (s: string) => green(s),\n  done: (s: string) => gray(s),\n  idle: (s: string) => gray(s),\n};\n\nexport const messageStyles: StatusStyles = {\n  active: (s: string) => black(s),\n  done: (s: string) => bold.green(s),\n  idle: (s: string) => gray(s),\n};\n\nexport type ProgressBar = {\n  // @TODO find better naming\n  incrementInSteps: (numSteps: number) => void;\n  updateTitle: (title: string) => void;\n  endProgress: (message?: string) => void;\n};\n\n// eslint-disable-next-line functional/no-let\nlet mpb: MultiProgressBars;\n\nexport function getSingletonProgressBars(\n  options?: Partial<CtorOptions>,\n): MultiProgressBars {\n  if (!mpb) {\n    mpb = new MultiProgressBars({\n      progressWidth: TERMINAL_WIDTH,\n      initMessage: '',\n      border: true,\n      ...options,\n    });\n  }\n  return mpb;\n}\n\nexport function getProgressBar(taskName: string): ProgressBar {\n  const tasks = getSingletonProgressBars();\n\n  // Initialize progress bar if not set\n  tasks.addTask(taskName, {\n    type: 'percentage',\n    percentage: 0,\n    message: '',\n    barTransformFn: barStyles.idle,\n  });\n\n  return {\n    incrementInSteps: (numPlugins: number) => {\n      tasks.incrementTask(taskName, {\n        percentage: 1 / numPlugins,\n        barTransformFn: barStyles.active,\n      });\n    },\n    updateTitle: (title: string) => {\n      tasks.updateTask(taskName, {\n        message: title,\n        barTransformFn: barStyles.active,\n      });\n    },\n    endProgress: (message = '') => {\n      tasks.done(taskName, {\n        message: messageStyles.done(message),\n        barTransformFn: barStyles.done,\n      });\n    },\n  };\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/generate-md-report.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/generate-md-report.ts\";import { type InlineText, MarkdownDocument, md } from 'build-md';\nimport type { AuditReport, Issue, Report } from '@code-pushup/models';\nimport { formatDate, formatDuration } from '../formatting.js';\nimport { HIERARCHY } from '../text-formats/index.js';\nimport {\n  FOOTER_PREFIX,\n  README_LINK,\n  REPORT_HEADLINE_TEXT,\n} from './constants.js';\nimport {\n  formatSourceLine,\n  linkToLocalSourceForIde,\n  metaDescription,\n  tableSection,\n} from './formatting.js';\nimport {\n  categoriesDetailsSection,\n  categoriesOverviewSection,\n} from './generate-md-report-categoy-section.js';\nimport type { MdReportOptions, ScoredReport } from './types.js';\nimport { formatReportScore, scoreMarker, severityMarker } from './utils.js';\n\nexport function auditDetailsAuditValue({\n  score,\n  value,\n  displayValue,\n}: AuditReport): InlineText {\n  return md`${scoreMarker(score, 'square')} ${md.bold(\n    String(displayValue ?? value),\n  )} (score: ${formatReportScore(score)})`;\n}\n\nfunction hasCategories(\n  report: ScoredReport,\n): report is ScoredReport & Required<Pick<ScoredReport, 'categories'>> {\n  return !!report.categories && report.categories.length > 0;\n}\n\nexport function generateMdReport(\n  report: ScoredReport,\n  options?: MdReportOptions,\n): string {\n  return new MarkdownDocument()\n    .heading(HIERARCHY.level_1, REPORT_HEADLINE_TEXT)\n    .$concat(\n      ...(hasCategories(report)\n        ? [categoriesOverviewSection(report), categoriesDetailsSection(report)]\n        : []),\n      auditsSection(report, options),\n      aboutSection(report),\n    )\n    .rule()\n    .paragraph(md`${FOOTER_PREFIX} ${md.link(README_LINK, 'Code PushUp')}`)\n    .toString();\n}\n\nexport function auditDetailsIssues(\n  issues: Issue[] = [],\n  options?: MdReportOptions,\n): MarkdownDocument | null {\n  if (issues.length === 0) {\n    return null;\n  }\n  return new MarkdownDocument().heading(HIERARCHY.level_4, 'Issues').table(\n    [\n      { heading: 'Severity', alignment: 'center' },\n      { heading: 'Message', alignment: 'left' },\n      { heading: 'Source file', alignment: 'left' },\n      { heading: 'Line(s)', alignment: 'center' },\n    ],\n    issues.map(({ severity: level, message, source }: Issue) => {\n      const severity = md`${severityMarker(level)} ${md.italic(level)}`;\n\n      if (!source) {\n        return [severity, message];\n      }\n      const file = linkToLocalSourceForIde(source, options);\n      if (!source.position) {\n        return [severity, message, file];\n      }\n      const line = formatSourceLine(source.position);\n      return [severity, message, file, line];\n    }),\n  );\n}\n\nexport function auditDetails(\n  audit: AuditReport,\n  options?: MdReportOptions,\n): MarkdownDocument {\n  const { table, issues = [] } = audit.details ?? {};\n  const detailsValue = auditDetailsAuditValue(audit);\n\n  // undefined details OR empty details (undefined issues OR empty issues AND empty table)\n  if (issues.length === 0 && !table?.rows.length) {\n    return new MarkdownDocument().paragraph(detailsValue);\n  }\n\n  const tableSectionContent = table && tableSection(table);\n  const issuesSectionContent =\n    issues.length > 0 && auditDetailsIssues(issues, options);\n\n  return new MarkdownDocument().details(\n    detailsValue,\n    new MarkdownDocument().$concat(tableSectionContent, issuesSectionContent),\n  );\n}\n\nexport function auditsSection(\n  { plugins }: Pick<ScoredReport, 'plugins'>,\n  options?: MdReportOptions,\n): MarkdownDocument {\n  return new MarkdownDocument()\n    .heading(HIERARCHY.level_2, '\uD83D\uDEE1\uFE0F Audits')\n    .$foreach(\n      plugins.flatMap(plugin =>\n        plugin.audits.map(audit => ({ ...audit, plugin })),\n      ),\n      (doc, { plugin, ...audit }) => {\n        const auditTitle = `${audit.title} (${plugin.title})`;\n        const detailsContent = auditDetails(audit, options);\n        const descriptionContent = metaDescription(audit);\n\n        return doc\n          .heading(HIERARCHY.level_3, auditTitle)\n          .$concat(detailsContent)\n          .paragraph(descriptionContent);\n      },\n    );\n}\n\nexport function aboutSection(\n  report: Omit<ScoredReport, 'packageName'>,\n): MarkdownDocument {\n  const { date, plugins } = report;\n  return new MarkdownDocument()\n    .heading(HIERARCHY.level_2, 'About')\n    .paragraph(\n      md`Report was created by ${md.link(\n        README_LINK,\n        'Code PushUp',\n      )} on ${formatDate(new Date(date))}.`,\n    )\n    .table(...pluginMetaTable({ plugins }))\n    .table(...reportMetaTable(report));\n}\n\nexport function pluginMetaTable({\n  plugins,\n}: Pick<Report, 'plugins'>): Parameters<MarkdownDocument['table']> {\n  return [\n    [\n      { heading: 'Plugin', alignment: 'left' },\n      { heading: 'Audits', alignment: 'center' },\n      { heading: 'Version', alignment: 'center' },\n      { heading: 'Duration', alignment: 'right' },\n    ],\n    plugins.map(({ title, audits, version = '', duration }) => [\n      title,\n      audits.length.toString(),\n      version && md.code(version),\n      formatDuration(duration),\n    ]),\n  ];\n}\n\nexport function reportMetaTable({\n  commit,\n  version,\n  duration,\n  plugins,\n  categories,\n}: Pick<\n  ScoredReport,\n  'date' | 'duration' | 'version' | 'commit' | 'plugins' | 'categories'\n>): Parameters<MarkdownDocument['table']> {\n  return [\n    [\n      { heading: 'Commit', alignment: 'left' },\n      { heading: 'Version', alignment: 'center' },\n      { heading: 'Duration', alignment: 'right' },\n      { heading: 'Plugins', alignment: 'center' },\n      { heading: 'Categories', alignment: 'center' },\n      { heading: 'Audits', alignment: 'center' },\n    ],\n    [\n      [\n        commit ? `${commit.message} (${commit.hash})` : 'N/A',\n        md.code(version),\n        formatDuration(duration),\n        plugins.length.toString(),\n        (categories?.length ?? 0).toString(),\n        plugins.reduce((acc, { audits }) => acc + audits.length, 0).toString(),\n      ],\n    ],\n  ];\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/formatting.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/formatting.ts\";import {\n  type HeadingLevel,\n  type InlineText,\n  MarkdownDocument,\n  md,\n} from 'build-md';\nimport path from 'node:path';\nimport type {\n  AuditReport,\n  SourceFileLocation,\n  Table,\n} from '@code-pushup/models';\nimport { HIERARCHY } from '../text-formats/index.js';\nimport {\n  columnsToStringArray,\n  getColumnAlignments,\n  rowToStringArray,\n} from '../text-formats/table.js';\nimport {\n  getEnvironmentType,\n  getGitHubBaseUrl,\n  getGitLabBaseUrl,\n} from './environment-type.js';\nimport type { MdReportOptions } from './types.js';\n\nexport function tableSection(\n  tableData: Table,\n  options?: {\n    level?: HeadingLevel;\n  },\n): MarkdownDocument | null {\n  if (tableData.rows.length === 0) {\n    return null;\n  }\n  const { level = HIERARCHY.level_4 } = options ?? {};\n  const columns = columnsToStringArray(tableData);\n  const alignments = getColumnAlignments(tableData);\n  const rows = rowToStringArray(tableData);\n  return new MarkdownDocument().heading(level, tableData.title).table(\n    columns.map((heading, i) => {\n      const alignment = alignments[i];\n      if (alignment) {\n        return { heading, alignment };\n      }\n      return heading;\n    }),\n    rows,\n  );\n}\n\n// @TODO extract `Pick<AuditReport, 'docsUrl' | 'description'>` to a reusable schema and type\nexport function metaDescription(\n  audit: Pick<AuditReport, 'docsUrl' | 'description'>,\n): InlineText {\n  const docsUrl = audit.docsUrl;\n  const description = audit.description?.trim();\n  if (docsUrl) {\n    const docsLink = md.link(docsUrl, '\uD83D\uDCD6 Docs');\n    if (!description) {\n      return docsLink;\n    }\n    const parsedDescription = description.endsWith('```')\n      ? `${description}\\n\\n`\n      : `${description} `;\n    return md`${parsedDescription}${docsLink}`;\n  }\n  if (description && description.trim().length > 0) {\n    return description;\n  }\n  return '';\n}\n\n/**\n * Link to local source for IDE\n * @param source\n * @param reportLocation\n *\n * @example\n * linkToLocalSourceInIde({ file: 'src/index.ts' }, { outputDir: '.code-pushup' }) // [`src/index.ts`](../src/index.ts)\n */\nexport function linkToLocalSourceForIde(\n  source: SourceFileLocation,\n  options?: Pick<MdReportOptions, 'outputDir'>,\n): InlineText {\n  const { file, position } = source;\n  const { outputDir } = options ?? {};\n\n  // NOT linkable\n  if (!outputDir) {\n    return md.code(file);\n  }\n\n  return md.link(formatFileLink(file, position, outputDir), md.code(file));\n}\n\nexport function formatSourceLine(\n  position: SourceFileLocation['position'],\n): string {\n  if (!position) {\n    return '';\n  }\n  const { startLine, endLine } = position;\n  return endLine && startLine !== endLine\n    ? `${startLine}-${endLine}`\n    : `${startLine}`;\n}\n\nexport function formatGitHubLink(\n  file: string,\n  position: SourceFileLocation['position'],\n): string {\n  const baseUrl = getGitHubBaseUrl();\n  if (!position) {\n    return `${baseUrl}/${file}`;\n  }\n  const { startLine, endLine, startColumn, endColumn } = position;\n  const start = startColumn ? `L${startLine}C${startColumn}` : `L${startLine}`;\n  const end = endLine\n    ? endColumn\n      ? `L${endLine}C${endColumn}`\n      : `L${endLine}`\n    : '';\n  const lineRange = end && start !== end ? `${start}-${end}` : start;\n  return `${baseUrl}/${file}#${lineRange}`;\n}\n\nexport function formatGitLabLink(\n  file: string,\n  position: SourceFileLocation['position'],\n): string {\n  const baseUrl = getGitLabBaseUrl();\n  if (!position) {\n    return `${baseUrl}/${file}`;\n  }\n  const { startLine, endLine } = position;\n  const lineRange =\n    endLine && startLine !== endLine ? `${startLine}-${endLine}` : startLine;\n  return `${baseUrl}/${file}#L${lineRange}`;\n}\n\nexport function formatFileLink(\n  file: string,\n  position: SourceFileLocation['position'],\n  outputDir: string,\n): string {\n  const relativePath = path.posix.relative(outputDir, file);\n  const env = getEnvironmentType();\n\n  switch (env) {\n    case 'vscode':\n      return position ? `${relativePath}#L${position.startLine}` : relativePath;\n    case 'github':\n      return formatGitHubLink(file, position);\n    case 'gitlab':\n      return formatGitLabLink(file, position);\n    default:\n      return relativePath;\n  }\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/generate-md-report-categoy-section.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/generate-md-report-categoy-section.ts\";import { type InlineText, MarkdownDocument, md } from 'build-md';\nimport type { AuditReport } from '@code-pushup/models';\nimport { slugify } from '../formatting.js';\nimport { HIERARCHY } from '../text-formats/index.js';\nimport { metaDescription } from './formatting.js';\nimport { getSortableAuditByRef, getSortableGroupByRef } from './sorting.js';\nimport type { ScoredGroup, ScoredReport } from './types.js';\nimport {\n  countCategoryAudits,\n  formatReportScore,\n  getPluginNameFromSlug,\n  scoreMarker,\n  targetScoreIcon,\n} from './utils.js';\n\nexport function categoriesOverviewSection(\n  report: Required<Pick<ScoredReport, 'plugins' | 'categories'>>,\n): MarkdownDocument {\n  const { categories, plugins } = report;\n  return new MarkdownDocument().table(\n    [\n      { heading: '\uD83C\uDFF7 Category', alignment: 'left' },\n      { heading: '\u2B50 Score', alignment: 'center' },\n      { heading: '\uD83D\uDEE1 Audits', alignment: 'center' },\n    ],\n    categories.map(({ title, refs, score, isBinary }) => [\n      // @TODO refactor `isBinary: boolean` to `targetScore: number` #713\n      // The heading \"ID\" is inferred from the heading text in Markdown.\n      md.link(`#${slugify(title)}`, title),\n      md`${scoreMarker(score)} ${md.bold(\n        formatReportScore(score),\n      )}${binaryIconSuffix(score, isBinary)}`,\n      countCategoryAudits(refs, plugins).toString(),\n    ]),\n  );\n}\n\nexport function categoriesDetailsSection(\n  report: Required<Pick<ScoredReport, 'plugins' | 'categories'>>,\n): MarkdownDocument {\n  const { categories, plugins } = report;\n\n  return new MarkdownDocument()\n    .heading(HIERARCHY.level_2, '\uD83C\uDFF7 Categories')\n    .$foreach(categories, (doc, category) =>\n      doc\n        .heading(HIERARCHY.level_3, category.title)\n        .paragraph(metaDescription(category))\n        .paragraph(\n          md`${scoreMarker(category.score)} Score: ${md.bold(\n            formatReportScore(category.score),\n          )}${binaryIconSuffix(category.score, category.isBinary)}`,\n        )\n        .list(\n          category.refs.map(ref => {\n            // Add group details\n            if (ref.type === 'group') {\n              const group = getSortableGroupByRef(ref, plugins);\n              const groupAudits = group.refs.map(groupRef =>\n                getSortableAuditByRef(\n                  { ...groupRef, plugin: group.plugin, type: 'audit' },\n                  plugins,\n                ),\n              );\n              const pluginTitle = getPluginNameFromSlug(ref.plugin, plugins);\n              return categoryGroupItem(group, groupAudits, pluginTitle);\n            }\n            // Add audit details\n            else {\n              const audit = getSortableAuditByRef(ref, plugins);\n              const pluginTitle = getPluginNameFromSlug(ref.plugin, plugins);\n              return categoryRef(audit, pluginTitle);\n            }\n          }),\n        ),\n    );\n}\n\nexport function categoryRef(\n  { title, score, value, displayValue }: AuditReport,\n  pluginTitle: string,\n): InlineText {\n  const auditTitleAsLink = md.link(\n    `#${slugify(title)}-${slugify(pluginTitle)}`,\n    title,\n  );\n  const marker = scoreMarker(score, 'square');\n  return md`${marker} ${auditTitleAsLink} (${md.italic(\n    pluginTitle,\n  )}) - ${md.bold((displayValue || value).toString())}`;\n}\n\nexport function categoryGroupItem(\n  { score = 0, title }: ScoredGroup,\n  groupAudits: AuditReport[],\n  pluginTitle: string,\n): InlineText {\n  const groupTitle = md`${scoreMarker(score)} ${title} (${md.italic(\n    pluginTitle,\n  )})`;\n\n  const auditsList = md.list(\n    groupAudits.map(\n      ({ title: auditTitle, score: auditScore, value, displayValue }) => {\n        const auditTitleLink = md.link(\n          `#${slugify(auditTitle)}-${slugify(pluginTitle)}`,\n          auditTitle,\n        );\n        const marker = scoreMarker(auditScore, 'square');\n        return md`${marker} ${auditTitleLink} - ${md.bold(\n          String(displayValue ?? value),\n        )}`;\n      },\n    ),\n  );\n\n  return md`${groupTitle}${auditsList}`;\n}\n\nexport function binaryIconSuffix(\n  score: number,\n  isBinary: boolean | undefined,\n): string {\n  // @TODO refactor `isBinary: boolean` to `targetScore: number` #713\n  return targetScoreIcon(score, isBinary ? 1 : undefined, { prefix: ' ' });\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/generate-md-reports-diff.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/generate-md-reports-diff.ts\";import {\n  type HeadingLevel,\n  MarkdownDocument,\n  type TableColumnObject,\n  type TableRow,\n  md,\n} from 'build-md';\nimport type { ReportsDiff } from '@code-pushup/models';\nimport { HIERARCHY } from '../text-formats/index.js';\nimport { toArray } from '../transform.js';\nimport type { WithRequired } from '../types.js';\nimport {\n  changesToDiffOutcomes,\n  compareDiffsBy,\n  createGroupsOrAuditsDetails,\n  formatPortalLink,\n  formatReportOutcome,\n  formatTitle,\n  getDiffChanges,\n  mergeDiffOutcomes,\n  sortChanges,\n  summarizeDiffOutcomes,\n  summarizeUnchanged,\n} from './generate-md-reports-diff-utils.js';\nimport type { DiffOutcome } from './types.js';\nimport {\n  formatScoreChange,\n  formatScoreWithColor,\n  formatValueChange,\n  scoreMarker,\n} from './utils.js';\n\nexport function generateMdReportsDiff(diff: ReportsDiff): string {\n  return new MarkdownDocument()\n    .$concat(\n      createDiffHeaderSection(diff),\n      createDiffCategoriesSection(diff),\n      createDiffDetailsSection(diff),\n    )\n    .toString();\n}\n\nexport type LabeledDiff = WithRequired<ReportsDiff, 'label'>;\n\nexport function generateMdReportsDiffForMonorepo(diffs: LabeledDiff[]): string {\n  const diffsWithOutcomes = diffs\n    .map(diff => ({\n      ...diff,\n      outcome: mergeDiffOutcomes(changesToDiffOutcomes(getDiffChanges(diff))),\n    }))\n    .sort(\n      (a, b) =>\n        compareDiffsBy('categories', a, b) ||\n        compareDiffsBy('groups', a, b) ||\n        compareDiffsBy('audits', a, b) ||\n        a.label.localeCompare(b.label),\n    );\n  const unchanged = diffsWithOutcomes.filter(\n    ({ outcome }) => outcome === 'unchanged',\n  );\n  const changed = diffsWithOutcomes.filter(diff => !unchanged.includes(diff));\n\n  return new MarkdownDocument()\n    .$concat(\n      createDiffHeaderSection(diffs),\n      ...changed.map(createDiffProjectSection),\n    )\n    .$if(unchanged.length > 0, doc =>\n      doc\n        .rule()\n        .paragraph(summarizeUnchanged('project', { unchanged, changed })),\n    )\n    .toString();\n}\n\nfunction createDiffHeaderSection(\n  diff: ReportsDiff | ReportsDiff[],\n): MarkdownDocument {\n  const outcome = mergeDiffOutcomes(\n    changesToDiffOutcomes(toArray(diff).flatMap(getDiffChanges)),\n  );\n  // TODO: what if array contains different commit pairs?\n  const commits = Array.isArray(diff) ? diff[0]?.commits : diff.commits;\n  const portalUrl = Array.isArray(diff) ? undefined : diff.portalUrl;\n\n  return new MarkdownDocument()\n    .heading(HIERARCHY.level_1, 'Code PushUp')\n    .paragraph(formatReportOutcome(outcome, commits))\n    .paragraph(formatPortalLink(portalUrl));\n}\n\nfunction createDiffProjectSection(\n  diff: LabeledDiff & { outcome: DiffOutcome },\n): MarkdownDocument {\n  return new MarkdownDocument()\n    .heading(HIERARCHY.level_2, md`\uD83D\uDCBC Project ${md.code(diff.label)}`)\n    .paragraph(formatReportOutcome(diff.outcome))\n    .paragraph(formatPortalLink(diff.portalUrl))\n    .$concat(\n      createDiffCategoriesSection(diff, {\n        skipHeading: true,\n        skipUnchanged: true,\n      }),\n      createDiffDetailsSection(diff, HIERARCHY.level_3),\n    );\n}\n\nfunction createDiffCategoriesSection(\n  diff: ReportsDiff,\n  options?: { skipHeading?: boolean; skipUnchanged?: boolean },\n): MarkdownDocument | null {\n  const { changed, unchanged, added } = diff.categories;\n  const { skipHeading, skipUnchanged } = options ?? {};\n\n  const categoriesCount = changed.length + unchanged.length + added.length;\n  const hasChanges = unchanged.length < categoriesCount;\n\n  if (categoriesCount === 0) {\n    return null;\n  }\n\n  const [columns, rows] = createCategoriesTable(diff, {\n    hasChanges,\n    skipUnchanged,\n  });\n\n  return new MarkdownDocument()\n    .heading(HIERARCHY.level_2, !skipHeading && '\uD83C\uDFF7\uFE0F Categories')\n    .table(columns, rows)\n    .paragraph(added.length > 0 && md.italic(String.raw`(\\*) New category.`))\n    .paragraph(\n      skipUnchanged &&\n        unchanged.length > 0 &&\n        summarizeUnchanged('category', { changed, unchanged }),\n    );\n}\n\nfunction createCategoriesTable(\n  diff: ReportsDiff,\n  options: { hasChanges: boolean; skipUnchanged?: boolean },\n): Parameters<MarkdownDocument['table']> {\n  const { changed, unchanged, added } = diff.categories;\n  const { hasChanges, skipUnchanged } = options;\n\n  const rows: TableRow[] = [\n    ...sortChanges(changed).map(category => [\n      formatTitle(category),\n      formatScoreWithColor(category.scores.before, {\n        skipBold: true,\n      }),\n      formatScoreWithColor(category.scores.after),\n      formatScoreChange(category.scores.diff),\n    ]),\n    ...added.map(category => [\n      formatTitle(category),\n      md.italic(String.raw`n/a (\\*)`),\n      formatScoreWithColor(category.score),\n      md.italic(String.raw`n/a (\\*)`),\n    ]),\n    ...(skipUnchanged\n      ? []\n      : unchanged.map(category => [\n          formatTitle(category),\n          formatScoreWithColor(category.score, { skipBold: true }),\n          formatScoreWithColor(category.score),\n          '\u2013',\n        ])),\n  ];\n\n  if (rows.length === 0) {\n    return [[], []];\n  }\n\n  const columns: TableColumnObject[] = [\n    { heading: '\uD83C\uDFF7\uFE0F Category', alignment: 'left' },\n    {\n      heading: hasChanges ? '\u2B50 Previous score' : '\u2B50 Score',\n      alignment: 'center',\n    },\n    { heading: '\u2B50 Current score', alignment: 'center' },\n    { heading: '\uD83D\uDD04 Score change', alignment: 'center' },\n  ];\n\n  return [\n    hasChanges ? columns : columns.slice(0, 2),\n    rows.map(row => (hasChanges ? row : row.slice(0, 2))),\n  ];\n}\n\nfunction createDiffDetailsSection(\n  diff: ReportsDiff,\n  level: HeadingLevel = HIERARCHY.level_2,\n): MarkdownDocument | null {\n  if (diff.groups.changed.length + diff.audits.changed.length === 0) {\n    return null;\n  }\n  const summary = (['group', 'audit'] as const)\n    .map(token =>\n      summarizeDiffOutcomes(\n        changesToDiffOutcomes(diff[`${token}s`].changed),\n        token,\n      ),\n    )\n    .filter(Boolean)\n    .join(', ');\n  const details = new MarkdownDocument().$concat(\n    createDiffGroupsSection(diff, level),\n    createDiffAuditsSection(diff, level),\n  );\n  return new MarkdownDocument().details(summary, details);\n}\n\nfunction createDiffGroupsSection(\n  diff: ReportsDiff,\n  level: HeadingLevel,\n): MarkdownDocument | null {\n  if (diff.groups.changed.length + diff.groups.unchanged.length === 0) {\n    return null;\n  }\n  return new MarkdownDocument().heading(level, '\uD83D\uDDC3\uFE0F Groups').$concat(\n    createGroupsOrAuditsDetails(\n      'group',\n      diff.groups,\n      [\n        { heading: '\uD83D\uDD0C Plugin', alignment: 'left' },\n        { heading: '\uD83D\uDDC3\uFE0F Group', alignment: 'left' },\n        { heading: '\u2B50 Previous score', alignment: 'center' },\n        { heading: '\u2B50 Current score', alignment: 'center' },\n        { heading: '\uD83D\uDD04 Score change', alignment: 'center' },\n      ],\n      sortChanges(diff.groups.changed).map(group => [\n        formatTitle(group.plugin),\n        formatTitle(group),\n        formatScoreWithColor(group.scores.before, { skipBold: true }),\n        formatScoreWithColor(group.scores.after),\n        formatScoreChange(group.scores.diff),\n      ]),\n    ),\n  );\n}\n\nfunction createDiffAuditsSection(\n  diff: ReportsDiff,\n  level: HeadingLevel,\n): MarkdownDocument {\n  return new MarkdownDocument().heading(level, '\uD83D\uDEE1\uFE0F Audits').$concat(\n    createGroupsOrAuditsDetails(\n      'audit',\n      diff.audits,\n      [\n        { heading: '\uD83D\uDD0C Plugin', alignment: 'left' },\n        { heading: '\uD83D\uDEE1\uFE0F Audit', alignment: 'left' },\n        { heading: '\uD83D\uDCCF Previous value', alignment: 'center' },\n        { heading: '\uD83D\uDCCF Current value', alignment: 'center' },\n        { heading: '\uD83D\uDD04 Value change', alignment: 'center' },\n      ],\n      sortChanges(diff.audits.changed).map(audit => [\n        formatTitle(audit.plugin),\n        formatTitle(audit),\n        `${scoreMarker(audit.scores.before, 'square')} ${\n          audit.displayValues.before || audit.values.before.toString()\n        }`,\n        md`${scoreMarker(audit.scores.after, 'square')} ${md.bold(\n          audit.displayValues.after || audit.values.after.toString(),\n        )}`,\n        formatValueChange(audit),\n      ]),\n    ),\n  );\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/generate-md-reports-diff-utils.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/generate-md-reports-diff-utils.ts\";import { type InlineText, MarkdownDocument, md } from 'build-md';\nimport type { ReportsDiff } from '@code-pushup/models';\nimport { pluralize, pluralizeToken } from '../formatting.js';\nimport { objectToEntries } from '../transform.js';\nimport type { DiffOutcome } from './types.js';\n\n// to prevent exceeding Markdown comment character limit\nconst MAX_ROWS = 100;\n\nexport function summarizeUnchanged(\n  token: string,\n  { changed, unchanged }: { changed: unknown[]; unchanged: unknown[] },\n): string {\n  const pluralizedCount =\n    changed.length > 0\n      ? pluralizeToken(`other ${token}`, unchanged.length)\n      : `All of ${pluralizeToken(token, unchanged.length)}`;\n  const pluralizedVerb = unchanged.length === 1 ? 'is' : 'are';\n  return `${pluralizedCount} ${pluralizedVerb} unchanged.`;\n}\n\nexport function summarizeDiffOutcomes(\n  outcomes: DiffOutcome[],\n  token: string,\n): string {\n  return objectToEntries(countDiffOutcomes(outcomes))\n    .filter(\n      (entry): entry is [Exclude<DiffOutcome, 'unchanged'>, number] =>\n        entry[0] !== 'unchanged' && entry[1] > 0,\n    )\n    .map(([outcome, count]): string => {\n      const formattedCount = `<strong>${count}</strong> ${pluralize(\n        token,\n        count,\n      )}`;\n      switch (outcome) {\n        case 'positive':\n          return `\uD83D\uDC4D ${formattedCount} improved`;\n        case 'negative':\n          return `\uD83D\uDC4E ${formattedCount} regressed`;\n        case 'mixed':\n          return `${formattedCount} changed without impacting score`;\n      }\n    })\n    .join(', ');\n}\n\nexport function createGroupsOrAuditsDetails<T extends 'group' | 'audit'>(\n  token: T,\n  { changed, unchanged }: ReportsDiff[`${T}s`],\n  ...[columns, rows]: Parameters<MarkdownDocument['table']>\n): MarkdownDocument {\n  if (changed.length === 0) {\n    return new MarkdownDocument().paragraph(\n      summarizeUnchanged(token, { changed, unchanged }),\n    );\n  }\n  return new MarkdownDocument()\n    .table(columns, rows.slice(0, MAX_ROWS))\n    .paragraph(\n      changed.length > MAX_ROWS &&\n        md.italic(\n          `Only the ${MAX_ROWS} most affected ${pluralize(\n            token,\n          )} are listed above for brevity.`,\n        ),\n    )\n    .paragraph(\n      unchanged.length > 0 && summarizeUnchanged(token, { changed, unchanged }),\n    );\n}\n\nexport function formatTitle({\n  title,\n  docsUrl,\n}: {\n  title: string;\n  docsUrl?: string;\n}): InlineText {\n  if (docsUrl) {\n    return md.link(docsUrl, title);\n  }\n  return title;\n}\n\nexport function formatPortalLink(\n  portalUrl: string | undefined,\n): InlineText | undefined {\n  return (\n    portalUrl &&\n    md.link(portalUrl, '\uD83D\uDD75\uFE0F See full comparison in Code PushUp portal \uD83D\uDD0D')\n  );\n}\n\ntype Change = {\n  scores: { diff: number };\n  values?: { diff: number };\n};\n\nexport function sortChanges<T extends Change>(changes: T[]): T[] {\n  return changes.toSorted(\n    (a, b) =>\n      Math.abs(b.scores.diff) - Math.abs(a.scores.diff) ||\n      Math.abs(b.values?.diff ?? 0) - Math.abs(a.values?.diff ?? 0),\n  );\n}\n\nexport function getDiffChanges(diff: ReportsDiff): Change[] {\n  return [\n    ...diff.categories.changed,\n    ...diff.groups.changed,\n    ...diff.audits.changed,\n  ];\n}\n\nexport function changesToDiffOutcomes(changes: Change[]): DiffOutcome[] {\n  return changes.map((change): DiffOutcome => {\n    if (change.scores.diff > 0) {\n      return 'positive';\n    }\n    if (change.scores.diff < 0) {\n      return 'negative';\n    }\n    if (change.values != null && change.values.diff !== 0) {\n      return 'mixed';\n    }\n    return 'unchanged';\n  });\n}\n\nexport function mergeDiffOutcomes(outcomes: DiffOutcome[]): DiffOutcome {\n  if (outcomes.every(outcome => outcome === 'unchanged')) {\n    return 'unchanged';\n  }\n  if (outcomes.includes('positive') && !outcomes.includes('negative')) {\n    return 'positive';\n  }\n  if (outcomes.includes('negative') && !outcomes.includes('positive')) {\n    return 'negative';\n  }\n  return 'mixed';\n}\n\nfunction countDiffOutcomes(\n  outcomes: DiffOutcome[],\n): Record<DiffOutcome, number> {\n  return {\n    positive: outcomes.filter(outcome => outcome === 'positive').length,\n    negative: outcomes.filter(outcome => outcome === 'negative').length,\n    mixed: outcomes.filter(outcome => outcome === 'mixed').length,\n    unchanged: outcomes.filter(outcome => outcome === 'unchanged').length,\n  };\n}\n\nexport function formatReportOutcome(\n  outcome: DiffOutcome,\n  commits?: ReportsDiff['commits'],\n): InlineText {\n  const outcomeTexts = {\n    positive: md`\uD83E\uDD73 Code PushUp report has ${md.bold('improved')}`,\n    negative: md`\uD83D\uDE1F Code PushUp report has ${md.bold('regressed')}`,\n    mixed: md`\uD83E\uDD28 Code PushUp report has both ${md.bold(\n      'improvements and regressions',\n    )}`,\n    unchanged: md`\uD83D\uDE10 Code PushUp report is ${md.bold('unchanged')}`,\n  };\n\n  if (commits) {\n    const commitsText = `compared target commit ${commits.after.hash} with source commit ${commits.before.hash}`;\n    return md`${outcomeTexts[outcome]} \u2013 ${commitsText}.`;\n  }\n\n  return md`${outcomeTexts[outcome]}.`;\n}\n\nexport function compareDiffsBy<T extends 'categories' | 'groups' | 'audits'>(\n  type: T,\n  a: ReportsDiff,\n  b: ReportsDiff,\n): number {\n  return (\n    sumScoreChanges(b[type].changed) - sumScoreChanges(a[type].changed) ||\n    sumConfigChanges(b[type]) - sumConfigChanges(a[type])\n  );\n}\n\nfunction sumScoreChanges(changes: Change[]): number {\n  return changes.reduce<number>(\n    (acc, { scores }) => acc + Math.abs(scores.diff),\n    0,\n  );\n}\n\nfunction sumConfigChanges({\n  added,\n  removed,\n}: {\n  added: unknown[];\n  removed: unknown[];\n}): number {\n  return added.length + removed.length;\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/load-report.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/load-report.ts\";import path from 'node:path';\nimport {\n  type Format,\n  type PersistConfig,\n  type Report,\n  reportSchema,\n} from '@code-pushup/models';\nimport {\n  ensureDirectoryExists,\n  readJsonFile,\n  readTextFile,\n} from '../file-system.js';\n\ntype LoadedReportFormat<T extends Format> = T extends 'json' ? Report : string;\n\nexport async function loadReport<T extends Format>(\n  options: Required<Omit<PersistConfig, 'format'>> & {\n    format: T;\n  },\n): Promise<LoadedReportFormat<T>> {\n  const { outputDir, filename, format } = options;\n  await ensureDirectoryExists(outputDir);\n  const filePath = path.join(outputDir, `${filename}.${format}`);\n\n  if (format === 'json') {\n    const content = await readJsonFile(filePath);\n    return reportSchema.parse(content) as LoadedReportFormat<T>;\n  }\n\n  const text = await readTextFile(filePath);\n  return text as LoadedReportFormat<T>;\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/log-stdout-summary.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/reports/log-stdout-summary.ts\";import { bold, cyan, cyanBright, green, red } from 'ansis';\nimport type { AuditReport } from '@code-pushup/models';\nimport { ui } from '../logging.js';\nimport {\n  CODE_PUSHUP_DOMAIN,\n  FOOTER_PREFIX,\n  REPORT_HEADLINE_TEXT,\n  REPORT_RAW_OVERVIEW_TABLE_HEADERS,\n  TERMINAL_WIDTH,\n} from './constants.js';\nimport type { ScoredReport } from './types.js';\nimport {\n  applyScoreColor,\n  countCategoryAudits,\n  targetScoreIcon,\n} from './utils.js';\n\nfunction log(msg = ''): void {\n  ui().logger.log(msg);\n}\n\nexport function logStdoutSummary(report: ScoredReport, verbose = false): void {\n  const { plugins, categories, packageName, version } = report;\n  log(reportToHeaderSection({ packageName, version }));\n  log();\n  logPlugins(plugins, verbose);\n  if (categories && categories.length > 0) {\n    logCategories({ plugins, categories });\n  }\n  log(`${FOOTER_PREFIX} ${CODE_PUSHUP_DOMAIN}`);\n  log();\n}\n\nfunction reportToHeaderSection({\n  packageName,\n  version,\n}: Pick<ScoredReport, 'packageName' | 'version'>): string {\n  return `${bold(REPORT_HEADLINE_TEXT)} - ${packageName}@${version}`;\n}\n\nexport function logPlugins(\n  plugins: ScoredReport['plugins'],\n  verbose: boolean,\n): void {\n  plugins.forEach(plugin => {\n    const { title, audits } = plugin;\n    const filteredAudits =\n      verbose || audits.length === 1\n        ? audits\n        : audits.filter(({ score }) => score !== 1);\n    const diff = audits.length - filteredAudits.length;\n\n    logAudits(title, filteredAudits);\n\n    if (diff > 0) {\n      const notice =\n        filteredAudits.length === 0\n          ? `... All ${diff} audits have perfect scores ...`\n          : `... ${diff} audits with perfect scores omitted for brevity ...`;\n      logRow(1, notice);\n    }\n    log();\n  });\n}\n\nfunction logAudits(pluginTitle: string, audits: AuditReport[]): void {\n  log();\n  log(bold.magentaBright(`${pluginTitle} audits`));\n  log();\n  audits.forEach(({ score, title, displayValue, value }) => {\n    logRow(score, title, displayValue || `${value}`);\n  });\n}\n\nfunction logRow(score: number, title: string, value?: string): void {\n  ui().row([\n    {\n      text: applyScoreColor({ score, text: '\u25CF' }),\n      width: 2,\n      padding: [0, 1, 0, 0],\n    },\n    {\n      text: title,\n      // eslint-disable-next-line @typescript-eslint/no-magic-numbers\n      padding: [0, 3, 0, 0],\n    },\n    ...(value\n      ? [\n          {\n            text: cyanBright(value),\n            // eslint-disable-next-line @typescript-eslint/no-magic-numbers\n            width: 20,\n            padding: [0, 0, 0, 0],\n          },\n        ]\n      : []),\n  ]);\n}\n\nexport function logCategories({\n  plugins,\n  categories,\n}: Required<Pick<ScoredReport, 'plugins' | 'categories'>>): void {\n  const hAlign = (idx: number) => (idx === 0 ? 'left' : 'right');\n\n  const rows = categories.map(({ title, score, refs, isBinary }) => [\n    title,\n    `${binaryIconPrefix(score, isBinary)}${applyScoreColor({ score })}`,\n    countCategoryAudits(refs, plugins),\n  ]);\n  const table = ui().table();\n  // eslint-disable-next-line @typescript-eslint/no-magic-numbers\n  table.columnWidths([TERMINAL_WIDTH - 9 - 10 - 4, 9, 10]);\n  table.head(\n    REPORT_RAW_OVERVIEW_TABLE_HEADERS.map((heading, idx) => ({\n      content: cyan(heading),\n      hAlign: hAlign(idx),\n    })),\n  );\n  rows.forEach(row =>\n    table.row(\n      row.map((content, idx) => ({\n        content: content.toString(),\n        hAlign: hAlign(idx),\n      })),\n    ),\n  );\n\n  log(bold.magentaBright('Categories'));\n  log();\n  table.render();\n  log();\n}\n\n// @TODO refactor `isBinary: boolean` to `targetScore: number` #713\nexport function binaryIconPrefix(\n  score: number,\n  isBinary: boolean | undefined,\n): string {\n  return targetScoreIcon(score, isBinary ? 1 : undefined, {\n    passIcon: bold(green('\u2713')),\n    failIcon: bold(red('\u2717')),\n    postfix: ' ',\n  });\n}\n", "const __injected_filename__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/zod-validation.ts\";const __injected_dirname__ = \"/home/alejandro/dev/code-pushup-cli/packages/utils/src/lib\";const __injected_import_meta_url__ = \"file:///home/alejandro/dev/code-pushup-cli/packages/utils/src/lib/zod-validation.ts\";import { bold, red } from 'ansis';\nimport type { MessageBuilder } from 'zod-validation-error';\n\nexport function formatErrorPath(errorPath: (string | number)[]): string {\n  return errorPath\n    .map((key, index) => {\n      if (typeof key === 'number') {\n        return `[${key}]`;\n      }\n      return index > 0 ? `.${key}` : key;\n    })\n    .join('');\n}\n\nexport const zodErrorMessageBuilder: MessageBuilder = issues =>\n  issues\n    .map(issue => {\n      const formattedMessage = red(`${bold(issue.code)}: ${issue.message}`);\n      const formattedPath = formatErrorPath(issue.path);\n      if (formattedPath) {\n        return `Validation error at ${bold(formattedPath)}\\n${formattedMessage}\\n`;\n      }\n      return `${formattedMessage}\\n`;\n    })\n    .join('\\n');\n"],
  "mappings": "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",
  "names": ["z", "path", "path", "ui", "path", "bold", "path", "ui", "z", "z", "config", "groups", "audits", "calculateCoverage", "config", "calculateCoverage", "config", "createRequire", "path", "fileURLToPath", "z", "z", "slugify", "toArray", "path", "exists", "toArray", "ui", "exists", "toArray", "ui", "ESLint", "writeFile", "path", "ensureDirectoryExists", "filePathToCliArg", "pluginWorkDir", "readJsonFile", "distinct", "executeProcess", "filePathToCliArg", "toArray", "ui", "WORKDIR", "pluginWorkDir", "RUNNER_OUTPUT_PATH", "path", "PLUGIN_CONFIG_PATH", "path", "fileExists", "toArray", "createRequire", "path", "fileURLToPath", "z", "z", "objectToKeys", "path", "objectToKeys", "readJsonFile", "objectToEntries", "objectToEntries", "objectToEntries", "objectToEntries", "objectToKeys", "objectToKeys", "objectToEntries", "fromJsonLines", "objectFromEntries", "objectToEntries", "objectToKeys", "writeFile", "path", "ensureDirectoryExists", "executeProcess", "filePathToCliArg", "objectFromEntries", "readJsonFile", "objectToEntries", "path", "pluginWorkDir", "WORKDIR", "pluginWorkDir", "RUNNER_OUTPUT_PATH", "path", "PLUGIN_CONFIG_PATH", "md", "objectFromEntries", "objectToKeys", "objectToKeys", "path", "fileExists", "executeProcess", "createRequire", "path", "path", "bold", "ui", "path", "path", "path", "ensureDirectoryExists", "bold", "importModule", "readJsonFile", "ui", "bold", "yellow", "ui", "tableSchema", "formatBytes", "formatDuration", "html", "bold", "ui", "bold", "toArray", "config", "config", "exists", "md", "bold", "readFile", "path", "path", "simpleGit", "platform", "config", "categories", "bold", "gray", "MarkdownDocument", "md", "md", "path", "MarkdownDocument", "md", "MarkdownDocument", "md", "MarkdownDocument", "md", "path", "bold", "green", "bold", "red", "z"]
}
 diff --git a/packages/plugin-doc-coverage/mocks/component-mock.ts b/packages/plugin-doc-coverage/mocks/component-mock.ts index 5b2da7c27..6f39b5118 100644 --- a/packages/plugin-doc-coverage/mocks/component-mock.ts +++ b/packages/plugin-doc-coverage/mocks/component-mock.ts @@ -9,41 +9,3 @@ export function DUMMY_FUNCTION() { export function DUMMY_FUNCTION_2() { return 'Hello World 2'; } - -// class DummyClass { -// /** -// * Dummy property that returns 'Hello World 3'. -// * @returns {string} - The string 'Hello World 3'. -// */ -// dummyProperty = 'Hello World 3'; - -// /** -// * Dummy method that returns 'Hello World 4'. -// * @returns {string} - The string 'Hello World 4'. -// */ -// dummyMethod() { -// return 'Hello World 4'; -// } - -// constructor() { -// this.dummyProperty = 'Hello World 3'; -// } -// } - -// export default DummyClass; - -// export const variableDummy = 'Hello World 5'; - -// export const variableDummy2 = 'Hello World 6'; - -// /** Dummy variable that returns 'Hello World 7'. */ -// export const variableDummy3 = 'Hello World 7'; - -// /** Dummy interface that returns 'Hello World 8'. */ -// export interface DummyInterface { -// dummyProperty: string; -// dummyMethod(): string; -// } - -// /** Dummy type that returns 'Hello World 9'. */ -// export type DummyType = string; diff --git a/packages/plugin-doc-coverage/mocks/fixtures/angular/map-event.function.ts b/packages/plugin-doc-coverage/mocks/fixtures/angular/map-event.function.ts index 9cd32ce8a..55f343e7c 100644 --- a/packages/plugin-doc-coverage/mocks/fixtures/angular/map-event.function.ts +++ b/packages/plugin-doc-coverage/mocks/fixtures/angular/map-event.function.ts @@ -1,3 +1,5 @@ +export const someVariable = 'Hello World 1'; + export function mapEventToCustomEvent(event: string) { return event; } diff --git a/packages/plugin-doc-coverage/mocks/source-files.mock.ts b/packages/plugin-doc-coverage/mocks/source-files.mock.ts index bc0ad113c..5a7ba13aa 100644 --- a/packages/plugin-doc-coverage/mocks/source-files.mock.ts +++ b/packages/plugin-doc-coverage/mocks/source-files.mock.ts @@ -6,70 +6,37 @@ import { SourceFile, SyntaxKind, TypeAliasDeclaration, + VariableStatement, } from 'ts-morph'; -import type { CoverageType } from '../src/lib/models'; +import type { CoverageType } from '../src/lib/runner/models'; export function sourceFileMock( file: string, nodes: Partial>>, ): SourceFile { + const createNodeGetter = ( + coverageType: CoverageType, + nodeData?: Record, + ) => { + if (!nodeData) return []; + return Object.entries(nodeData).map(([line, isCommented]) => + nodeMock({ coverageType, line: Number(line), file, isCommented }), + ) as unknown as T[]; + }; + return { getFilePath: () => file as any, getClasses: () => - nodes.classes - ? (Object.entries(nodes.classes).map(([line, isCommented]) => - nodeMock({ - coverageType: 'classes', - line: Number(line), - file, - isCommented, - }), - ) as unknown as ClassDeclaration[]) - : [], + createNodeGetter('classes', nodes.classes), getFunctions: () => - nodes.functions - ? (Object.entries(nodes.functions).map(([line, isCommented]) => - nodeMock({ - coverageType: 'functions', - line: Number(line), - file, - isCommented, - }), - ) as unknown as FunctionDeclaration[]) - : [], - getEnums: () => - nodes.enums - ? (Object.entries(nodes.enums).map(([line, isCommented]) => - nodeMock({ - coverageType: 'enums', - line: Number(line), - file, - isCommented, - }), - ) as unknown as EnumDeclaration[]) - : [], + createNodeGetter('functions', nodes.functions), + getEnums: () => createNodeGetter('enums', nodes.enums), getTypeAliases: () => - nodes.types - ? (Object.entries(nodes.types).map(([line, isCommented]) => - nodeMock({ - coverageType: 'types', - line: Number(line), - file, - isCommented, - }), - ) as unknown as TypeAliasDeclaration[]) - : [], + createNodeGetter('types', nodes.types), getInterfaces: () => - nodes.interfaces - ? (Object.entries(nodes.interfaces).map(([line, isCommented]) => - nodeMock({ - coverageType: 'interfaces', - line: Number(line), - file, - isCommented, - }), - ) as unknown as InterfaceDeclaration[]) - : [], + createNodeGetter('interfaces', nodes.interfaces), + getVariableStatements: () => + createNodeGetter('variables', nodes.variables), } as SourceFile; } @@ -84,6 +51,7 @@ export function nodeMock(options: { getJsDocs: () => (options.isCommented ? ['Comment'] : []), getName: () => 'test', getStartLineNumber: () => options.line, + getDeclarations: () => [], // Only for classes getMethods: () => [], getProperties: () => [], diff --git a/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.integration.test.ts.snap b/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.integration.test.ts.snap index 2507460f6..0b98c1e05 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.integration.test.ts.snap +++ b/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.integration.test.ts.snap @@ -23,7 +23,7 @@ exports[`processDocCoverage > should succesfully get the right number of ts file }, { "file": "/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/mocks/fixtures/angular/map-event.function.ts", - "line": 1, + "line": 3, "name": "mapEventToCustomEvent", "type": "functions", }, @@ -40,7 +40,7 @@ exports[`processDocCoverage > should succesfully get the right number of ts file "issues": [ { "file": "/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.ts", - "line": 15, + "line": 17, "name": "sendEvent", "type": "methods", }, @@ -52,7 +52,7 @@ exports[`processDocCoverage > should succesfully get the right number of ts file "issues": [ { "file": "/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.ts", - "line": 5, + "line": 7, "name": "title", "type": "properties", }, @@ -65,9 +65,16 @@ exports[`processDocCoverage > should succesfully get the right number of ts file "nodesCount": 0, }, "variables": { - "coverage": 100, - "issues": [], - "nodesCount": 0, + "coverage": 0, + "issues": [ + { + "file": "/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/mocks/fixtures/angular/map-event.function.ts", + "line": 1, + "name": "someVariable", + "type": "variables", + }, + ], + "nodesCount": 1, }, } `; @@ -89,7 +96,7 @@ exports[`processDocCoverage > should succesfully get the right number of ts file "issues": [ { "file": "/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/mocks/fixtures/angular/map-event.function.ts", - "line": 1, + "line": 3, "name": "mapEventToCustomEvent", "type": "functions", }, @@ -106,7 +113,7 @@ exports[`processDocCoverage > should succesfully get the right number of ts file "issues": [ { "file": "/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.ts", - "line": 15, + "line": 17, "name": "sendEvent", "type": "methods", }, @@ -118,7 +125,7 @@ exports[`processDocCoverage > should succesfully get the right number of ts file "issues": [ { "file": "/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.ts", - "line": 5, + "line": 7, "name": "title", "type": "properties", }, @@ -131,9 +138,16 @@ exports[`processDocCoverage > should succesfully get the right number of ts file "nodesCount": 0, }, "variables": { - "coverage": 100, - "issues": [], - "nodesCount": 0, + "coverage": 0, + "issues": [ + { + "file": "/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/mocks/fixtures/angular/map-event.function.ts", + "line": 1, + "name": "someVariable", + "type": "variables", + }, + ], + "nodesCount": 1, }, } `; diff --git a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts index d510ae15f..c5d82cac7 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts @@ -1,4 +1,9 @@ -import { ClassDeclaration, Project, SourceFile } from 'ts-morph'; +import { + ClassDeclaration, + Project, + SourceFile, + VariableStatement, +} from 'ts-morph'; import type { DocCoveragePluginConfig } from '../config.js'; import type { CoverageResult, @@ -11,6 +16,30 @@ import { getCoverageTypeFromKind, } from './utils.js'; +/** + * Gets the variables information from the variable statements + * @param variableStatements - The variable statements to process + * @returns {Node[]} The variables information with the right methods to get the information + */ +export function getVariablesInformation( + variableStatements: VariableStatement[], +) { + return variableStatements.flatMap(variable => { + // Get parent-level information + const parentInfo = { + getKind: () => variable.getKind(), + getJsDocs: () => variable.getJsDocs(), + getStartLineNumber: () => variable.getStartLineNumber(), + }; + + // Map each declaration to combine parent info with declaration-specific info + return variable.getDeclarations().map(declaration => ({ + ...parentInfo, + getName: () => declaration.getName(), + })); + }); +} + /** * Processes documentation coverage for TypeScript files in the specified path * @param toInclude - The file path pattern to include for documentation analysis @@ -44,6 +73,7 @@ export function getUnprocessedCoverageReport( ...sourceFile.getTypeAliases(), ...sourceFile.getEnums(), ...sourceFile.getInterfaces(), + ...getVariablesInformation(sourceFile.getVariableStatements()), ]; const coverageReportOfCurrentFile = allNodesFromFile.reduce( diff --git a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts index 233723f03..dcd9ad31b 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts @@ -1,8 +1,9 @@ -import type { ClassDeclaration } from 'ts-morph'; +import type { ClassDeclaration, VariableStatement } from 'ts-morph'; import { nodeMock, sourceFileMock } from '../../../mocks/source-files.mock'; import { getClassNodes, getUnprocessedCoverageReport, + getVariablesInformation, mergeCoverageResults, } from './doc-processer.js'; import type { UnprocessedCoverageResult } from './models.js'; @@ -196,3 +197,79 @@ describe('getClassNodes', () => { expect(propertyNodeSpy).toHaveBeenCalledTimes(1); }); }); + +describe('getVariablesInformation', () => { + it('should process variable statements correctly', () => { + const mockDeclaration = { + getName: () => 'testVariable', + }; + + const mockVariableStatement = { + getKind: () => 'const', + getJsDocs: () => ['some docs'], + getStartLineNumber: () => 42, + getDeclarations: () => [mockDeclaration], + }; + + const result = getVariablesInformation([ + mockVariableStatement as unknown as VariableStatement, + ]); + + expect(result).toHaveLength(1); + expect(result[0]).toEqual({ + getKind: expect.any(Function), + getJsDocs: expect.any(Function), + getStartLineNumber: expect.any(Function), + getName: expect.any(Function), + }); + // It must be defined + expect(result[0]!.getName()).toBe('testVariable'); + expect(result[0]!.getKind()).toBe('const'); + expect(result[0]!.getJsDocs()).toEqual(['some docs']); + expect(result[0]!.getStartLineNumber()).toBe(42); + }); + + it('should handle multiple declarations in a single variable statement', () => { + const mockDeclarations = [ + { getName: () => 'var1' }, + { getName: () => 'var2' }, + ]; + + const mockVariableStatement = { + getKind: () => 'let', + getJsDocs: () => [], + getStartLineNumber: () => 10, + getDeclarations: () => mockDeclarations, + }; + + const result = getVariablesInformation([ + mockVariableStatement as unknown as VariableStatement, + ]); + + expect(result).toHaveLength(2); + // They must be defined + expect(result[0]!.getName()).toBe('var1'); + expect(result[1]!.getName()).toBe('var2'); + expect(result[0]!.getKind()).toBe('let'); + expect(result[1]!.getKind()).toBe('let'); + }); + + it('should handle empty variable statements array', () => { + const result = getVariablesInformation([]); + expect(result).toHaveLength(0); + }); + + it('should handle variable statements without declarations', () => { + const mockVariableStatement = { + getKind: () => 'const', + getJsDocs: () => [], + getStartLineNumber: () => 1, + getDeclarations: () => [], + }; + + const result = getVariablesInformation([ + mockVariableStatement as unknown as VariableStatement, + ]); + expect(result).toHaveLength(0); + }); +}); diff --git a/packages/plugin-doc-coverage/src/lib/runner/utils.ts b/packages/plugin-doc-coverage/src/lib/runner/utils.ts index 31c312619..7b8807a2c 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/utils.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/utils.ts @@ -67,6 +67,7 @@ export function getCoverageTypeFromKind(kind: SyntaxKind): CoverageType { return 'interfaces'; case SyntaxKind.EnumDeclaration: return 'enums'; + case SyntaxKind.VariableStatement: case SyntaxKind.VariableDeclaration: return 'variables'; case SyntaxKind.PropertyDeclaration: From 1a5a6149ce07aa00961a8033cdbf7556ec5d0a66 Mon Sep 17 00:00:00 2001 From: Alejandro Date: Sat, 21 Dec 2024 12:51:12 +0100 Subject: [PATCH 11/39] chore(plugin-doc-coverage): remove unused file and update readme file --- packages/plugin-doc-coverage/README.md | 19 +++++++++---------- .../mocks/documentation.json | 11 ----------- 2 files changed, 9 insertions(+), 21 deletions(-) delete mode 100644 packages/plugin-doc-coverage/mocks/documentation.json diff --git a/packages/plugin-doc-coverage/README.md b/packages/plugin-doc-coverage/README.md index 0b4fb33e6..59a039c9d 100644 --- a/packages/plugin-doc-coverage/README.md +++ b/packages/plugin-doc-coverage/README.md @@ -33,12 +33,14 @@ Measured documentation types are mapped to Code PushUp audits in the following w pnpm add --save-dev @code-pushup/doc-coverage-plugin ``` -3. Add Compodoc to your project. You can follow the instructions [here](https://compodoc.app/guides/installation.html). - -4. Add this plugin to the `plugins` array in your Code PushUp CLI config file (e.g. `code-pushup.config.js`). +3. Add this plugin to the `plugins` array in your Code PushUp CLI config file (e.g. `code-pushup.config.js`). Pass the target files to analyze and optionally specify which types of documentation you want to track. - All documentation types are measured by default. If you wish to focus on a subset of offered types, define them in `docTypes`. + You can skip for example tests by defining in the sourceGlob the path to the tests folder or pattern to match the tests files with the `!` symbol. + All documentation types are measured by default. + If you wish to focus on a subset of offered types, define them in `onlyAudits`. + Also you can skip some types by defining them in `skipAudits`. + You can only define or `onlyAudits` or `skipAudits`, not both. The configuration will look similarly to the following: @@ -50,16 +52,13 @@ Measured documentation types are mapped to Code PushUp audits in the following w plugins: [ // ... await docCoveragePlugin({ - coverageToolCommand: { - command: 'npx', - args: ['compodoc', '-p', 'tsconfig.doc.json', '-e', 'json'], - }, + sourceGlob: ['**/*.ts'], }), ], }; ``` -5. (Optional) Reference individual audits or the provided plugin group which you wish to include in custom categories (use `npx code-pushup print-config` to list audits and groups). +4. (Optional) Reference individual audits or the provided plugin group which you wish to include in custom categories (use `npx code-pushup print-config` to list audits and groups). 💡 Assign weights based on what influence each documentation type should have on the overall category score (assign weight 0 to only include as extra info, without influencing category score). @@ -85,7 +84,7 @@ Measured documentation types are mapped to Code PushUp audits in the following w }; ``` -6. Run the CLI with `npx code-pushup collect` and view or upload report (refer to [CLI docs](../cli/README.md)). +5. Run the CLI with `npx code-pushup collect` and view or upload report (refer to [CLI docs](../cli/README.md)). ## About documentation coverage diff --git a/packages/plugin-doc-coverage/mocks/documentation.json b/packages/plugin-doc-coverage/mocks/documentation.json deleted file mode 100644 index 7a608253c..000000000 --- a/packages/plugin-doc-coverage/mocks/documentation.json +++ /dev/null @@ -1,11 +0,0 @@ -{ - "coverage": { - "count": 85, - "files": { - "src/app/services/my.service.ts": { - "documented": 17, - "total": 20 - } - } - } -} From 8909855f8e4a142eca8b9eeb988b68ad9f11b729 Mon Sep 17 00:00:00 2001 From: Alejandro <49059458+aramirezj@users.noreply.github.com> Date: Sun, 22 Dec 2024 14:54:41 +0100 Subject: [PATCH 12/39] Update packages/plugin-doc-coverage/src/lib/constants.ts Co-authored-by: Michael Hladky <10064416+BioPhoton@users.noreply.github.com> --- packages/plugin-doc-coverage/src/lib/constants.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/plugin-doc-coverage/src/lib/constants.ts b/packages/plugin-doc-coverage/src/lib/constants.ts index d199b2b55..d5d0d6b38 100644 --- a/packages/plugin-doc-coverage/src/lib/constants.ts +++ b/packages/plugin-doc-coverage/src/lib/constants.ts @@ -7,7 +7,7 @@ export const AUDITS_MAP: Record = { 'classes-coverage': { slug: 'classes-coverage', title: 'Classes coverage', - description: 'Coverage of classes', + description: 'Documentation coverage of classes', }, 'methods-coverage': { slug: 'methods-coverage', From b8cdf77de25368121d55a115aa1f457f9a55488e Mon Sep 17 00:00:00 2001 From: Alejandro <49059458+aramirezj@users.noreply.github.com> Date: Sun, 22 Dec 2024 14:54:51 +0100 Subject: [PATCH 13/39] Update packages/plugin-doc-coverage/package.json Co-authored-by: Michael Hladky <10064416+BioPhoton@users.noreply.github.com> --- packages/plugin-doc-coverage/package.json | 29 ++++++++++++----------- 1 file changed, 15 insertions(+), 14 deletions(-) diff --git a/packages/plugin-doc-coverage/package.json b/packages/plugin-doc-coverage/package.json index c06f92a38..4d5fc0c60 100644 --- a/packages/plugin-doc-coverage/package.json +++ b/packages/plugin-doc-coverage/package.json @@ -13,21 +13,22 @@ "directory": "packages/plugin-doc-coverage" }, "keywords": [ - "CLI", - "Code PushUp", - "plugin", - "automation", - "developer tools", - "conformance", "documentation coverage", - "documentation", - "docs", - "KPI tracking", - "automated feedback", - "regression guard", - "actionable feedback", - "audit", - "score monitoring" + "documentation quality", + "docs completeness", + "automated documentation checks", + "coverage audit", + "documentation conformance", + "docs KPI tracking", + "documentation feedback", + "actionable documentation insights", + "documentation regression guard", + "documentation score monitoring", + "developer documentation tools", + "plugin for documentation coverage", + "CLI documentation coverage", + "Code PushUp documentation", + "documentation audit" ], "publishConfig": { "access": "public" From 24ab2e04861dcd1d31566d9debe3ff1461b48a30 Mon Sep 17 00:00:00 2001 From: Alejandro Date: Sun, 22 Dec 2024 15:38:03 +0100 Subject: [PATCH 14/39] chore(plugin-doc-coverage): from Michael comments, remakes some tests, rename different stuff --- code-pushup.config.ts | 24 ++- .../mocks/component-mock.ts | 11 -- .../mocks/component-mock.unit.test.ts | 16 -- .../doc-processer.integration.test.ts.snap | 153 ------------------ .../__snapshots__/runner.unit.test.ts.snap | 147 ----------------- .../runner/doc-processer.integration.test.ts | 39 +++-- .../src/lib/runner/doc-processer.ts | 20 +-- .../src/lib/runner/doc-processer.unit.test.ts | 6 +- .../src/lib/runner/models.ts | 6 +- .../src/lib/runner/runner.ts | 11 +- .../src/lib/runner/runner.unit.test.ts | 73 ++++----- .../src/lib/runner/utils.ts | 6 +- .../src/lib/runner/utils.unit.test.ts | 15 +- 13 files changed, 95 insertions(+), 432 deletions(-) delete mode 100644 packages/plugin-doc-coverage/mocks/component-mock.ts delete mode 100644 packages/plugin-doc-coverage/mocks/component-mock.unit.test.ts delete mode 100644 packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.integration.test.ts.snap delete mode 100644 packages/plugin-doc-coverage/src/lib/runner/__snapshots__/runner.unit.test.ts.snap diff --git a/code-pushup.config.ts b/code-pushup.config.ts index a0a33cfee..6b2ea8dc4 100644 --- a/code-pushup.config.ts +++ b/code-pushup.config.ts @@ -1,12 +1,6 @@ import 'dotenv/config'; import { z } from 'zod'; -import { - coverageCoreConfigNx, - docCoverageCoreConfig, - eslintCoreConfigNx, - jsPackagesCoreConfig, - lighthouseCoreConfig, -} from './code-pushup.preset.js'; +import { docCoverageCoreConfig } from './code-pushup.preset.js'; import type { CoreConfig } from './packages/models/src/index.js'; import { mergeConfigs } from './packages/utils/src/index.js'; @@ -33,13 +27,13 @@ const config: CoreConfig = { }; export default mergeConfigs( - config, - await coverageCoreConfigNx(), - await jsPackagesCoreConfig(), - await lighthouseCoreConfig( - 'https://github.com/code-pushup/cli?tab=readme-ov-file#code-pushup-cli/', - ), - await eslintCoreConfigNx(), + // config, + // await coverageCoreConfigNx(), + // await jsPackagesCoreConfig(), + // await lighthouseCoreConfig( + // 'https://github.com/code-pushup/cli?tab=readme-ov-file#code-pushup-cli/', + // ), + // await eslintCoreConfigNx(), await docCoverageCoreConfig({ sourceGlob: [ 'packages/**/src/**/*.ts', @@ -48,6 +42,6 @@ export default mergeConfigs( '!**/implementation/**', '!**/internal/**', ], - skipAudits: ['methods-coverage'], + skipAudits: ['methodawdawdds-coverage'], }), ); diff --git a/packages/plugin-doc-coverage/mocks/component-mock.ts b/packages/plugin-doc-coverage/mocks/component-mock.ts deleted file mode 100644 index 6f39b5118..000000000 --- a/packages/plugin-doc-coverage/mocks/component-mock.ts +++ /dev/null @@ -1,11 +0,0 @@ -/** - * Dummy function that returns 'Hello World'. - * @returns {string} - The string 'Hello World'. - */ -export function DUMMY_FUNCTION() { - return 'Hello World'; -} - -export function DUMMY_FUNCTION_2() { - return 'Hello World 2'; -} diff --git a/packages/plugin-doc-coverage/mocks/component-mock.unit.test.ts b/packages/plugin-doc-coverage/mocks/component-mock.unit.test.ts deleted file mode 100644 index 648080fb0..000000000 --- a/packages/plugin-doc-coverage/mocks/component-mock.unit.test.ts +++ /dev/null @@ -1,16 +0,0 @@ -import { describe, expect, it } from 'vitest'; -import { DUMMY_FUNCTION, DUMMY_FUNCTION_2 } from './component-mock.js'; - -export function shouldnotBeHere() { - return 'Hello World'; -} - -describe('component-mock', () => { - it('should return Hello World', () => { - expect(DUMMY_FUNCTION()).toBe('Hello World'); - }); - - it('should return Hello World 2', () => { - expect(DUMMY_FUNCTION_2()).toBe('Hello World 2'); - }); -}); diff --git a/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.integration.test.ts.snap b/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.integration.test.ts.snap deleted file mode 100644 index 0b98c1e05..000000000 --- a/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.integration.test.ts.snap +++ /dev/null @@ -1,153 +0,0 @@ -// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html - -exports[`processDocCoverage > should succesfully get the right number of ts files 1`] = ` -{ - "classes": { - "coverage": 100, - "issues": [], - "nodesCount": 1, - }, - "enums": { - "coverage": 100, - "issues": [], - "nodesCount": 0, - }, - "functions": { - "coverage": 33.33, - "issues": [ - { - "file": "/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.spec.ts", - "line": 1, - "name": "notRealisticFunction", - "type": "functions", - }, - { - "file": "/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/mocks/fixtures/angular/map-event.function.ts", - "line": 3, - "name": "mapEventToCustomEvent", - "type": "functions", - }, - ], - "nodesCount": 3, - }, - "interfaces": { - "coverage": 100, - "issues": [], - "nodesCount": 0, - }, - "methods": { - "coverage": 50, - "issues": [ - { - "file": "/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.ts", - "line": 17, - "name": "sendEvent", - "type": "methods", - }, - ], - "nodesCount": 2, - }, - "properties": { - "coverage": 0, - "issues": [ - { - "file": "/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.ts", - "line": 7, - "name": "title", - "type": "properties", - }, - ], - "nodesCount": 1, - }, - "types": { - "coverage": 100, - "issues": [], - "nodesCount": 0, - }, - "variables": { - "coverage": 0, - "issues": [ - { - "file": "/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/mocks/fixtures/angular/map-event.function.ts", - "line": 1, - "name": "someVariable", - "type": "variables", - }, - ], - "nodesCount": 1, - }, -} -`; - -exports[`processDocCoverage > should succesfully get the right number of ts files and not include spec files 1`] = ` -{ - "classes": { - "coverage": 100, - "issues": [], - "nodesCount": 1, - }, - "enums": { - "coverage": 100, - "issues": [], - "nodesCount": 0, - }, - "functions": { - "coverage": 50, - "issues": [ - { - "file": "/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/mocks/fixtures/angular/map-event.function.ts", - "line": 3, - "name": "mapEventToCustomEvent", - "type": "functions", - }, - ], - "nodesCount": 2, - }, - "interfaces": { - "coverage": 100, - "issues": [], - "nodesCount": 0, - }, - "methods": { - "coverage": 50, - "issues": [ - { - "file": "/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.ts", - "line": 17, - "name": "sendEvent", - "type": "methods", - }, - ], - "nodesCount": 2, - }, - "properties": { - "coverage": 0, - "issues": [ - { - "file": "/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.ts", - "line": 7, - "name": "title", - "type": "properties", - }, - ], - "nodesCount": 1, - }, - "types": { - "coverage": 100, - "issues": [], - "nodesCount": 0, - }, - "variables": { - "coverage": 0, - "issues": [ - { - "file": "/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/mocks/fixtures/angular/map-event.function.ts", - "line": 1, - "name": "someVariable", - "type": "variables", - }, - ], - "nodesCount": 1, - }, -} -`; diff --git a/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/runner.unit.test.ts.snap b/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/runner.unit.test.ts.snap deleted file mode 100644 index 9db5313d1..000000000 --- a/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/runner.unit.test.ts.snap +++ /dev/null @@ -1,147 +0,0 @@ -// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html - -exports[`trasformCoverageReportToAudits > should filter audits when onlyAudits is provided 1`] = ` -[ - { - "details": { - "issues": [ - { - "message": "Missing documentation", - "severity": "warning", - "source": { - "file": "test.ts", - "position": { - "startLine": 10, - }, - }, - }, - ], - }, - "displayValue": "75 %", - "score": 0.75, - "slug": "functions-coverage", - "value": 75, - }, -] -`; - -exports[`trasformCoverageReportToAudits > should filter audits when skipAudits is provided 1`] = ` -[ - { - "details": { - "issues": [ - { - "message": "Missing documentation", - "severity": "warning", - "source": { - "file": "test.ts", - "position": { - "startLine": 10, - }, - }, - }, - ], - }, - "displayValue": "75 %", - "score": 0.75, - "slug": "functions-coverage", - "value": 75, - }, -] -`; - -exports[`trasformCoverageReportToAudits > should handle coverage result with multiple issues 1`] = ` -[ - { - "details": { - "issues": [ - { - "message": "Missing documentation", - "severity": "warning", - "source": { - "file": "test1.ts", - "position": { - "startLine": 10, - }, - }, - }, - { - "message": "Missing documentation", - "severity": "warning", - "source": { - "file": "test2.ts", - "position": { - "startLine": 20, - }, - }, - }, - ], - }, - "displayValue": "50 %", - "score": 0.5, - "slug": "functions-coverage", - "value": 50, - }, -] -`; - -exports[`trasformCoverageReportToAudits > should handle empty coverage result 1`] = `[]`; - -exports[`trasformCoverageReportToAudits > should prioritize onlyAudits over skipAudits when both are provided 1`] = ` -[ - { - "details": { - "issues": [ - { - "message": "Missing documentation", - "severity": "warning", - "source": { - "file": "test.ts", - "position": { - "startLine": 10, - }, - }, - }, - ], - }, - "displayValue": "75 %", - "score": 0.75, - "slug": "functions-coverage", - "value": 75, - }, -] -`; - -exports[`trasformCoverageReportToAudits > should transform coverage report to audit outputs with no filters 1`] = ` -[ - { - "details": { - "issues": [ - { - "message": "Missing documentation", - "severity": "warning", - "source": { - "file": "test.ts", - "position": { - "startLine": 10, - }, - }, - }, - ], - }, - "displayValue": "75 %", - "score": 0.75, - "slug": "functions-coverage", - "value": 75, - }, - { - "details": { - "issues": [], - }, - "displayValue": "100 %", - "score": 1, - "slug": "classes-coverage", - "value": 100, - }, -] -`; diff --git a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.integration.test.ts b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.integration.test.ts index 00bdc83a7..0a93347f9 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.integration.test.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.integration.test.ts @@ -1,23 +1,34 @@ import { processDocCoverage } from './doc-processer.js'; describe('processDocCoverage', () => { - it('should succesfully get the right number of ts files', () => { - const results = processDocCoverage({ - sourceGlob: [ - 'packages/plugin-doc-coverage/mocks/fixtures/angular/**/*.ts', - ], - }); - expect(results).toMatchSnapshot(); + const sourcePath = + 'packages/plugin-doc-coverage/mocks/fixtures/angular/**/*.ts'; + + it('should count total nodes from TypeScript files correctly', () => { + const expectedNodeCount = 8; + + const results = processDocCoverage({ sourceGlob: [sourcePath] }); + + const totalNodeCount = Object.values(results).reduce( + (acc, node) => acc + node.nodesCount, + 0, + ); + + expect(totalNodeCount).toBe(expectedNodeCount); }); - it('should succesfully get the right number of ts files and not include spec files', () => { + it('should count total nodes from TypeScript files correctly and not include spec files when specified', () => { + const expectedNodeCount = 7; + const results = processDocCoverage({ - sourceGlob: [ - 'packages/plugin-doc-coverage/mocks/fixtures/angular/**/*.ts', - '!**/*.spec.ts', - '!**/*.test.ts', - ], + sourceGlob: [sourcePath, '!**/*.spec.ts', '!**/*.test.ts'], }); - expect(results).toMatchSnapshot(); + + const totalNodeCount = Object.values(results).reduce( + (acc, node) => acc + node.nodesCount, + 0, + ); + + expect(totalNodeCount).toBe(expectedNodeCount); }); }); diff --git a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts index c5d82cac7..d63c1f469 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts @@ -6,13 +6,13 @@ import { } from 'ts-morph'; import type { DocCoveragePluginConfig } from '../config.js'; import type { + CoverageReportShape, CoverageResult, CoverageType, - UnprocessedCoverageResult, } from './models.js'; import { calculateCoverage, - createEmptyUnprocessedCoverageReport, + createEmptyCoverageData, getCoverageTypeFromKind, } from './utils.js'; @@ -56,7 +56,7 @@ export function processDocCoverage( /** * Gets the unprocessed coverage report from the source files * @param sourceFiles - The source files to process - * @returns {UnprocessedCoverageResult} The unprocessed coverage report + * @returns {CoverageReportShape} The unprocessed coverage report */ export function getUnprocessedCoverageReport( sourceFiles: SourceFile[], @@ -102,7 +102,7 @@ export function getUnprocessedCoverageReport( }, }; }, - createEmptyUnprocessedCoverageReport(), + createEmptyCoverageData(), ); return mergeCoverageResults( @@ -110,7 +110,7 @@ export function getUnprocessedCoverageReport( coverageReportOfCurrentFile, ); }, - createEmptyUnprocessedCoverageReport(), + createEmptyCoverageData(), ); return calculateCoverage(unprocessedCoverageReport); @@ -120,12 +120,12 @@ export function getUnprocessedCoverageReport( * Merges two coverage results * @param results - The first empty coverage result * @param current - The second coverage result - * @returns {UnprocessedCoverageResult} The merged coverage result + * @returns {CoverageReportShape} The merged coverage result */ export function mergeCoverageResults( - results: UnprocessedCoverageResult, - current: Partial, -): UnprocessedCoverageResult { + results: CoverageReportShape, + current: Partial, +): CoverageReportShape { return Object.fromEntries( Object.entries(results).map(([key, value]) => { const node = value as CoverageResult[CoverageType]; @@ -138,7 +138,7 @@ export function mergeCoverageResults( }, ]; }), - ) as UnprocessedCoverageResult; + ) as CoverageReportShape; } /** diff --git a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts index dcd9ad31b..2c6fc0c17 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts @@ -6,7 +6,7 @@ import { getVariablesInformation, mergeCoverageResults, } from './doc-processer.js'; -import type { UnprocessedCoverageResult } from './models.js'; +import type { CoverageReportShape } from './models.js'; describe('getUnprocessedCoverageReport', () => { it('should produce a full report', () => { @@ -72,7 +72,7 @@ describe('getUnprocessedCoverageReport', () => { }); describe('mergeCoverageResults', () => { - const emptyResult: UnprocessedCoverageResult = { + const emptyResult: CoverageReportShape = { enums: { nodesCount: 0, issues: [] }, interfaces: { nodesCount: 0, issues: [] }, types: { nodesCount: 0, issues: [] }, @@ -102,7 +102,7 @@ describe('mergeCoverageResults', () => { const results = mergeCoverageResults( emptyResult, - secondResult as Partial, + secondResult as Partial, ); expect(results).toStrictEqual( expect.objectContaining({ diff --git a/packages/plugin-doc-coverage/src/lib/runner/models.ts b/packages/plugin-doc-coverage/src/lib/runner/models.ts index c8119b4db..547efab56 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/models.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/models.ts @@ -25,14 +25,14 @@ export type UndocumentedNode = { class?: string; }; -/** The coverage data is the data that is used to create the coverage report. Without coverage stats yet */ +/** The coverage data is the data that is used to create the coverage report. Without coverage stats. */ export type CoverageData = { issues: UndocumentedNode[]; nodesCount: number; }; -/** The unprocessed coverage result CoverageData but for each coverage type. */ -export type UnprocessedCoverageResult = Record; +/** The coverage report shape the report of every CoverageType without coverage stats. */ +export type CoverageReportShape = Record; /** The processed coverage result CoverageData but for each coverage type and with coverage stats. */ export type CoverageResult = Record< diff --git a/packages/plugin-doc-coverage/src/lib/runner/runner.ts b/packages/plugin-doc-coverage/src/lib/runner/runner.ts index 8bbf54066..1019687e8 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/runner.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/runner.ts @@ -1,7 +1,7 @@ import type { AuditOutputs, RunnerFunction } from '@code-pushup/models'; import type { DocCoveragePluginConfig } from '../config.js'; import { processDocCoverage } from './doc-processer.js'; -import type { CoverageResult, CoverageType } from './models.js'; +import type { CoverageResult } from './models.js'; export function createRunnerFunction( config: DocCoveragePluginConfig, @@ -33,17 +33,16 @@ export function trasformCoverageReportToAudits( } return true; }) - .map(([type, items]) => { - const coverageType = type as CoverageType; - const coverage = items.coverage; + .map(([type, item]) => { + const { coverage } = item; return { - slug: `${coverageType}-coverage`, + slug: `${type}-coverage`, value: coverage, score: coverage / 100, displayValue: `${coverage} %`, details: { - issues: items.issues.map(({ file, line }) => ({ + issues: item.issues.map(({ file, line }) => ({ message: 'Missing documentation', source: { file, position: { startLine: line } }, severity: 'warning', diff --git a/packages/plugin-doc-coverage/src/lib/runner/runner.unit.test.ts b/packages/plugin-doc-coverage/src/lib/runner/runner.unit.test.ts index d81748ab3..aab40d08c 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/runner.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/runner.unit.test.ts @@ -18,71 +18,58 @@ describe('trasformCoverageReportToAudits', () => { classes: { coverage: 100, nodesCount: 2, - issues: [], + issues: [ + { + file: 'test.ts', + line: 10, + name: 'testClass', + type: 'classes', + }, + ], }, } as unknown as CoverageResult; - it('should transform coverage report to audit outputs with no filters', () => { + it('should return all audits from the coverage result when no filters are provided', () => { const result = trasformCoverageReportToAudits(mockCoverageResult, {}); - expect(result).toMatchSnapshot(); + expect(result.map(item => item.slug)).toStrictEqual([ + 'functions-coverage', + 'classes-coverage', + ]); }); it('should filter audits when onlyAudits is provided', () => { const result = trasformCoverageReportToAudits(mockCoverageResult, { onlyAudits: ['functions-coverage'], }); - expect(result).toMatchSnapshot(); + expect(result).toHaveLength(1); + expect(result.map(item => item.slug)).toStrictEqual(['functions-coverage']); }); it('should filter audits when skipAudits is provided', () => { const result = trasformCoverageReportToAudits(mockCoverageResult, { - skipAudits: ['classes-coverage'], + skipAudits: ['functions-coverage'], }); - expect(result).toMatchSnapshot(); + expect(result).toHaveLength(1); + expect(result.map(item => item.slug)).toStrictEqual(['classes-coverage']); }); - it('should handle empty coverage result', () => { + it('should handle properly empty coverage result', () => { const result = trasformCoverageReportToAudits( {} as unknown as CoverageResult, {}, ); - expect(result).toMatchSnapshot(); - }); - - it('should handle coverage result with multiple issues', () => { - const coverageWithMultipleIssues = { - functions: { - coverage: 50, - nodesCount: 4, - issues: [ - { - file: 'test1.ts', - line: 10, - name: 'function1', - type: 'functions', - }, - { - file: 'test2.ts', - line: 20, - name: 'function2', - type: 'functions', - }, - ], - }, - } as unknown as CoverageResult; - - const result = trasformCoverageReportToAudits( - coverageWithMultipleIssues, - {}, - ); - expect(result).toMatchSnapshot(); + expect(result).toEqual([]); }); - it('should prioritize onlyAudits over skipAudits when both are provided', () => { - const result = trasformCoverageReportToAudits(mockCoverageResult, { - onlyAudits: ['functions-coverage'], - skipAudits: ['functions-coverage'], - }); - expect(result).toMatchSnapshot(); + it('should handle coverage result with multiple issues and add them to the details.issue of the report', () => { + const expectedIssues = 2; + const result = trasformCoverageReportToAudits(mockCoverageResult, {}); + expect(result).toHaveLength(2); + expect( + result.reduce( + (acc, item) => acc + (item.details?.issues?.length ?? 0), + 0, + ), + ).toBe(expectedIssues); }); }); diff --git a/packages/plugin-doc-coverage/src/lib/runner/utils.ts b/packages/plugin-doc-coverage/src/lib/runner/utils.ts index 7b8807a2c..cdc202991 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/utils.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/utils.ts @@ -1,15 +1,15 @@ import { SyntaxKind } from 'ts-morph'; import type { + CoverageReportShape, CoverageResult, CoverageType, - UnprocessedCoverageResult, } from './models.js'; /** * Creates an empty unprocessed coverage report. * @returns The empty unprocessed coverage report. */ -export function createEmptyUnprocessedCoverageReport(): UnprocessedCoverageResult { +export function createEmptyCoverageData(): CoverageReportShape { return { enums: { nodesCount: 0, issues: [] }, interfaces: { nodesCount: 0, issues: [] }, @@ -27,7 +27,7 @@ export function createEmptyUnprocessedCoverageReport(): UnprocessedCoverageResul * @param result - The unprocessed coverage result. * @returns The processed coverage result. */ -export function calculateCoverage(result: UnprocessedCoverageResult) { +export function calculateCoverage(result: CoverageReportShape) { return Object.fromEntries( Object.entries(result).map(([key, value]) => { const type = key as CoverageType; diff --git a/packages/plugin-doc-coverage/src/lib/runner/utils.unit.test.ts b/packages/plugin-doc-coverage/src/lib/runner/utils.unit.test.ts index 731d5280c..d45b1600c 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/utils.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/utils.unit.test.ts @@ -1,14 +1,14 @@ import { SyntaxKind } from 'ts-morph'; -import type { UnprocessedCoverageResult } from './models.js'; +import type { CoverageReportShape } from './models.js'; import { calculateCoverage, - createEmptyUnprocessedCoverageReport, + createEmptyCoverageData, getCoverageTypeFromKind, } from './utils.js'; -describe('createEmptyUnprocessedCoverageReport', () => { +describe('createEmptyCoverageData', () => { it('should create an empty report with all categories initialized', () => { - const result = createEmptyUnprocessedCoverageReport(); + const result = createEmptyCoverageData(); expect(result).toStrictEqual({ enums: { nodesCount: 0, issues: [] }, @@ -25,8 +25,7 @@ describe('createEmptyUnprocessedCoverageReport', () => { describe('calculateCoverage', () => { it('should calculate 100% coverage when there are no nodes', () => { - const input: UnprocessedCoverageResult = - createEmptyUnprocessedCoverageReport(); + const input = createEmptyCoverageData(); const result = calculateCoverage(input); Object.values(result).forEach(category => { @@ -37,8 +36,8 @@ describe('calculateCoverage', () => { }); it('should calculate correct coverage percentage with issues', () => { - const input: UnprocessedCoverageResult = { - ...createEmptyUnprocessedCoverageReport(), + const input: CoverageReportShape = { + ...createEmptyCoverageData(), functions: { nodesCount: 4, issues: [ From 6c83208016f9e7c922823e13ade088c5efc1854f Mon Sep 17 00:00:00 2001 From: Alejandro Date: Sun, 22 Dec 2024 15:46:14 +0100 Subject: [PATCH 15/39] chore(plugin-doc-coverage): remove extra line From 8c2d274074e30d151a495cc37ea8e8083acdc809 Mon Sep 17 00:00:00 2001 From: Alejandro Date: Sun, 22 Dec 2024 15:46:55 +0100 Subject: [PATCH 16/39] chore: put back plugin config --- code-pushup.config.ts | 22 ++++++++++++++-------- 1 file changed, 14 insertions(+), 8 deletions(-) diff --git a/code-pushup.config.ts b/code-pushup.config.ts index 6b2ea8dc4..699aee3c3 100644 --- a/code-pushup.config.ts +++ b/code-pushup.config.ts @@ -1,6 +1,12 @@ import 'dotenv/config'; import { z } from 'zod'; -import { docCoverageCoreConfig } from './code-pushup.preset.js'; +import { + coverageCoreConfigNx, + docCoverageCoreConfig, + eslintCoreConfigNx, + jsPackagesCoreConfig, + lighthouseCoreConfig, +} from './code-pushup.preset.js'; import type { CoreConfig } from './packages/models/src/index.js'; import { mergeConfigs } from './packages/utils/src/index.js'; @@ -27,13 +33,13 @@ const config: CoreConfig = { }; export default mergeConfigs( - // config, - // await coverageCoreConfigNx(), - // await jsPackagesCoreConfig(), - // await lighthouseCoreConfig( - // 'https://github.com/code-pushup/cli?tab=readme-ov-file#code-pushup-cli/', - // ), - // await eslintCoreConfigNx(), + config, + await coverageCoreConfigNx(), + await jsPackagesCoreConfig(), + await lighthouseCoreConfig( + 'https://github.com/code-pushup/cli?tab=readme-ov-file#code-pushup-cli/', + ), + await eslintCoreConfigNx(), await docCoverageCoreConfig({ sourceGlob: [ 'packages/**/src/**/*.ts', From a70c03b23bd5bcd850b069d440262d2004ddac9a Mon Sep 17 00:00:00 2001 From: Alejandro Date: Sun, 22 Dec 2024 15:49:36 +0100 Subject: [PATCH 17/39] chore: fix plugin config, remove unused snapshot --- code-pushup.config.ts | 2 +- .../runner/doc-processer.unit.test.ts.snap | 125 ------------------ 2 files changed, 1 insertion(+), 126 deletions(-) delete mode 100644 packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts.snap diff --git a/code-pushup.config.ts b/code-pushup.config.ts index 699aee3c3..a0a33cfee 100644 --- a/code-pushup.config.ts +++ b/code-pushup.config.ts @@ -48,6 +48,6 @@ export default mergeConfigs( '!**/implementation/**', '!**/internal/**', ], - skipAudits: ['methodawdawdds-coverage'], + skipAudits: ['methods-coverage'], }), ); diff --git a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts.snap b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts.snap deleted file mode 100644 index 220467a98..000000000 --- a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts.snap +++ /dev/null @@ -1,125 +0,0 @@ -{ - "classes": { - "coverage": 0, - "issues": [ - { - "file": "test.ts", - "line": 4, - "name": "test", - "type": "classes", - }, - { - "file": "test.ts", - "line": 5, - "name": "test", - "type": "classes", - }, - { - "file": "test.ts", - "line": 6, - "name": "test", - "type": "classes", - }, - ], - "nodesCount": 3, - }, - "enums": { - "coverage": 0, - "issues": [ - { - "file": "test.ts", - "line": 7, - "name": "test", - "type": "enums", - }, - { - "file": "test.ts", - "line": 8, - "name": "test", - "type": "enums", - }, - { - "file": "test.ts", - "line": 9, - "name": "test", - "type": "enums", - }, - ], - "nodesCount": 3, - }, - "functions": { - "coverage": 66.66666666666667, - "issues": [ - { - "file": "test.ts", - "line": 3, - "name": "test", - "type": "functions", - }, - ], - "nodesCount": 3, - }, - "interfaces": { - "coverage": 0, - "issues": [ - { - "file": "test.ts", - "line": 13, - "name": "test", - "type": "interfaces", - }, - { - "file": "test.ts", - "line": 14, - "name": "test", - "type": "interfaces", - }, - { - "file": "test.ts", - "line": 15, - "name": "test", - "type": "interfaces", - }, - ], - "nodesCount": 3, - }, - "methods": { - "coverage": 100, - "issues": [], - "nodesCount": 0, - }, - "properties": { - "coverage": 100, - "issues": [], - "nodesCount": 0, - }, - "types": { - "coverage": 0, - "issues": [ - { - "file": "test.ts", - "line": 10, - "name": "test", - "type": "types", - }, - { - "file": "test.ts", - "line": 11, - "name": "test", - "type": "types", - }, - { - "file": "test.ts", - "line": 12, - "name": "test", - "type": "types", - }, - ], - "nodesCount": 3, - }, - "variables": { - "coverage": 100, - "issues": [], - "nodesCount": 0, - }, -} \ No newline at end of file From 6be3803c67b505a27950fab13b0ba9a10ce038e5 Mon Sep 17 00:00:00 2001 From: Alejandro Date: Sun, 22 Dec 2024 16:04:43 +0100 Subject: [PATCH 18/39] chore(plugin-doc-coverage): stuff of the pr and rename file --- ...mock.ts => source-files-mock.generator.ts} | 0 .../plugin-doc-coverage/src/lib/config.ts | 17 +- .../src/lib/config.unit.test.ts | 156 +++++++++--------- .../src/lib/runner/doc-processer.unit.test.ts | 5 +- 4 files changed, 96 insertions(+), 82 deletions(-) rename packages/plugin-doc-coverage/mocks/{source-files.mock.ts => source-files-mock.generator.ts} (100%) diff --git a/packages/plugin-doc-coverage/mocks/source-files.mock.ts b/packages/plugin-doc-coverage/mocks/source-files-mock.generator.ts similarity index 100% rename from packages/plugin-doc-coverage/mocks/source-files.mock.ts rename to packages/plugin-doc-coverage/mocks/source-files-mock.generator.ts diff --git a/packages/plugin-doc-coverage/src/lib/config.ts b/packages/plugin-doc-coverage/src/lib/config.ts index 648420a1d..1204ca7f7 100644 --- a/packages/plugin-doc-coverage/src/lib/config.ts +++ b/packages/plugin-doc-coverage/src/lib/config.ts @@ -2,11 +2,22 @@ import { z } from 'zod'; export const docCoveragePluginConfigSchema = z .object({ - skipAudits: z.array(z.string()).optional(), - onlyAudits: z.array(z.string()).optional(), + skipAudits: z + .array(z.string()) + .optional() + .describe( + 'List of audit slugs to exclude from evaluation. When specified, all audits except these will be evaluated.', + ), + onlyAudits: z + .array(z.string()) + .optional() + .describe( + 'List of audit slugs to evaluate. When specified, only these audits will be evaluated.', + ), sourceGlob: z .array(z.string()) - .default(['src/**/*.{ts,tsx}', '!**/*.spec.ts', '!**/*.test.ts']), + .default(['src/**/*.{ts,tsx}', '!**/*.spec.ts', '!**/*.test.ts']) + .describe('Glob pattern to match source files to evaluate.'), }) .refine(data => !(data.skipAudits && data.onlyAudits), { message: "You can't define 'skipAudits' and 'onlyAudits' simultaneously", diff --git a/packages/plugin-doc-coverage/src/lib/config.unit.test.ts b/packages/plugin-doc-coverage/src/lib/config.unit.test.ts index 1d28d2a7d..f9f777d15 100644 --- a/packages/plugin-doc-coverage/src/lib/config.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/config.unit.test.ts @@ -5,6 +5,15 @@ import { } from './config.js'; describe('docCoveragePluginConfigSchema', () => { + it('accepts a complete valid configuration', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + sourceGlob: ['src/**/*.ts'], + onlyAudits: ['functions-coverage'], + } satisfies DocCoveragePluginConfig), + ).not.toThrow(); + }); + it('throws when skipAudits and onlyAudits are defined', () => { expect(() => docCoveragePluginConfigSchema.parse({ @@ -13,100 +22,91 @@ describe('docCoveragePluginConfigSchema', () => { }), ).toThrow("You can't define 'skipAudits' and 'onlyAudits' simultaneously"); }); +}); - describe('sourceGlob', () => { - it('accepts a valid source glob pattern', () => { - expect(() => - docCoveragePluginConfigSchema.parse({ - sourceGlob: ['src/**/*.{ts,tsx}', '!**/*.spec.ts', '!**/*.test.ts'], - } satisfies DocCoveragePluginConfig), - ).not.toThrow(); - }); +describe('sourceGlob', () => { + it('accepts a valid source glob pattern', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + sourceGlob: ['src/**/*.{ts,tsx}', '!**/*.spec.ts', '!**/*.test.ts'], + } satisfies DocCoveragePluginConfig), + ).not.toThrow(); + }); - it('uses default value for missing sourceGlob', () => { - const result = docCoveragePluginConfigSchema.parse({}); - expect(result.sourceGlob).toEqual([ - 'src/**/*.{ts,tsx}', - '!**/*.spec.ts', - '!**/*.test.ts', - ]); - }); + it('uses default value for missing sourceGlob', () => { + const result = docCoveragePluginConfigSchema.parse({}); + expect(result.sourceGlob).toEqual([ + 'src/**/*.{ts,tsx}', + '!**/*.spec.ts', + '!**/*.test.ts', + ]); + }); - it('throws for invalid sourceGlob type', () => { - expect(() => - docCoveragePluginConfigSchema.parse({ - sourceGlob: 123, - }), - ).toThrow('Expected array'); - }); + it('throws for invalid sourceGlob type', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + sourceGlob: 123, + }), + ).toThrow('Expected array'); }); +}); - it('accepts a complete valid configuration', () => { +describe('onlyAudits', () => { + it('accepts valid audit slugs array', () => { expect(() => docCoveragePluginConfigSchema.parse({ + onlyAudits: ['functions-coverage', 'classes-coverage'], sourceGlob: ['src/**/*.ts'], - onlyAudits: ['functions-coverage'], - } satisfies DocCoveragePluginConfig), + }), ).not.toThrow(); }); - describe('onlyAudits', () => { - it('accepts valid audit slugs array', () => { - expect(() => - docCoveragePluginConfigSchema.parse({ - onlyAudits: ['functions-coverage', 'classes-coverage'], - sourceGlob: ['src/**/*.ts'], - }), - ).not.toThrow(); - }); - - it('accepts empty array for onlyAudits', () => { - expect(() => - docCoveragePluginConfigSchema.parse({ - onlyAudits: [], - sourceGlob: ['src/**/*.ts'], - }), - ).not.toThrow(); - }); + it('accepts empty array for onlyAudits', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + onlyAudits: [], + sourceGlob: ['src/**/*.ts'], + }), + ).not.toThrow(); + }); - it('allows onlyAudits to be undefined', () => { - const result = docCoveragePluginConfigSchema.parse({}); - expect(result.onlyAudits).toBeUndefined(); - }); + it('allows onlyAudits to be undefined', () => { + const result = docCoveragePluginConfigSchema.parse({}); + expect(result.onlyAudits).toBeUndefined(); + }); - it('throws for invalid onlyAudits type', () => { - expect(() => - docCoveragePluginConfigSchema.parse({ - onlyAudits: 'functions-coverage', - }), - ).toThrow('Expected array'); - }); + it('throws for invalid onlyAudits type', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + onlyAudits: 'functions-coverage', + }), + ).toThrow('Expected array'); + }); - it('throws for array with non-string elements', () => { - expect(() => - docCoveragePluginConfigSchema.parse({ - onlyAudits: [123, true], - }), - ).toThrow('Expected string'); - }); + it('throws for array with non-string elements', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + onlyAudits: [123, true], + }), + ).toThrow('Expected string'); }); +}); - describe('skipAudits', () => { - it('accepts valid audit slugs array', () => { - expect(() => - docCoveragePluginConfigSchema.parse({ - skipAudits: ['functions-coverage', 'classes-coverage'], - sourceGlob: ['src/**/*.ts'], - }), - ).not.toThrow(); - }); +describe('skipAudits', () => { + it('accepts valid audit slugs array', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + skipAudits: ['functions-coverage', 'classes-coverage'], + sourceGlob: ['src/**/*.ts'], + }), + ).not.toThrow(); + }); - it('throws for array with non-string elements', () => { - expect(() => - docCoveragePluginConfigSchema.parse({ - skipAudits: [123, true], - }), - ).toThrow('Expected string'); - }); + it('throws for array with non-string elements', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + skipAudits: [123, true], + }), + ).toThrow('Expected string'); }); }); diff --git a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts index 2c6fc0c17..3db7abbb7 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts @@ -1,5 +1,8 @@ import type { ClassDeclaration, VariableStatement } from 'ts-morph'; -import { nodeMock, sourceFileMock } from '../../../mocks/source-files.mock'; +import { + nodeMock, + sourceFileMock, +} from '../../../mocks/source-files-mock.generator'; import { getClassNodes, getUnprocessedCoverageReport, From 2f2972848b2ff62bdc9ba0079aa67a3a9ebd3d56 Mon Sep 17 00:00:00 2001 From: Alejandro <49059458+aramirezj@users.noreply.github.com> Date: Mon, 23 Dec 2024 11:29:44 +0100 Subject: [PATCH 19/39] Update code-pushup.config.ts Co-authored-by: Michael Hladky <10064416+BioPhoton@users.noreply.github.com> --- code-pushup.config.ts | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/code-pushup.config.ts b/code-pushup.config.ts index a0a33cfee..ebaaf803f 100644 --- a/code-pushup.config.ts +++ b/code-pushup.config.ts @@ -43,8 +43,7 @@ export default mergeConfigs( await docCoverageCoreConfig({ sourceGlob: [ 'packages/**/src/**/*.ts', - '!**/*.spec.ts', - '!**/*.test.ts', + '!**/*.{spec,test}.ts' '!**/implementation/**', '!**/internal/**', ], From adec386a93e67a062017007464213d0e477ad0a7 Mon Sep 17 00:00:00 2001 From: Alejandro <49059458+aramirezj@users.noreply.github.com> Date: Mon, 23 Dec 2024 11:29:53 +0100 Subject: [PATCH 20/39] Update packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts Co-authored-by: Michael Hladky <10064416+BioPhoton@users.noreply.github.com> --- .../src/lib/doc-coverage-plugin.unit.test.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts index fea278277..adf079fc4 100644 --- a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts @@ -16,7 +16,7 @@ vi.mock('./runner/index.ts', () => ({ })); describe('docCoveragePlugin', () => { - it('should initialise a Documentation coverage plugin', async () => { + it('should create a valid plugin config', async () => { await expect( docCoveragePlugin({ sourceGlob: ['src/**/*.ts', '!**/*.spec.ts', '!**/*.test.ts'], From 47cff4bb8874f85651e246d6dca31fe2f5cd5b70 Mon Sep 17 00:00:00 2001 From: Alejandro <49059458+aramirezj@users.noreply.github.com> Date: Mon, 23 Dec 2024 11:30:00 +0100 Subject: [PATCH 21/39] Update packages/plugin-doc-coverage/src/lib/runner/doc-processer.integration.test.ts Co-authored-by: Michael Hladky <10064416+BioPhoton@users.noreply.github.com> --- .../src/lib/runner/doc-processer.integration.test.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.integration.test.ts b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.integration.test.ts index 0a93347f9..539c3af7d 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.integration.test.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.integration.test.ts @@ -17,7 +17,7 @@ describe('processDocCoverage', () => { expect(totalNodeCount).toBe(expectedNodeCount); }); - it('should count total nodes from TypeScript files correctly and not include spec files when specified', () => { + it('respect `sourceGlob` and only include matching files', () => { const expectedNodeCount = 7; const results = processDocCoverage({ From c644029b858f1469f5662db1f81c2f751a18847b Mon Sep 17 00:00:00 2001 From: Alejandro <49059458+aramirezj@users.noreply.github.com> Date: Mon, 23 Dec 2024 11:30:21 +0100 Subject: [PATCH 22/39] Update packages/plugin-doc-coverage/src/lib/constants.ts Co-authored-by: Michael Hladky <10064416+BioPhoton@users.noreply.github.com> --- packages/plugin-doc-coverage/src/lib/constants.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/plugin-doc-coverage/src/lib/constants.ts b/packages/plugin-doc-coverage/src/lib/constants.ts index d5d0d6b38..ddcc1471f 100644 --- a/packages/plugin-doc-coverage/src/lib/constants.ts +++ b/packages/plugin-doc-coverage/src/lib/constants.ts @@ -12,7 +12,7 @@ export const AUDITS_MAP: Record = { 'methods-coverage': { slug: 'methods-coverage', title: 'Methods coverage', - description: 'Coverage of methods', + description: 'Documentation coverage of methods', }, 'functions-coverage': { slug: 'functions-coverage', From 09d9eb0ff02c34a1d0116071a9f41a5b7591f6cc Mon Sep 17 00:00:00 2001 From: Alejandro <49059458+aramirezj@users.noreply.github.com> Date: Mon, 23 Dec 2024 11:30:48 +0100 Subject: [PATCH 23/39] Update packages/plugin-doc-coverage/src/lib/constants.ts Co-authored-by: Michael Hladky <10064416+BioPhoton@users.noreply.github.com> --- packages/plugin-doc-coverage/src/lib/constants.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/plugin-doc-coverage/src/lib/constants.ts b/packages/plugin-doc-coverage/src/lib/constants.ts index ddcc1471f..a09d463a9 100644 --- a/packages/plugin-doc-coverage/src/lib/constants.ts +++ b/packages/plugin-doc-coverage/src/lib/constants.ts @@ -22,7 +22,7 @@ export const AUDITS_MAP: Record = { 'interfaces-coverage': { slug: 'interfaces-coverage', title: 'Interfaces coverage', - description: 'Coverage of interfaces', + description: 'Documentation coverage of interfaces', }, 'variables-coverage': { slug: 'variables-coverage', From 39019550ae05d7d8e8d6088a35cff55b2ceb1ac5 Mon Sep 17 00:00:00 2001 From: Alejandro <49059458+aramirezj@users.noreply.github.com> Date: Mon, 23 Dec 2024 11:30:55 +0100 Subject: [PATCH 24/39] Update packages/plugin-doc-coverage/src/lib/constants.ts Co-authored-by: Michael Hladky <10064416+BioPhoton@users.noreply.github.com> --- packages/plugin-doc-coverage/src/lib/constants.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/plugin-doc-coverage/src/lib/constants.ts b/packages/plugin-doc-coverage/src/lib/constants.ts index a09d463a9..0db20d774 100644 --- a/packages/plugin-doc-coverage/src/lib/constants.ts +++ b/packages/plugin-doc-coverage/src/lib/constants.ts @@ -32,7 +32,7 @@ export const AUDITS_MAP: Record = { 'properties-coverage': { slug: 'properties-coverage', title: 'Properties coverage', - description: 'Coverage of properties', + description: 'Documentation coverage of properties', }, 'types-coverage': { slug: 'types-coverage', From 11ad4bbb73a38d1975b33a7a6947d05f508e2001 Mon Sep 17 00:00:00 2001 From: Alejandro <49059458+aramirezj@users.noreply.github.com> Date: Mon, 23 Dec 2024 11:31:03 +0100 Subject: [PATCH 25/39] Update packages/plugin-doc-coverage/src/lib/constants.ts Co-authored-by: Michael Hladky <10064416+BioPhoton@users.noreply.github.com> --- packages/plugin-doc-coverage/src/lib/constants.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/plugin-doc-coverage/src/lib/constants.ts b/packages/plugin-doc-coverage/src/lib/constants.ts index 0db20d774..a635afe66 100644 --- a/packages/plugin-doc-coverage/src/lib/constants.ts +++ b/packages/plugin-doc-coverage/src/lib/constants.ts @@ -37,7 +37,7 @@ export const AUDITS_MAP: Record = { 'types-coverage': { slug: 'types-coverage', title: 'Types coverage', - description: 'Coverage of types', + description: 'Documentation coverage of types', }, 'enums-coverage': { slug: 'enums-coverage', From 19d43a504dfc6150e1a11ad2b1adf755898c8780 Mon Sep 17 00:00:00 2001 From: Alejandro <49059458+aramirezj@users.noreply.github.com> Date: Mon, 23 Dec 2024 11:31:13 +0100 Subject: [PATCH 26/39] Update packages/plugin-doc-coverage/src/lib/constants.ts Co-authored-by: Michael Hladky <10064416+BioPhoton@users.noreply.github.com> --- packages/plugin-doc-coverage/src/lib/constants.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/plugin-doc-coverage/src/lib/constants.ts b/packages/plugin-doc-coverage/src/lib/constants.ts index a635afe66..55f41d47f 100644 --- a/packages/plugin-doc-coverage/src/lib/constants.ts +++ b/packages/plugin-doc-coverage/src/lib/constants.ts @@ -42,7 +42,7 @@ export const AUDITS_MAP: Record = { 'enums-coverage': { slug: 'enums-coverage', title: 'Enums coverage', - description: 'Coverage of enums', + description: 'Documentation coverage of enums', }, } as const; From 49e5b56e43f82c2c304a9315f8c6358a5906f765 Mon Sep 17 00:00:00 2001 From: Alejandro <49059458+aramirezj@users.noreply.github.com> Date: Mon, 23 Dec 2024 11:31:20 +0100 Subject: [PATCH 27/39] Update packages/plugin-doc-coverage/README.md Co-authored-by: Michael Hladky <10064416+BioPhoton@users.noreply.github.com> --- packages/plugin-doc-coverage/README.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/packages/plugin-doc-coverage/README.md b/packages/plugin-doc-coverage/README.md index 59a039c9d..08b4cba51 100644 --- a/packages/plugin-doc-coverage/README.md +++ b/packages/plugin-doc-coverage/README.md @@ -11,7 +11,9 @@ It analyzes your codebase and checks for documentation on different code element Measured documentation types are mapped to Code PushUp audits in the following way: -- The value is in range 0-100 and represents the documentation coverage for all passed results (_documented / total_) +- `value`: The value is the number of undocumented nodes -> 4 +- `displayValue`: `${value} undocumented ${type}` -> 4 undocumented functions +- `score`: 0.5 -> total nodes 8 undocumented 4 -> 8/4 - The score is value converted to 0-1 range - Missing documentation is mapped to issues in the audit details (undocumented classes, functions, interfaces, etc.) From 54d162118cffbe7d72cb93319f8ffd5dbb329d7e Mon Sep 17 00:00:00 2001 From: Alejandro <49059458+aramirezj@users.noreply.github.com> Date: Mon, 23 Dec 2024 11:31:29 +0100 Subject: [PATCH 28/39] Update packages/plugin-doc-coverage/README.md Co-authored-by: Michael Hladky <10064416+BioPhoton@users.noreply.github.com> --- packages/plugin-doc-coverage/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/plugin-doc-coverage/README.md b/packages/plugin-doc-coverage/README.md index 08b4cba51..842730ab5 100644 --- a/packages/plugin-doc-coverage/README.md +++ b/packages/plugin-doc-coverage/README.md @@ -35,7 +35,7 @@ Measured documentation types are mapped to Code PushUp audits in the following w pnpm add --save-dev @code-pushup/doc-coverage-plugin ``` -3. Add this plugin to the `plugins` array in your Code PushUp CLI config file (e.g. `code-pushup.config.js`). +3. Add this plugin to the `plugins` array in your Code PushUp CLI config file (e.g. `code-pushup.config.ts`). Pass the target files to analyze and optionally specify which types of documentation you want to track. You can skip for example tests by defining in the sourceGlob the path to the tests folder or pattern to match the tests files with the `!` symbol. From b3105aefd455b4f1f151f948ba5b4d6dcb00e8a0 Mon Sep 17 00:00:00 2001 From: Alejandro <49059458+aramirezj@users.noreply.github.com> Date: Mon, 23 Dec 2024 11:31:39 +0100 Subject: [PATCH 29/39] Update packages/plugin-doc-coverage/src/lib/constants.ts Co-authored-by: Michael Hladky <10064416+BioPhoton@users.noreply.github.com> --- packages/plugin-doc-coverage/src/lib/constants.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/plugin-doc-coverage/src/lib/constants.ts b/packages/plugin-doc-coverage/src/lib/constants.ts index 55f41d47f..4ea1e9a14 100644 --- a/packages/plugin-doc-coverage/src/lib/constants.ts +++ b/packages/plugin-doc-coverage/src/lib/constants.ts @@ -27,7 +27,7 @@ export const AUDITS_MAP: Record = { 'variables-coverage': { slug: 'variables-coverage', title: 'Variables coverage', - description: 'Coverage of variables', + description: 'Documentation coverage of variables', }, 'properties-coverage': { slug: 'properties-coverage', From 89893a05659d19fd218e4adf4c3df5f1109dfeed Mon Sep 17 00:00:00 2001 From: Alejandro <49059458+aramirezj@users.noreply.github.com> Date: Mon, 23 Dec 2024 11:31:47 +0100 Subject: [PATCH 30/39] Update packages/plugin-doc-coverage/src/lib/constants.ts Co-authored-by: Michael Hladky <10064416+BioPhoton@users.noreply.github.com> --- packages/plugin-doc-coverage/src/lib/constants.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/plugin-doc-coverage/src/lib/constants.ts b/packages/plugin-doc-coverage/src/lib/constants.ts index 4ea1e9a14..cbd09b671 100644 --- a/packages/plugin-doc-coverage/src/lib/constants.ts +++ b/packages/plugin-doc-coverage/src/lib/constants.ts @@ -17,7 +17,7 @@ export const AUDITS_MAP: Record = { 'functions-coverage': { slug: 'functions-coverage', title: 'Functions coverage', - description: 'Coverage of functions', + description: 'Documentation coverage of functions', }, 'interfaces-coverage': { slug: 'interfaces-coverage', From 97d32bfc41316c8cf959756f47d4f900dac750fa Mon Sep 17 00:00:00 2001 From: Alejandro <49059458+aramirezj@users.noreply.github.com> Date: Mon, 23 Dec 2024 11:33:50 +0100 Subject: [PATCH 31/39] Update packages/plugin-doc-coverage/src/lib/config.unit.test.ts Co-authored-by: Michael Hladky <10064416+BioPhoton@users.noreply.github.com> --- packages/plugin-doc-coverage/src/lib/config.unit.test.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/plugin-doc-coverage/src/lib/config.unit.test.ts b/packages/plugin-doc-coverage/src/lib/config.unit.test.ts index f9f777d15..fe73aafce 100644 --- a/packages/plugin-doc-coverage/src/lib/config.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/config.unit.test.ts @@ -5,7 +5,7 @@ import { } from './config.js'; describe('docCoveragePluginConfigSchema', () => { - it('accepts a complete valid configuration', () => { + it('accepts a valid configuration', () => { expect(() => docCoveragePluginConfigSchema.parse({ sourceGlob: ['src/**/*.ts'], From 79b6a027058446939d9ab267cdbb79a9f047693b Mon Sep 17 00:00:00 2001 From: Alejandro <49059458+aramirezj@users.noreply.github.com> Date: Mon, 23 Dec 2024 11:34:04 +0100 Subject: [PATCH 32/39] Update packages/plugin-doc-coverage/src/lib/config.unit.test.ts Co-authored-by: Michael Hladky <10064416+BioPhoton@users.noreply.github.com> --- packages/plugin-doc-coverage/src/lib/config.unit.test.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/plugin-doc-coverage/src/lib/config.unit.test.ts b/packages/plugin-doc-coverage/src/lib/config.unit.test.ts index fe73aafce..f58d7fa73 100644 --- a/packages/plugin-doc-coverage/src/lib/config.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/config.unit.test.ts @@ -52,7 +52,7 @@ describe('sourceGlob', () => { }); describe('onlyAudits', () => { - it('accepts valid audit slugs array', () => { + it('accepts a valid `onlyAudits` array', () => { expect(() => docCoveragePluginConfigSchema.parse({ onlyAudits: ['functions-coverage', 'classes-coverage'], From fd3bd5eb9d691ea2b734365795e2ecb43430ed62 Mon Sep 17 00:00:00 2001 From: Alejandro Date: Mon, 23 Dec 2024 12:03:37 +0100 Subject: [PATCH 33/39] chore(plugin-doc-coverage): add js files for integration test, remove unused dependency, new test --- .../mocks/fixtures/react/component.js | 10 + .../mocks/source-files-mock.generator.ts | 2 +- packages/plugin-doc-coverage/package.json | 5 - .../src/lib/config.unit.test.ts | 206 ++++++++++-------- .../src/lib/doc-coverage-plugin.unit.test.ts | 52 ++++- .../doc-processer.unit.test.ts.snap | 2 +- .../runner/doc-processer.integration.test.ts | 37 +++- .../src/lib/runner/doc-processer.ts | 47 ++-- .../src/lib/runner/doc-processer.unit.test.ts | 34 +-- .../src/lib/runner/models.ts | 14 +- .../src/lib/runner/runner.ts | 4 +- .../src/lib/runner/runner.unit.test.ts | 6 +- .../src/lib/runner/utils.ts | 10 +- .../src/lib/runner/utils.unit.test.ts | 4 +- 14 files changed, 266 insertions(+), 167 deletions(-) create mode 100644 packages/plugin-doc-coverage/mocks/fixtures/react/component.js diff --git a/packages/plugin-doc-coverage/mocks/fixtures/react/component.js b/packages/plugin-doc-coverage/mocks/fixtures/react/component.js new file mode 100644 index 000000000..dfa1336e3 --- /dev/null +++ b/packages/plugin-doc-coverage/mocks/fixtures/react/component.js @@ -0,0 +1,10 @@ +function MyComponent() { + return ( +
+

Hello World

+

This is a basic React component

+
+ ); +} + +export default MyComponent; diff --git a/packages/plugin-doc-coverage/mocks/source-files-mock.generator.ts b/packages/plugin-doc-coverage/mocks/source-files-mock.generator.ts index 5a7ba13aa..5d700db3c 100644 --- a/packages/plugin-doc-coverage/mocks/source-files-mock.generator.ts +++ b/packages/plugin-doc-coverage/mocks/source-files-mock.generator.ts @@ -8,7 +8,7 @@ import { TypeAliasDeclaration, VariableStatement, } from 'ts-morph'; -import type { CoverageType } from '../src/lib/runner/models'; +import type { CoverageType } from '../src/lib/runner/models.js'; export function sourceFileMock( file: string, diff --git a/packages/plugin-doc-coverage/package.json b/packages/plugin-doc-coverage/package.json index 4d5fc0c60..20f0b4f52 100644 --- a/packages/plugin-doc-coverage/package.json +++ b/packages/plugin-doc-coverage/package.json @@ -38,10 +38,5 @@ "@code-pushup/models": "0.57.0", "zod": "^3.22.4", "ts-morph": "^24.0.0" - }, - "peerDependenciesMeta": { - "@nx/devkit": { - "optional": true - } } } diff --git a/packages/plugin-doc-coverage/src/lib/config.unit.test.ts b/packages/plugin-doc-coverage/src/lib/config.unit.test.ts index f58d7fa73..83449ecce 100644 --- a/packages/plugin-doc-coverage/src/lib/config.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/config.unit.test.ts @@ -4,109 +4,135 @@ import { docCoveragePluginConfigSchema, } from './config.js'; -describe('docCoveragePluginConfigSchema', () => { - it('accepts a valid configuration', () => { - expect(() => - docCoveragePluginConfigSchema.parse({ - sourceGlob: ['src/**/*.ts'], - onlyAudits: ['functions-coverage'], - } satisfies DocCoveragePluginConfig), - ).not.toThrow(); - }); +describe('DocCoveragePlugin Configuration', () => { + describe('docCoveragePluginConfigSchema', () => { + it('accepts a valid configuration', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + sourceGlob: ['src/**/*.ts'], + onlyAudits: ['functions-coverage'], + } satisfies DocCoveragePluginConfig), + ).not.toThrow(); + }); - it('throws when skipAudits and onlyAudits are defined', () => { - expect(() => - docCoveragePluginConfigSchema.parse({ - skipAudits: ['functions-coverage'], - onlyAudits: ['classes-coverage'], - }), - ).toThrow("You can't define 'skipAudits' and 'onlyAudits' simultaneously"); + it('throws when skipAudits and onlyAudits are defined', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + skipAudits: ['functions-coverage'], + onlyAudits: ['classes-coverage'], + }), + ).toThrow( + "You can't define 'skipAudits' and 'onlyAudits' simultaneously", + ); + }); }); -}); -describe('sourceGlob', () => { - it('accepts a valid source glob pattern', () => { - expect(() => - docCoveragePluginConfigSchema.parse({ - sourceGlob: ['src/**/*.{ts,tsx}', '!**/*.spec.ts', '!**/*.test.ts'], - } satisfies DocCoveragePluginConfig), - ).not.toThrow(); - }); + describe('sourceGlob', () => { + it('accepts a valid source glob pattern', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + sourceGlob: ['src/**/*.{ts,tsx}', '!**/*.spec.ts', '!**/*.test.ts'], + } satisfies DocCoveragePluginConfig), + ).not.toThrow(); + }); - it('uses default value for missing sourceGlob', () => { - const result = docCoveragePluginConfigSchema.parse({}); - expect(result.sourceGlob).toEqual([ - 'src/**/*.{ts,tsx}', - '!**/*.spec.ts', - '!**/*.test.ts', - ]); - }); + it('uses default value for missing sourceGlob', () => { + const result = docCoveragePluginConfigSchema.parse({}); + expect(result.sourceGlob).toEqual([ + 'src/**/*.{ts,tsx}', + '!**/*.spec.ts', + '!**/*.test.ts', + ]); + }); - it('throws for invalid sourceGlob type', () => { - expect(() => - docCoveragePluginConfigSchema.parse({ - sourceGlob: 123, - }), - ).toThrow('Expected array'); + it('throws for invalid sourceGlob type', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + sourceGlob: 123, + }), + ).toThrow('Expected array'); + }); }); -}); -describe('onlyAudits', () => { - it('accepts a valid `onlyAudits` array', () => { - expect(() => - docCoveragePluginConfigSchema.parse({ - onlyAudits: ['functions-coverage', 'classes-coverage'], - sourceGlob: ['src/**/*.ts'], - }), - ).not.toThrow(); - }); + describe('onlyAudits', () => { + it('accepts a valid `onlyAudits` array', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + onlyAudits: ['functions-coverage', 'classes-coverage'], + sourceGlob: ['src/**/*.ts'], + }), + ).not.toThrow(); + }); - it('accepts empty array for onlyAudits', () => { - expect(() => - docCoveragePluginConfigSchema.parse({ - onlyAudits: [], - sourceGlob: ['src/**/*.ts'], - }), - ).not.toThrow(); - }); + it('accepts empty array for onlyAudits', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + onlyAudits: [], + sourceGlob: ['src/**/*.ts'], + }), + ).not.toThrow(); + }); - it('allows onlyAudits to be undefined', () => { - const result = docCoveragePluginConfigSchema.parse({}); - expect(result.onlyAudits).toBeUndefined(); - }); + it('allows onlyAudits to be undefined', () => { + const result = docCoveragePluginConfigSchema.parse({}); + expect(result.onlyAudits).toBeUndefined(); + }); - it('throws for invalid onlyAudits type', () => { - expect(() => - docCoveragePluginConfigSchema.parse({ - onlyAudits: 'functions-coverage', - }), - ).toThrow('Expected array'); - }); + it('throws for invalid onlyAudits type', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + onlyAudits: 'functions-coverage', + }), + ).toThrow('Expected array'); + }); - it('throws for array with non-string elements', () => { - expect(() => - docCoveragePluginConfigSchema.parse({ - onlyAudits: [123, true], - }), - ).toThrow('Expected string'); + it('throws for array with non-string elements', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + onlyAudits: [123, true], + }), + ).toThrow('Expected string'); + }); }); -}); -describe('skipAudits', () => { - it('accepts valid audit slugs array', () => { - expect(() => - docCoveragePluginConfigSchema.parse({ - skipAudits: ['functions-coverage', 'classes-coverage'], - sourceGlob: ['src/**/*.ts'], - }), - ).not.toThrow(); - }); + describe('skipAudits', () => { + it('accepts valid audit slugs array', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + skipAudits: ['functions-coverage', 'classes-coverage'], + sourceGlob: ['src/**/*.ts'], + }), + ).not.toThrow(); + }); + + it('accepts empty array for skipAudits', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + skipAudits: [], + sourceGlob: ['src/**/*.ts'], + }), + ).not.toThrow(); + }); + + it('allows skipAudits to be undefined', () => { + const result = docCoveragePluginConfigSchema.parse({}); + expect(result.skipAudits).toBeUndefined(); + }); + + it('throws for invalid skipAudits type', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + skipAudits: 'functions-coverage', + }), + ).toThrow('Expected array'); + }); - it('throws for array with non-string elements', () => { - expect(() => - docCoveragePluginConfigSchema.parse({ - skipAudits: [123, true], - }), - ).toThrow('Expected string'); + it('throws for array with non-string elements', () => { + expect(() => + docCoveragePluginConfigSchema.parse({ + skipAudits: [123, true], + }), + ).toThrow('Expected string'); + }); }); }); diff --git a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts index adf079fc4..3682d515d 100644 --- a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts @@ -1,18 +1,24 @@ -import { describe, expect, it } from 'vitest'; -import type { RunnerConfig } from '@code-pushup/models'; -import { PLUGIN_SLUG } from './constants.js'; +import { describe, expect, it, vi } from 'vitest'; +import { PLUGIN_SLUG, groups } from './constants.js'; import { PLUGIN_DESCRIPTION, PLUGIN_DOCS_URL, PLUGIN_TITLE, docCoveragePlugin, } from './doc-coverage-plugin.js'; +import { createRunnerFunction } from './runner/runner.js'; +import { + filterAuditsByPluginConfig, + filterGroupsByOnlyAudits, +} from './utils.js'; + +vi.mock('./utils.js', () => ({ + filterAuditsByPluginConfig: vi.fn().mockReturnValue(['mockAudit']), + filterGroupsByOnlyAudits: vi.fn().mockReturnValue(['mockGroup']), +})); -vi.mock('./runner/index.ts', () => ({ - createRunnerConfig: vi.fn().mockReturnValue({ - command: 'node', - outputFile: 'runner-output.json', - } satisfies RunnerConfig), +vi.mock('./runner/runner.js', () => ({ + createRunnerFunction: vi.fn().mockReturnValue(() => Promise.resolve([])), })); describe('docCoveragePlugin', () => { @@ -34,4 +40,34 @@ describe('docCoveragePlugin', () => { }), ); }); + + it('should throw for invalid plugin options', async () => { + await expect( + docCoveragePlugin({ + // @ts-expect-error testing invalid config + sourceGlob: 123, + }), + ).rejects.toThrow('Expected array, received number'); + }); + + it('should filter groups', async () => { + const config = { sourceGlob: ['src/**/*.ts'] }; + await docCoveragePlugin(config); + + expect(filterGroupsByOnlyAudits).toHaveBeenCalledWith(groups, config); + }); + + it('should filter audits', async () => { + const config = { sourceGlob: ['src/**/*.ts'] }; + await docCoveragePlugin(config); + + expect(filterAuditsByPluginConfig).toHaveBeenCalledWith(config); + }); + + it('should forward options to runner function', async () => { + const config = { sourceGlob: ['src/**/*.ts'] }; + await docCoveragePlugin(config); + + expect(createRunnerFunction).toHaveBeenCalledWith(config); + }); }); diff --git a/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.unit.test.ts.snap b/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.unit.test.ts.snap index 1090891fe..3a9c6a965 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.unit.test.ts.snap +++ b/packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.unit.test.ts.snap @@ -1,6 +1,6 @@ // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html -exports[`getUnprocessedCoverageReport > should produce a full report 1`] = ` +exports[`getDocumentationReport > should produce a full report 1`] = ` { "classes": { "coverage": 33.33, diff --git a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.integration.test.ts b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.integration.test.ts index 539c3af7d..2f8cb4864 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.integration.test.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.integration.test.ts @@ -1,10 +1,9 @@ import { processDocCoverage } from './doc-processer.js'; describe('processDocCoverage', () => { - const sourcePath = - 'packages/plugin-doc-coverage/mocks/fixtures/angular/**/*.ts'; - it('should count total nodes from TypeScript files correctly', () => { + const sourcePath = + 'packages/plugin-doc-coverage/mocks/fixtures/angular/**/*.ts'; const expectedNodeCount = 8; const results = processDocCoverage({ sourceGlob: [sourcePath] }); @@ -17,7 +16,39 @@ describe('processDocCoverage', () => { expect(totalNodeCount).toBe(expectedNodeCount); }); + it('should count total nodes from Javascript files correctly', () => { + const sourcePath = + 'packages/plugin-doc-coverage/mocks/fixtures/react/**/*.js'; + const expectedNodeCount = 1; + + const results = processDocCoverage({ sourceGlob: [sourcePath] }); + + const totalNodeCount = Object.values(results).reduce( + (acc, node) => acc + node.nodesCount, + 0, + ); + + expect(totalNodeCount).toBe(expectedNodeCount); + }); + + it('should count total nodes from Javascript and TypeScript files correctly', () => { + const sourcePath = + 'packages/plugin-doc-coverage/mocks/fixtures/**/*.{js,ts}'; + const expectedNodeCount = 9; + + const results = processDocCoverage({ sourceGlob: [sourcePath] }); + + const totalNodeCount = Object.values(results).reduce( + (acc, node) => acc + node.nodesCount, + 0, + ); + + expect(totalNodeCount).toBe(expectedNodeCount); + }); + it('respect `sourceGlob` and only include matching files', () => { + const sourcePath = + 'packages/plugin-doc-coverage/mocks/fixtures/angular/**/*.ts'; const expectedNodeCount = 7; const results = processDocCoverage({ diff --git a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts index d63c1f469..c5bac7f78 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts @@ -6,9 +6,9 @@ import { } from 'ts-morph'; import type { DocCoveragePluginConfig } from '../config.js'; import type { - CoverageReportShape, - CoverageResult, CoverageType, + DocumentationCoverageReport, + DocumentationReport, } from './models.js'; import { calculateCoverage, @@ -43,24 +43,24 @@ export function getVariablesInformation( /** * Processes documentation coverage for TypeScript files in the specified path * @param toInclude - The file path pattern to include for documentation analysis - * @returns {CoverageResult} Object containing coverage statistics and undocumented items + * @returns {DocumentationCoverageReport} Object containing coverage statistics and undocumented items */ export function processDocCoverage( config: DocCoveragePluginConfig, -): CoverageResult { +): DocumentationCoverageReport { const project = new Project(); project.addSourceFilesAtPaths(config.sourceGlob); - return getUnprocessedCoverageReport(project.getSourceFiles()); + return getDocumentationReport(project.getSourceFiles()); } /** - * Gets the unprocessed coverage report from the source files + * Gets the documentation coverage report from the source files * @param sourceFiles - The source files to process - * @returns {CoverageReportShape} The unprocessed coverage report + * @returns {DocumentationCoverageReport} The documentation coverage report */ -export function getUnprocessedCoverageReport( +export function getDocumentationReport( sourceFiles: SourceFile[], -): CoverageResult { +): DocumentationCoverageReport { const unprocessedCoverageReport = sourceFiles.reduce( (coverageReportOfAllFiles, sourceFile) => { const filePath = sourceFile.getFilePath(); @@ -105,7 +105,7 @@ export function getUnprocessedCoverageReport( createEmptyCoverageData(), ); - return mergeCoverageResults( + return mergeDocumentationReports( coverageReportOfAllFiles, coverageReportOfCurrentFile, ); @@ -117,28 +117,29 @@ export function getUnprocessedCoverageReport( } /** - * Merges two coverage results - * @param results - The first empty coverage result - * @param current - The second coverage result - * @returns {CoverageReportShape} The merged coverage result + * Merges two documentation results + * @param accumulatedReport - The first empty documentation result + * @param currentFileReport - The second documentation result + * @returns {DocumentationReport} The merged documentation result */ -export function mergeCoverageResults( - results: CoverageReportShape, - current: Partial, -): CoverageReportShape { +export function mergeDocumentationReports( + accumulatedReport: DocumentationReport, + currentFileReport: Partial, +): DocumentationReport { return Object.fromEntries( - Object.entries(results).map(([key, value]) => { - const node = value as CoverageResult[CoverageType]; + Object.entries(accumulatedReport).map(([key, value]) => { + const node = value as DocumentationCoverageReport[CoverageType]; const type = key as CoverageType; return [ type, { - nodesCount: node.nodesCount + (current[type]?.nodesCount ?? 0), - issues: [...node.issues, ...(current[type]?.issues ?? [])], + nodesCount: + node.nodesCount + (currentFileReport[type]?.nodesCount ?? 0), + issues: [...node.issues, ...(currentFileReport[type]?.issues ?? [])], }, ]; }), - ) as CoverageReportShape; + ) as DocumentationReport; } /** diff --git a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts index 3db7abbb7..c8bfe7953 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts @@ -5,15 +5,15 @@ import { } from '../../../mocks/source-files-mock.generator'; import { getClassNodes, - getUnprocessedCoverageReport, + getDocumentationReport, getVariablesInformation, - mergeCoverageResults, + mergeDocumentationReports, } from './doc-processer.js'; -import type { CoverageReportShape } from './models.js'; +import type { DocumentationReport } from './models.js'; -describe('getUnprocessedCoverageReport', () => { +describe('getDocumentationReport', () => { it('should produce a full report', () => { - const results = getUnprocessedCoverageReport([ + const results = getDocumentationReport([ sourceFileMock('test.ts', { functions: { 1: true, 2: true, 3: true }, classes: { 4: false, 5: false, 6: true }, @@ -28,14 +28,14 @@ describe('getUnprocessedCoverageReport', () => { }); it('should accept array of source files', () => { - const results = getUnprocessedCoverageReport([ + const results = getDocumentationReport([ sourceFileMock('test.ts', { functions: { 1: true, 2: true, 3: false } }), ]); expect(results).toBeDefined(); }); it('should count nodes correctly', () => { - const results = getUnprocessedCoverageReport([ + const results = getDocumentationReport([ sourceFileMock('test.ts', { functions: { 1: true, 2: true, 3: false } }), ]); @@ -43,7 +43,7 @@ describe('getUnprocessedCoverageReport', () => { }); it('should collect uncommented nodes issues', () => { - const results = getUnprocessedCoverageReport([ + const results = getDocumentationReport([ sourceFileMock('test.ts', { functions: { 1: true, 2: false, 3: false } }), ]); @@ -51,7 +51,7 @@ describe('getUnprocessedCoverageReport', () => { }); it('should collect valid issues', () => { - const results = getUnprocessedCoverageReport([ + const results = getDocumentationReport([ sourceFileMock('test.ts', { functions: { 1: false } }), ]); @@ -66,7 +66,7 @@ describe('getUnprocessedCoverageReport', () => { }); it('should calculate coverage correctly', () => { - const results = getUnprocessedCoverageReport([ + const results = getDocumentationReport([ sourceFileMock('test.ts', { functions: { 1: true, 2: false } }), ]); @@ -74,8 +74,8 @@ describe('getUnprocessedCoverageReport', () => { }); }); -describe('mergeCoverageResults', () => { - const emptyResult: CoverageReportShape = { +describe('mergeDocumentationReports', () => { + const emptyResult: DocumentationReport = { enums: { nodesCount: 0, issues: [] }, interfaces: { nodesCount: 0, issues: [] }, types: { nodesCount: 0, issues: [] }, @@ -103,9 +103,9 @@ describe('mergeCoverageResults', () => { }, }; - const results = mergeCoverageResults( + const results = mergeDocumentationReports( emptyResult, - secondResult as Partial, + secondResult as Partial, ); expect(results).toStrictEqual( expect.objectContaining({ @@ -118,12 +118,12 @@ describe('mergeCoverageResults', () => { }); it('should merge empty results', () => { - const results = mergeCoverageResults(emptyResult, emptyResult); + const results = mergeDocumentationReports(emptyResult, emptyResult); expect(results).toStrictEqual(emptyResult); }); it('should merge second level property nodesCount', () => { - const results = mergeCoverageResults( + const results = mergeDocumentationReports( { ...emptyResult, enums: { nodesCount: 1, issues: [] }, @@ -136,7 +136,7 @@ describe('mergeCoverageResults', () => { }); it('should merge second level property issues', () => { - const results = mergeCoverageResults( + const results = mergeDocumentationReports( { ...emptyResult, enums: { diff --git a/packages/plugin-doc-coverage/src/lib/runner/models.ts b/packages/plugin-doc-coverage/src/lib/runner/models.ts index 547efab56..d95b7b47b 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/models.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/models.ts @@ -25,19 +25,19 @@ export type UndocumentedNode = { class?: string; }; -/** The coverage data is the data that is used to create the coverage report. Without coverage stats. */ -export type CoverageData = { +/** The documentation data has the issues and the total nodes count from a specific CoverageType. */ +export type DocumentationData = { issues: UndocumentedNode[]; nodesCount: number; }; -/** The coverage report shape the report of every CoverageType without coverage stats. */ -export type CoverageReportShape = Record; +/** The documentation report has all the documentation data for each coverage type. */ +export type DocumentationReport = Record; -/** The processed coverage result CoverageData but for each coverage type and with coverage stats. */ -export type CoverageResult = Record< +/** The processed documentation result has the documentation data for each coverage type and with coverage stats. */ +export type DocumentationCoverageReport = Record< CoverageType, - CoverageData & { + DocumentationData & { coverage: number; } >; diff --git a/packages/plugin-doc-coverage/src/lib/runner/runner.ts b/packages/plugin-doc-coverage/src/lib/runner/runner.ts index 1019687e8..b50fbdc4f 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/runner.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/runner.ts @@ -1,7 +1,7 @@ import type { AuditOutputs, RunnerFunction } from '@code-pushup/models'; import type { DocCoveragePluginConfig } from '../config.js'; import { processDocCoverage } from './doc-processer.js'; -import type { CoverageResult } from './models.js'; +import type { DocumentationCoverageReport } from './models.js'; export function createRunnerFunction( config: DocCoveragePluginConfig, @@ -19,7 +19,7 @@ export function createRunnerFunction( * @returns Audit outputs with coverage scores and details about undocumented items */ export function trasformCoverageReportToAudits( - coverageResult: CoverageResult, + coverageResult: DocumentationCoverageReport, options: Pick, ): AuditOutputs { return Object.entries(coverageResult) diff --git a/packages/plugin-doc-coverage/src/lib/runner/runner.unit.test.ts b/packages/plugin-doc-coverage/src/lib/runner/runner.unit.test.ts index aab40d08c..081df241f 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/runner.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/runner.unit.test.ts @@ -1,4 +1,4 @@ -import type { CoverageResult } from './models.js'; +import type { DocumentationCoverageReport } from './models.js'; import { trasformCoverageReportToAudits } from './runner.js'; describe('trasformCoverageReportToAudits', () => { @@ -27,7 +27,7 @@ describe('trasformCoverageReportToAudits', () => { }, ], }, - } as unknown as CoverageResult; + } as unknown as DocumentationCoverageReport; it('should return all audits from the coverage result when no filters are provided', () => { const result = trasformCoverageReportToAudits(mockCoverageResult, {}); @@ -55,7 +55,7 @@ describe('trasformCoverageReportToAudits', () => { it('should handle properly empty coverage result', () => { const result = trasformCoverageReportToAudits( - {} as unknown as CoverageResult, + {} as unknown as DocumentationCoverageReport, {}, ); expect(result).toEqual([]); diff --git a/packages/plugin-doc-coverage/src/lib/runner/utils.ts b/packages/plugin-doc-coverage/src/lib/runner/utils.ts index cdc202991..298b64806 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/utils.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/utils.ts @@ -1,15 +1,15 @@ import { SyntaxKind } from 'ts-morph'; import type { - CoverageReportShape, - CoverageResult, CoverageType, + DocumentationCoverageReport, + DocumentationReport, } from './models.js'; /** * Creates an empty unprocessed coverage report. * @returns The empty unprocessed coverage report. */ -export function createEmptyCoverageData(): CoverageReportShape { +export function createEmptyCoverageData(): DocumentationReport { return { enums: { nodesCount: 0, issues: [] }, interfaces: { nodesCount: 0, issues: [] }, @@ -27,7 +27,7 @@ export function createEmptyCoverageData(): CoverageReportShape { * @param result - The unprocessed coverage result. * @returns The processed coverage result. */ -export function calculateCoverage(result: CoverageReportShape) { +export function calculateCoverage(result: DocumentationReport) { return Object.fromEntries( Object.entries(result).map(([key, value]) => { const type = key as CoverageType; @@ -47,7 +47,7 @@ export function calculateCoverage(result: CoverageReportShape) { }, ]; }), - ) as CoverageResult; + ) as DocumentationCoverageReport; } /** diff --git a/packages/plugin-doc-coverage/src/lib/runner/utils.unit.test.ts b/packages/plugin-doc-coverage/src/lib/runner/utils.unit.test.ts index d45b1600c..fcf8e2f33 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/utils.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/utils.unit.test.ts @@ -1,5 +1,5 @@ import { SyntaxKind } from 'ts-morph'; -import type { CoverageReportShape } from './models.js'; +import type { DocumentationReport } from './models.js'; import { calculateCoverage, createEmptyCoverageData, @@ -36,7 +36,7 @@ describe('calculateCoverage', () => { }); it('should calculate correct coverage percentage with issues', () => { - const input: CoverageReportShape = { + const input: DocumentationReport = { ...createEmptyCoverageData(), functions: { nodesCount: 4, From 0ecc1931245cdcc8a91986f439ebd3df713088d0 Mon Sep 17 00:00:00 2001 From: Alejandro Date: Mon, 23 Dec 2024 15:43:57 +0100 Subject: [PATCH 34/39] chore: run nx format --- code-pushup.config.ts | 2 +- packages/plugin-doc-coverage/README.md | 2 +- tsconfig.base.json | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/code-pushup.config.ts b/code-pushup.config.ts index ebaaf803f..e511a1d76 100644 --- a/code-pushup.config.ts +++ b/code-pushup.config.ts @@ -43,7 +43,7 @@ export default mergeConfigs( await docCoverageCoreConfig({ sourceGlob: [ 'packages/**/src/**/*.ts', - '!**/*.{spec,test}.ts' + '!**/*.{spec,test}.ts', '!**/implementation/**', '!**/internal/**', ], diff --git a/packages/plugin-doc-coverage/README.md b/packages/plugin-doc-coverage/README.md index 842730ab5..ca54ce31f 100644 --- a/packages/plugin-doc-coverage/README.md +++ b/packages/plugin-doc-coverage/README.md @@ -11,7 +11,7 @@ It analyzes your codebase and checks for documentation on different code element Measured documentation types are mapped to Code PushUp audits in the following way: -- `value`: The value is the number of undocumented nodes -> 4 +- `value`: The value is the number of undocumented nodes -> 4 - `displayValue`: `${value} undocumented ${type}` -> 4 undocumented functions - `score`: 0.5 -> total nodes 8 undocumented 4 -> 8/4 - The score is value converted to 0-1 range diff --git a/tsconfig.base.json b/tsconfig.base.json index c5cddb98c..026003f3e 100644 --- a/tsconfig.base.json +++ b/tsconfig.base.json @@ -24,10 +24,10 @@ "@code-pushup/cli": ["packages/cli/src/index.ts"], "@code-pushup/core": ["packages/core/src/index.ts"], "@code-pushup/coverage-plugin": ["packages/plugin-coverage/src/index.ts"], - "@code-pushup/eslint-plugin": ["packages/plugin-eslint/src/index.ts"], "@code-pushup/doc-coverage-plugin": [ "packages/plugin-doc-coverage/src/index.ts" ], + "@code-pushup/eslint-plugin": ["packages/plugin-eslint/src/index.ts"], "@code-pushup/js-packages-plugin": [ "packages/plugin-js-packages/src/index.ts" ], From 7e0acbdf402856c49268e43d8540119508e570eb Mon Sep 17 00:00:00 2001 From: Alejandro Date: Mon, 23 Dec 2024 16:02:43 +0100 Subject: [PATCH 35/39] chore(plugin-doc-coverage): improve readme and audits --- packages/plugin-doc-coverage/README.md | 67 ++++++++++++++----- .../src/lib/runner/runner.ts | 6 +- 2 files changed, 55 insertions(+), 18 deletions(-) diff --git a/packages/plugin-doc-coverage/README.md b/packages/plugin-doc-coverage/README.md index ca54ce31f..78f30ace6 100644 --- a/packages/plugin-doc-coverage/README.md +++ b/packages/plugin-doc-coverage/README.md @@ -37,15 +37,6 @@ Measured documentation types are mapped to Code PushUp audits in the following w 3. Add this plugin to the `plugins` array in your Code PushUp CLI config file (e.g. `code-pushup.config.ts`). - Pass the target files to analyze and optionally specify which types of documentation you want to track. - You can skip for example tests by defining in the sourceGlob the path to the tests folder or pattern to match the tests files with the `!` symbol. - All documentation types are measured by default. - If you wish to focus on a subset of offered types, define them in `onlyAudits`. - Also you can skip some types by defining them in `skipAudits`. - You can only define or `onlyAudits` or `skipAudits`, not both. - - The configuration will look similarly to the following: - ```js import docCoveragePlugin from '@code-pushup/doc-coverage-plugin'; @@ -92,9 +83,16 @@ Measured documentation types are mapped to Code PushUp audits in the following w Documentation coverage is a metric that indicates what percentage of your code elements have proper documentation. It helps ensure your codebase is well-documented and maintainable. -The plugin provides a single audit that measures the overall percentage of documentation coverage across your codebase: +The plugin provides multiple audits, one for each documentation type (classes, functions, interfaces, etc.), and groups them together for an overall documentation coverage measurement. Each audit: + +- Measures the documentation coverage for its specific type (e.g., classes, functions) +- Provides a score based on the percentage of documented elements +- Includes details about which elements are missing documentation -- **Percentage coverage**: Measures how many percent of the codebase have documentation. +These audits are grouped together to provide a comprehensive view of your codebase's documentation status. You can use either: + +- The complete group of audits for overall documentation coverage +- Individual audits to focus on specific documentation types ## Plugin architecture @@ -102,10 +100,49 @@ The plugin provides a single audit that measures the overall percentage of docum The plugin accepts the following parameters: -- (optional) `coverageToolCommand`: If you wish to run your documentation coverage tool (compodoc) to generate the results first, you may define it here. - - `command`: Command to run coverage tool (e.g. `npx`). - - `args`: Arguments to be passed to the coverage tool (e.g. `['compodoc', '-p', 'tsconfig.doc.json', '-e', 'json']`). -- `outputPath`: Path to the documentation.json file. Defaults to `'documentation/documentation.json'`. +#### SourceGlob + +Required parameter. The `sourceGlob` option accepts an array of strings that define patterns to include or exclude files. You can use glob patterns to match files and the `!` symbol to exclude specific patterns. Example: + +```js +await docCoveragePlugin({ + sourceGlob: [ + 'src/**/*.ts', // include all TypeScript files in src + '!src/**/*.{spec,test}.ts', // exclude test files + '!src/**/testing/**/*.ts' // exclude testing utilities + ], +}), +``` + +#### OnlyAudits + +Optional parameter. The `onlyAudits` option allows you to specify which documentation types you want to measure. Only the specified audits will be included in the results. Example: + +```js +await docCoveragePlugin({ + sourceGlob: ['src/**/*.ts'], + onlyAudits: [ + 'classes-coverage', + 'functions-coverage' + ] // Only measure documentation for classes and functions +}), +``` + +#### SkipAudits + +Optional parameter. The `skipAudits` option allows you to exclude specific documentation types from measurement. All other types will be included in the results. + +```js +await docCoveragePlugin({ + sourceGlob: ['src/**/*.ts'], + skipAudits: [ + 'variables-coverage', + 'interfaces-coverage' + ] // Measure all documentation types except variables and interfaces +}), +``` + +> ⚠️ **Warning:** You cannot use both `onlyAudits` and `skipAudits` in the same configuration. Choose the one that better suits your needs. ### Audits and group diff --git a/packages/plugin-doc-coverage/src/lib/runner/runner.ts b/packages/plugin-doc-coverage/src/lib/runner/runner.ts index b50fbdc4f..8c059aac7 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/runner.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/runner.ts @@ -34,13 +34,13 @@ export function trasformCoverageReportToAudits( return true; }) .map(([type, item]) => { - const { coverage } = item; + const { coverage, issues } = item; return { slug: `${type}-coverage`, - value: coverage, + value: issues.length, score: coverage / 100, - displayValue: `${coverage} %`, + displayValue: `${issues.length} undocumented ${type}`, details: { issues: item.issues.map(({ file, line }) => ({ message: 'Missing documentation', From 24468ccc1b3862e7c318ca36bafffaff8f1e5a25 Mon Sep 17 00:00:00 2001 From: Alejandro Date: Mon, 23 Dec 2024 19:08:00 +0100 Subject: [PATCH 36/39] chore(plugin-doc-coverage): remove unused async --- packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts index d452839d6..578c0c490 100644 --- a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts +++ b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts @@ -36,9 +36,9 @@ export const PLUGIN_DOCS_URL = * * @returns Plugin configuration. */ -export async function docCoveragePlugin( +export function docCoveragePlugin( config: DocCoveragePluginConfig, -): Promise { +): PluginConfig { const docCoverageConfig = docCoveragePluginConfigSchema.parse(config); return { From ef77df0007feaed0a0afb05bdca8bb602deda327 Mon Sep 17 00:00:00 2001 From: Alejandro Date: Mon, 23 Dec 2024 19:53:25 +0100 Subject: [PATCH 37/39] chore(plugin-doc-coverage): fix tests, fully remove unnecessary await --- code-pushup.preset.ts | 2 +- packages/plugin-doc-coverage/README.md | 8 ++--- .../src/lib/config.unit.test.ts | 2 +- .../src/lib/doc-coverage-plugin.ts | 4 +-- .../src/lib/doc-coverage-plugin.unit.test.ts | 20 +++++------ .../src/lib/runner/doc-processer.ts | 26 +++++++------- .../src/lib/runner/doc-processer.unit.test.ts | 35 +++++++++++++++++++ 7 files changed, 67 insertions(+), 30 deletions(-) diff --git a/code-pushup.preset.ts b/code-pushup.preset.ts index 1060dd1e9..c7f907f03 100644 --- a/code-pushup.preset.ts +++ b/code-pushup.preset.ts @@ -144,7 +144,7 @@ export const docCoverageCoreConfig = async ( config: DocCoveragePluginConfig, ): Promise => { return { - plugins: [await docCoveragePlugin(config)], + plugins: [docCoveragePlugin(config)], categories: getDocCoverageCategories(config), }; }; diff --git a/packages/plugin-doc-coverage/README.md b/packages/plugin-doc-coverage/README.md index 78f30ace6..d41ba4576 100644 --- a/packages/plugin-doc-coverage/README.md +++ b/packages/plugin-doc-coverage/README.md @@ -44,7 +44,7 @@ Measured documentation types are mapped to Code PushUp audits in the following w // ... plugins: [ // ... - await docCoveragePlugin({ + docCoveragePlugin({ sourceGlob: ['**/*.ts'], }), ], @@ -105,7 +105,7 @@ The plugin accepts the following parameters: Required parameter. The `sourceGlob` option accepts an array of strings that define patterns to include or exclude files. You can use glob patterns to match files and the `!` symbol to exclude specific patterns. Example: ```js -await docCoveragePlugin({ +docCoveragePlugin({ sourceGlob: [ 'src/**/*.ts', // include all TypeScript files in src '!src/**/*.{spec,test}.ts', // exclude test files @@ -119,7 +119,7 @@ await docCoveragePlugin({ Optional parameter. The `onlyAudits` option allows you to specify which documentation types you want to measure. Only the specified audits will be included in the results. Example: ```js -await docCoveragePlugin({ +docCoveragePlugin({ sourceGlob: ['src/**/*.ts'], onlyAudits: [ 'classes-coverage', @@ -133,7 +133,7 @@ await docCoveragePlugin({ Optional parameter. The `skipAudits` option allows you to exclude specific documentation types from measurement. All other types will be included in the results. ```js -await docCoveragePlugin({ +docCoveragePlugin({ sourceGlob: ['src/**/*.ts'], skipAudits: [ 'variables-coverage', diff --git a/packages/plugin-doc-coverage/src/lib/config.unit.test.ts b/packages/plugin-doc-coverage/src/lib/config.unit.test.ts index 83449ecce..4d4b4f1ea 100644 --- a/packages/plugin-doc-coverage/src/lib/config.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/config.unit.test.ts @@ -91,7 +91,7 @@ describe('DocCoveragePlugin Configuration', () => { docCoveragePluginConfigSchema.parse({ onlyAudits: [123, true], }), - ).toThrow('Expected string'); + ).toThrow('Expected string, received number'); }); }); diff --git a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts index 578c0c490..dc594a303 100644 --- a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts +++ b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts @@ -28,8 +28,8 @@ export const PLUGIN_DOCS_URL = * // ... core config ... * plugins: [ * // ... other plugins ... - * await docCoveragePlugin({ - * sourceGlob: 'src/**/*.{ts,tsx}', + * docCoveragePlugin({ + * sourceGlob: ['src/**/*.{ts,tsx}'] * }) * ] * } diff --git a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts index 3682d515d..3fda06e71 100644 --- a/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts @@ -22,12 +22,12 @@ vi.mock('./runner/runner.js', () => ({ })); describe('docCoveragePlugin', () => { - it('should create a valid plugin config', async () => { - await expect( + it('should create a valid plugin config', () => { + expect( docCoveragePlugin({ sourceGlob: ['src/**/*.ts', '!**/*.spec.ts', '!**/*.test.ts'], }), - ).resolves.toStrictEqual( + ).toStrictEqual( expect.objectContaining({ slug: PLUGIN_SLUG, title: PLUGIN_TITLE, @@ -41,32 +41,32 @@ describe('docCoveragePlugin', () => { ); }); - it('should throw for invalid plugin options', async () => { - await expect( + it('should throw for invalid plugin options', () => { + expect(() => docCoveragePlugin({ // @ts-expect-error testing invalid config sourceGlob: 123, }), - ).rejects.toThrow('Expected array, received number'); + ).toThrow('Expected array, received number'); }); - it('should filter groups', async () => { + it('should filter groups', () => { const config = { sourceGlob: ['src/**/*.ts'] }; - await docCoveragePlugin(config); + docCoveragePlugin(config); expect(filterGroupsByOnlyAudits).toHaveBeenCalledWith(groups, config); }); it('should filter audits', async () => { const config = { sourceGlob: ['src/**/*.ts'] }; - await docCoveragePlugin(config); + docCoveragePlugin(config); expect(filterAuditsByPluginConfig).toHaveBeenCalledWith(config); }); it('should forward options to runner function', async () => { const config = { sourceGlob: ['src/**/*.ts'] }; - await docCoveragePlugin(config); + docCoveragePlugin(config); expect(createRunnerFunction).toHaveBeenCalledWith(config); }); diff --git a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts index c5bac7f78..82be50608 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.ts @@ -53,6 +53,19 @@ export function processDocCoverage( return getDocumentationReport(project.getSourceFiles()); } +export function getAllNodesFromASourceFile(sourceFile: SourceFile) { + const classes = sourceFile.getClasses(); + return [ + ...sourceFile.getFunctions(), + ...classes, + ...getClassNodes(classes), + ...sourceFile.getTypeAliases(), + ...sourceFile.getEnums(), + ...sourceFile.getInterfaces(), + ...getVariablesInformation(sourceFile.getVariableStatements()), + ]; +} + /** * Gets the documentation coverage report from the source files * @param sourceFiles - The source files to process @@ -64,23 +77,12 @@ export function getDocumentationReport( const unprocessedCoverageReport = sourceFiles.reduce( (coverageReportOfAllFiles, sourceFile) => { const filePath = sourceFile.getFilePath(); - const classes = sourceFile.getClasses(); - - const allNodesFromFile = [ - ...sourceFile.getFunctions(), - ...classes, - ...getClassNodes(classes), - ...sourceFile.getTypeAliases(), - ...sourceFile.getEnums(), - ...sourceFile.getInterfaces(), - ...getVariablesInformation(sourceFile.getVariableStatements()), - ]; + const allNodesFromFile = getAllNodesFromASourceFile(sourceFile); const coverageReportOfCurrentFile = allNodesFromFile.reduce( (acc, node) => { const nodeType = getCoverageTypeFromKind(node.getKind()); const currentTypeReport = acc[nodeType]; - const updatedIssues = node.getJsDocs().length === 0 ? [ diff --git a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts index c8bfe7953..8cf66f43f 100644 --- a/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts +++ b/packages/plugin-doc-coverage/src/lib/runner/doc-processer.unit.test.ts @@ -4,6 +4,7 @@ import { sourceFileMock, } from '../../../mocks/source-files-mock.generator'; import { + getAllNodesFromASourceFile, getClassNodes, getDocumentationReport, getVariablesInformation, @@ -276,3 +277,37 @@ describe('getVariablesInformation', () => { expect(result).toHaveLength(0); }); }); + +describe('getAllNodesFromASourceFile', () => { + it('should combine all node types from a source file', () => { + const mockSourceFile = sourceFileMock('test.ts', { + functions: { 1: true }, + classes: { 2: false }, + types: { 3: true }, + enums: { 4: false }, + interfaces: { 5: true }, + }); + + const result = getAllNodesFromASourceFile(mockSourceFile); + + expect(result).toHaveLength(5); + }); + + it('should handle empty source file', () => { + const mockSourceFile = sourceFileMock('empty.ts', {}); + + const result = getAllNodesFromASourceFile(mockSourceFile); + + expect(result).toHaveLength(0); + }); + + it('should handle source file with only functions', () => { + const mockSourceFile = sourceFileMock('functions.ts', { + functions: { 1: true, 2: false, 3: true }, + }); + + const result = getAllNodesFromASourceFile(mockSourceFile); + + expect(result).toHaveLength(3); + }); +}); From b09aa579b01682e6ea2eb6e885d687a3de2d01e6 Mon Sep 17 00:00:00 2001 From: Alejandro Date: Mon, 23 Dec 2024 22:26:10 +0100 Subject: [PATCH 38/39] chore: fix scope of sourceGlob --- code-pushup.config.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/code-pushup.config.ts b/code-pushup.config.ts index e511a1d76..c891c7a99 100644 --- a/code-pushup.config.ts +++ b/code-pushup.config.ts @@ -43,10 +43,11 @@ export default mergeConfigs( await docCoverageCoreConfig({ sourceGlob: [ 'packages/**/src/**/*.ts', + '!packages/**/node_modules', + '!packages/**/{mocks,mocks}', '!**/*.{spec,test}.ts', '!**/implementation/**', '!**/internal/**', ], - skipAudits: ['methods-coverage'], }), ); From b9f5333a1e99b49656a5e1b3a7c48046648b7583 Mon Sep 17 00:00:00 2001 From: Alejandro Date: Mon, 23 Dec 2024 22:26:30 +0100 Subject: [PATCH 39/39] fix: mock word --- code-pushup.config.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/code-pushup.config.ts b/code-pushup.config.ts index c891c7a99..b48295452 100644 --- a/code-pushup.config.ts +++ b/code-pushup.config.ts @@ -44,7 +44,7 @@ export default mergeConfigs( sourceGlob: [ 'packages/**/src/**/*.ts', '!packages/**/node_modules', - '!packages/**/{mocks,mocks}', + '!packages/**/{mocks,mock}', '!**/*.{spec,test}.ts', '!**/implementation/**', '!**/internal/**',