fix: refactor types

Author: BioPhoton

packages/plugin-typescript/src/index.ts

@@ -2,9 +2,14 @@ import { typescriptPlugin } from './lib/typescript-plugin.js';
 
 export { TYPESCRIPT_PLUGIN_SLUG } from './lib/constants.js';
 
-export type { TypescriptPluginOptions } from './lib/types.js';
 export { getCurrentTsVersion } from './lib/runner/utils.js';
-export { getCategoryRefsFromGroups } from './lib/utils.js';
-export { typescriptPlugin } from './lib/typescript-plugin.js';
+export {
+  getCategoryRefsFromAudits,
+  getCategoryRefsFromGroups,
+} from './lib/utils.js';
+export {
+  typescriptPlugin,
+  TypescriptPluginOptions,
+} from './lib/typescript-plugin.js';
 export default typescriptPlugin;
 export { getTsDefaultsFilename } from './lib/runner/constants.js';

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

@@ -6,19 +6,22 @@ import type {
   Issue,
   RunnerFunction,
 } from '@code-pushup/models';
-import type { TypescriptPluginOptions } from '../types.js';
 import { AUDIT_LOOKUP } from './constants.js';
-import { getTypeScriptDiagnostics } from './ts-runner.js';
+import {
+  type DiagnosticsOptions,
+  getTypeScriptDiagnostics,
+} from './ts-runner.js';
 import type { CompilerOptionName } from './types.js';
 import { getIssueFromDiagnostic, tSCodeToAuditSlug } from './utils.js';
 
-export type RunnerOptions = TypescriptPluginOptions & {
+export type RunnerOptions = DiagnosticsOptions & {
   expectedAudits: Pick<Audit, 'slug'>[];
 };
 
 export function createRunnerFunction(options: RunnerOptions): RunnerFunction {
+  const { tsConfigPath, expectedAudits } = options;
   return async (): Promise<AuditOutputs> => {
-    const diagnostics = await getTypeScriptDiagnostics(options.tsConfigPath);
+    const diagnostics = await getTypeScriptDiagnostics({ tsConfigPath });
     const result: Record<
       CompilerOptionName,
       Pick<AuditReport, 'slug' | 'details'>
@@ -42,11 +45,11 @@ export function createRunnerFunction(options: RunnerOptions): RunnerFunction {
         },
         {} as unknown as Record<
           CompilerOptionName,
-          Pick<AuditReport, 'slug' | 'details'>
+          Pick<AuditOutput, 'slug' | 'details'>
         >,
       );
 
-    return options.expectedAudits.map(({ slug }) => {
+    return expectedAudits.map(({ slug }) => {
       const { details } = result[slug as CompilerOptionName] ?? {};
 
       const issues = details?.issues ?? [];

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

@@ -1,19 +1,16 @@
 import {
-  type CompilerOptions,
   type Diagnostic,
   createProgram,
   getPreEmitDiagnostics,
 } from 'typescript';
 import { loadTargetConfig, validateDiagnostics } from './utils.js';
 
 export type DiagnosticsOptions = {
-  fileNames: string[];
-  compilerOptions: CompilerOptions;
+  tsConfigPath: string;
 };
-
-export async function getTypeScriptDiagnostics(
-  tsConfigPath: string,
-): Promise<readonly Diagnostic[]> {
+export async function getTypeScriptDiagnostics({
+  tsConfigPath,
+}: DiagnosticsOptions): Promise<readonly Diagnostic[]> {
   try {
     const { fileNames, options } = await loadTargetConfig(tsConfigPath);
 

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

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

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

@@ -1,10 +1,4 @@
-import { z } from 'zod';
 import type { CamelCaseToKebabCase } from '@code-pushup/utils';
 import type { CompilerOptionName } from './runner/types.js';
-import { typescriptPluginConfigSchema } from './schema.js';
 
 export type AuditSlug = CamelCaseToKebabCase<CompilerOptionName>;
-
-export type TypescriptPluginOptions = z.infer<
-  typeof typescriptPluginConfigSchema
-> & { onlyAudits?: AuditSlug[] | undefined };

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

@@ -3,21 +3,29 @@ import type { PluginConfig } from '@code-pushup/models';
 import { DEFAULT_TS_CONFIG, TYPESCRIPT_PLUGIN_SLUG } from './constants.js';
 import { normalizeCompilerOptions } from './normalize-compiler-options.js';
 import { createRunnerFunction } from './runner/runner.js';
-import type { TypescriptPluginOptions } from './types.js';
+import type { DiagnosticsOptions } from './runner/ts-runner.js';
+import { typescriptPluginConfigSchema } from './schema.js';
+import type { AuditSlug } from './types.js';
 import { getAudits, getGroups, logSkippedAudits } from './utils.js';
 
 const packageJson = createRequire(import.meta.url)(
   '../../package.json',
 ) as typeof import('../../package.json');
 
+export type FilterOptions = { onlyAudits?: AuditSlug[] | undefined };
+export type TypescriptPluginOptions = Partial<DiagnosticsOptions> &
+  FilterOptions;
+
 export async function typescriptPlugin(
   options?: TypescriptPluginOptions,
 ): Promise<PluginConfig> {
-  const { tsConfigPath } = options ?? { tsConfigPath: DEFAULT_TS_CONFIG };
+  const { tsConfigPath = DEFAULT_TS_CONFIG, onlyAudits } = parseOptions(
+    options ?? {},
+  );
 
   const compilerOptions = await normalizeCompilerOptions({ tsConfigPath });
-  const filteredAudits = getAudits(compilerOptions, options);
-  const filteredGroups = getGroups(compilerOptions, options);
+  const filteredAudits = getAudits(compilerOptions, { onlyAudits });
+  const filteredGroups = getGroups(compilerOptions, { onlyAudits });
 
   logSkippedAudits(filteredAudits);
 
@@ -37,3 +45,15 @@ export async function typescriptPlugin(
     }),
   };
 }
+
+function parseOptions(
+  tsPluginOptions: TypescriptPluginOptions,
+): TypescriptPluginOptions {
+  try {
+    return typescriptPluginConfigSchema.parse(tsPluginOptions);
+  } catch (error) {
+    throw new Error(
+      `Error parsing TypeScript Plugin options: ${(error as Error).message}`,
+    );
+  }
+}

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

@@ -8,7 +8,10 @@ import {
   TYPESCRIPT_PLUGIN_SLUG,
 } from './constants.js';
 import { normalizeCompilerOptions } from './normalize-compiler-options.js';
-import type { TypescriptPluginOptions } from './types.js';
+import type {
+  FilterOptions,
+  TypescriptPluginOptions,
+} from './typescript-plugin.js';
 
 export function filterAuditsBySlug(slugs?: string[]) {
   return ({ slug }: { slug: string }) => {
@@ -74,7 +77,7 @@ export function getGroups(
 
 export function getAudits(
   definitive: CompilerOptions,
-  options?: TypescriptPluginOptions,
+  options?: FilterOptions,
 ) {
   return AUDITS.filter(
     filterAuditsByCompilerOptions(definitive, options?.onlyAudits),
@@ -91,11 +94,16 @@ export async function getCategoryRefsFromGroups(
   opt?: TypescriptPluginOptions,
 ): Promise<CategoryRef[]> {
   const { tsConfigPath } = opt ?? { tsConfigPath: DEFAULT_TS_CONFIG };
-  const definitive = await normalizeCompilerOptions({ ...opt, tsConfigPath });
+  // this line is duplicated in the typescriptPlugin function
+  // to mitigate multiple file access we cache the result
+  const compilerOptions = await normalizeCompilerOptions({
+    ...opt,
+    tsConfigPath,
+  });
   return GROUPS.map(group => ({
     ...group,
     refs: group.refs.filter(
-      filterAuditsByCompilerOptions(definitive, opt?.onlyAudits),
+      filterAuditsByCompilerOptions(compilerOptions, opt?.onlyAudits),
     ),
   }))
     .filter(group => group.refs.length > 0)
@@ -107,6 +115,31 @@ export async function getCategoryRefsFromGroups(
     }));
 }
 
+/**
+ * Retrieve the category references from the audits.
+ * @param opt TSPluginOptions
+ * @returns The array of category references
+ */
+export async function getCategoryRefsFromAudits(
+  opt?: TypescriptPluginOptions,
+): Promise<CategoryRef[]> {
+  const { tsConfigPath } = opt ?? { tsConfigPath: DEFAULT_TS_CONFIG };
+  // this line is duplicated in the typescriptPlugin function
+  // to mitigate multiple file access we cache the result
+  const compilerOptions = await normalizeCompilerOptions({
+    ...opt,
+    tsConfigPath,
+  });
+  return AUDITS.filter(
+    filterAuditsByCompilerOptions(compilerOptions, opt?.onlyAudits),
+  ).map(({ slug }) => ({
+    plugin: TYPESCRIPT_PLUGIN_SLUG,
+    slug,
+    weight: 1,
+    type: 'audit',
+  }));
+}
+
 export function logSkippedAudits(audits: Audit[]) {
   const skippedAudits = AUDITS.filter(
     audit => !audits.some(filtered => filtered.slug === audit.slug),