wip

code-pushup.config.ts

@@ -34,12 +34,12 @@ const config: CoreConfig = {
 
 export default mergeConfigs(
   config,
-  await coverageCoreConfigNx(),
+/* await coverageCoreConfigNx(),
   await jsPackagesCoreConfig(),
   await lighthouseCoreConfig(
     'https://github.com/code-pushup/cli?tab=readme-ov-file#code-pushup-cli/',
   ),
-  await eslintCoreConfigNx(),
+  await eslintCoreConfigNx(),*/
   await typescriptPluginConfigNx({
     tsConfigPath: 'packages/plugin-typescript/tsconfig.lib.json',
     // onlyAudits: ['verbatim-module-syntax-typescript']

code-pushup.preset.ts

@@ -144,7 +144,7 @@ export const typescriptPluginConfigNx = async (
 
   return {
     plugins: [await typescriptPlugin(opt)],
-    categories: [
+    /*categories: [
       {
         slug: 'typescript',
         title: 'Typescript',
@@ -157,7 +157,7 @@ export const typescriptPluginConfigNx = async (
           }),
         ),
       },
-    ],
+    ],*/
   };
 };
 

packages/plugin-typescript/src/lib/constants.ts

@@ -4,15 +4,15 @@ import {
   GROUPS_DESCRIPTIONS,
   TS_ERROR_CODES,
 } from './runner/ts-error-codes.js';
-import type { AuditSlug } from './types.js';
+import type { CompilerOptionName } from './types.js';
 
 export const TYPESCRIPT_PLUGIN_SLUG = 'typescript';
 export const DEFAULT_TS_CONFIG = 'tsconfig.json';
 
 export const AUDITS = Object.values(TS_ERROR_CODES)
   .flatMap(i => Object.entries(i))
   .reduce<Audit[]>((audits, [name]) => {
-    const slug = camelCaseToKebabCase(name) as AuditSlug;
+    const slug = camelCaseToKebabCase(name) as CompilerOptionName;
     const title = kebabCaseToSentence(name);
     return [
       ...audits,

packages/plugin-typescript/src/lib/runner/runner.ts

@@ -6,7 +6,7 @@ import type {
   Issue,
   RunnerFunction,
 } from '@code-pushup/models';
-import type { AuditSlug } from '../types.js';
+import type { CompilerOptionName } from '../types.js';
 import { mergeTsConfigs } from '../typescript-plugin';
 import {
   type DiagnosticsOptions,
@@ -29,7 +29,7 @@ export function createRunnerFunction(options: RunnerOptions): RunnerFunction {
     const diagnostics = await getDiagnostics({ fileNames, compilerOptions });
 
     const result: Record<
-      AuditSlug,
+      CompilerOptionName,
       Pick<AuditReport, 'slug' | 'details'>
     > = diagnostics
       // filter out unsupported errors
@@ -50,13 +50,13 @@ export function createRunnerFunction(options: RunnerOptions): RunnerFunction {
           };
         },
         {} as unknown as Record<
-          AuditSlug,
+          CompilerOptionName,
           Pick<AuditReport, 'slug' | 'details'>
         >,
       );
 
     return filteredAudits.map(audit => {
-      const { details } = result[audit.slug as AuditSlug] ?? {};
+      const { details } = result[audit.slug as CompilerOptionName] ?? {};
       const issues = details?.issues ?? [];
       return {
         ...audit,

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

@@ -5,26 +5,26 @@ import {
 } from 'typescript';
 import type { Issue } from '@code-pushup/models';
 import { camelCaseToKebabCase } from '@code-pushup/utils';
-import type { AuditSlug } from '../types.js';
+import type { CompilerOptionName } from '../types.js';
 import { TS_ERROR_CODES } from './ts-error-codes.js';
 
 /** Build Reverse Lookup Map. It will a map with key as the error code and value as the audit slug. */
 export const AUDIT_LOOKUP = Object.values(TS_ERROR_CODES)
   .flatMap(v => Object.entries(v))
-  .reduce<Map<number, AuditSlug>>((lookup, [name, codes]) => {
+  .reduce<Map<number, CompilerOptionName>>((lookup, [name, codes]) => {
     codes.forEach((code: number) =>
-      lookup.set(code, camelCaseToKebabCase(name) as AuditSlug),
+      lookup.set(code, camelCaseToKebabCase(name) as CompilerOptionName),
     );
     return lookup;
-  }, new Map<number, AuditSlug>());
+  }, new Map<number, CompilerOptionName>());
 
 /**
  * Transform the TypeScript error code to the audit slug.
  * @param code - The TypeScript error code.
  * @returns The audit slug.
  * @throws Error if the code is not supported.
  */
-export function tSCodeToAuditSlug(code: number): AuditSlug {
+export function tSCodeToAuditSlug(code: number): CompilerOptionName {
   const knownCode = AUDIT_LOOKUP.get(code);
   if (knownCode === undefined) {
     throw new Error(`Code ${code} not supported.`);

packages/plugin-typescript/src/lib/schema.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { AUDITS, DEFAULT_TS_CONFIG } from './constants.js';
-import type { AuditSlug } from './types.js';
+import type { CompilerOptionName } from './types.js';
 
 const auditSlugs = AUDITS.map(({ slug }) => slug) as [string, ...string[]];
 export const typescriptPluginConfigSchema = z.object({
@@ -18,4 +18,4 @@ export const typescriptPluginConfigSchema = z.object({
 
 export type TypescriptPluginOptions = z.infer<
   typeof typescriptPluginConfigSchema
-> & { onlyAudits?: (string | AuditSlug)[] | undefined };
+> & { onlyAudits?: (string | CompilerOptionName)[] | undefined };

packages/plugin-typescript/src/lib/types.ts

@@ -1,14 +1,24 @@
-import { z } from 'zod';
-import { TS_ERROR_CODES } from './runner/ts-error-codes.js';
-import { typescriptPluginConfigSchema } from './schema.js';
+import {z} from 'zod';
+import {TS_ERROR_CODES} from './runner/ts-error-codes.js';
+import {typescriptPluginConfigSchema} from './schema.js';
+
+type CamelCaseToKebabCase<S extends string> = S extends `${infer First}${infer Rest}`
+  ? Rest extends Uncapitalize<Rest>
+    ? `${Lowercase<First>}${CamelCaseToKebabCase<Rest>}`
+    : `${Lowercase<First>}-${CamelCaseToKebabCase<Rest>}`
+  : S;
 
 export type SemVerString = `${number}.${number}.${number}`;
 
 type ErrorCodes = typeof TS_ERROR_CODES;
-export type AuditSlug = {
+
+export type CompilerOptionName = {
   [K in keyof ErrorCodes]: keyof ErrorCodes[K];
 }[keyof ErrorCodes];
 
+export type AuditSlug = CamelCaseToKebabCase<CompilerOptionName>;
+
+
 export type TypescriptPluginOptions = z.infer<
   typeof typescriptPluginConfigSchema
 > & { onlyAudits?: (string | AuditSlug)[] | undefined };

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

@@ -1,23 +1,26 @@
 import type {PluginConfig} from '@code-pushup/models';
 import {name as packageName, version} from '../../package.json';
-import {
-  AUDITS,
-  DEFAULT_TS_CONFIG,
-  GROUPS,
-  TYPESCRIPT_PLUGIN_SLUG,
-} from './constants.js';
+import {AUDITS, DEFAULT_TS_CONFIG, GROUPS, TYPESCRIPT_PLUGIN_SLUG,} from './constants.js';
 import {createRunnerFunction} from './runner/runner.js';
-import type {TypescriptPluginOptions} from './types.js';
+import type {AuditSlug, CompilerOptionName, TypescriptPluginOptions} from './types.js';
 import {
-  filterAuditsBySlug,
+  filterAuditsByTsOptions,
   filterGroupsByAuditSlug,
+  filterGroupsByByTsOptions,
   getCurrentTsVersion,
-  loadDefaultTsConfig,
-  mergeTsConfigs
+  loadDefaultTsConfig
 } from './utils.js';
 import {getTsConfigurationFromPath} from "./runner/typescript-runner.ts";
-import {join, resolve} from "node:path";
-import {formatDiagnosticsWithColorAndContext, parseJsonConfigFileContent, readConfigFile, sys} from "typescript";
+import {resolve} from "node:path";
+import {
+  type CompilerOptions,
+  formatDiagnosticsWithColorAndContext,
+  parseJsonConfigFileContent,
+  readConfigFile,
+  sys,
+} from "typescript";
+import {kebabCaseToCamelCase} from "@code-pushup/utils";
+import {filterAuditsBySlug} from './utils.js';
 
 export function mergeTsConfigs(baseConfigPath: string, overrideConfigPath: string) {
   // Read and parse the base configuration
@@ -66,13 +69,15 @@ export async function typescriptPlugin(
     existingConfig: defaultCompilerOptions
   });
 
-  const  compilerOptions =  {...defaultCompilerOptions, ...desiredCompilerOptions};
+  // merges the defaultCompilerOptions of that TS Version with the compilerOptions configured by the user. EX: user vermatin could be undefined, but the default could be true
+  const  compilerOptions: CompilerOptions =  {...defaultCompilerOptions, ...desiredCompilerOptions};
+
+
 
-  const filteredAudits = AUDITS//.filter(filterAuditsBySlug(onlyAudits))
-  // filter by active compilerOptions
-  // .filter();
+  const filteredAudits = AUDITS
+    .filter(filterAuditsByTsOptions(compilerOptions, onlyAudits))
 
-  const filteredGroups = GROUPS.filter(filterGroupsByAuditSlug(onlyAudits));
+  const filteredGroups = GROUPS.filter(filterGroupsByByTsOptions(compilerOptions, onlyAudits));
   return {
     slug: TYPESCRIPT_PLUGIN_SLUG,
     packageName,
@@ -82,7 +87,7 @@ export async function typescriptPlugin(
     docsUrl: 'https://www.npmjs.com/package/@code-pushup/typescript-plugin/',
     icon: 'typescript',
     audits: filteredAudits,
-    groups: filteredGroups,
+    // groups: filteredGroups,
     runner: createRunnerFunction({
       fileNames,
       compilerOptions,

packages/plugin-typescript/src/lib/utils.ts

@@ -1,35 +1,45 @@
-import { access } from 'node:fs/promises';
-import { dirname } from 'node:path';
+import {access} from 'node:fs/promises';
+import {dirname} from 'node:path';
 import {
   type CompilerOptions,
   type TsConfigSourceFile,
   parseJsonConfigFileContent,
   sys,
 } from 'typescript';
-import type { Audit, Group } from '@code-pushup/models';
-import { executeProcess } from '@code-pushup/utils';
-import type { SemVerString } from './types.js';
+import type {Audit, Group} from '@code-pushup/models';
+import {executeProcess, kebabCaseToCamelCase} from '@code-pushup/utils';
+import type {CompilerOptionName, SemVerString} from './types.js';
 
 export function filterAuditsBySlug(slugs?: string[]) {
-  return ({ slug }: Audit) => {
+  return ({slug}: { slug: string }) => {
     if (slugs && slugs.length > 0) {
       return slugs.includes(slug);
     }
     return true;
   };
 }
 
+export function filterAuditsByTsOptions(compilerOptions: CompilerOptions, onlyAudits?: string[]) {
+  return ({slug}: { slug: string }) => {
+    const compilerOptionName = kebabCaseToCamelCase(slug) as CompilerOptionName;
+    return compilerOptions[compilerOptionName] === true && filterAuditsBySlug(onlyAudits);
+  };
+}
+
 export function filterGroupsByAuditSlug(slugs?: string[]) {
-  return ({ refs }: Group) => {
-    if (slugs && slugs.length > 0) {
-      return refs.some(({ slug }) => slugs.includes(slug));
-    }
-    return true;
+  return ({refs}: Group) => {
+    return refs.some(filterAuditsBySlug(slugs));
+  };
+}
+
+export function filterGroupsByByTsOptions(compilerOptions: CompilerOptions, onlyAudits?: string[]) {
+  return ({refs}: Group) => {
+    return refs.some(filterAuditsByTsOptions(compilerOptions, onlyAudits));
   };
 }
 
 export async function getCurrentTsVersion(): Promise<SemVerString> {
-  const { stdout } = await executeProcess({
+  const {stdout} = await executeProcess({
     command: 'npx',
     args: ['tsc', '--version'],
   });