@tramvai/cli 5.53.81 → 5.53.111

package/src/api/benchmark/utils/compilationUtils.ts

@@ -0,0 +1,213 @@
+import fs from 'node:fs/promises';
+
+import { CompilationStats, LoaderTransformData, MinimalLoaderData, PluginData } from '../types';
+
+export async function getServerCompilationTimings(
+  benchmarkStartTime: string,
+  attemptStartTime: number,
+  attempt: number
+) {
+  return getCompilationTimings(benchmarkStartTime, attemptStartTime, attempt, 'server');
+}
+
+export async function getClientCompilationTimings(
+  benchmarkStartTime: string,
+  attemptStartTime: number,
+  attempt: number
+) {
+  return getCompilationTimings(benchmarkStartTime, attemptStartTime, attempt, 'client');
+}
+
+async function getCompilationTimings(
+  benchmarkStartTime: string,
+  attemptStartTime: number,
+  attempt: number,
+  type: 'client' | 'server'
+): Promise<CompilationStats> {
+  try {
+    const rsdoctorData = await getReportData(
+      await processReport(benchmarkStartTime, attempt, type)
+    );
+
+    const { summary, loader, plugin } = rsdoctorData;
+
+    const totalBuildCosts = calculateTotalCosts(summary, attemptStartTime);
+    const loaderBuildCosts = calculateLoadersCosts(loader);
+    const pluginBuildCosts = calculatePluginsCosts(plugin);
+
+    return { totalBuildCosts, loaderBuildCosts, pluginBuildCosts };
+  } catch (err) {
+    throw new Error(`Failed to get rsdoctor report!\n${err}`);
+  }
+}
+
+async function getReportData(reportPath: string) {
+  const rsdoctorRawStats = await fs.readFile(reportPath, 'utf-8');
+  const rsdoctorStats = JSON.parse(rsdoctorRawStats);
+
+  return rsdoctorStats.data;
+}
+
+async function processReport(
+  benchmarkStartTime: string,
+  attempt: number,
+  type: 'client' | 'server'
+) {
+  const reportBasePath = `./.rsdoctor/${benchmarkStartTime}`;
+  const reportPath = `${reportBasePath}/${type}-rsdoctor-data-${attempt + 1}.json`;
+
+  await fs.mkdir(reportBasePath, { recursive: true });
+  await fs.rename(`./.rsdoctor/${type}-rsdoctor-data.json`, reportPath);
+
+  return reportPath;
+}
+
+function mergeIntervals(intervals: [number, number][]) {
+  // Sort from small to large
+  intervals.sort((a, b) => a[0] - b[0]);
+  // The previous interval, the next interval, store the result
+  let previous;
+  let current;
+  const result: [number, number][] = [];
+
+  for (let i = 0; i < intervals.length; i++) {
+    current = intervals[i];
+    // If the first interval or the current interval does not overlap with the previous interval, add the current interval to the result
+    if (!previous || current[0] > previous[1]) {
+      // Assign the current interval to the previous interval
+      previous = current;
+      result.push(current);
+    } else {
+      // Otherwise, the two intervals overlap
+      // Update the end time of the previous interval
+      previous[1] = Math.max(previous[1], current[1]);
+    }
+  }
+
+  return result;
+}
+
+function getLoadersCosts(
+  filter: (loader: MinimalLoaderData) => boolean,
+  loaders: MinimalLoaderData[]
+) {
+  const match: { [pid: number | string]: [start: number, end: number][] } = {};
+  const others: { [pid: number | string]: [start: number, end: number][] } = {};
+
+  loaders.forEach((e) => {
+    if (filter(e)) {
+      if (!match[e.pid]) match[e.pid] = [];
+      match[e.pid].push([e.startAt, e.endAt]);
+    } else {
+      if (!others[e.pid]) others[e.pid] = [];
+      others[e.pid].push([e.startAt, e.endAt]);
+    }
+  });
+
+  let costs = 0;
+
+  const pids = Object.keys(match);
+
+  for (let i = 0; i < pids.length; i++) {
+    const pid = pids[i];
+    const _match = mergeIntervals(match[pid]);
+    // between in loader.startAt and loader.endAt
+    const _others = mergeIntervals(others[pid] || []).filter(([s, e]) =>
+      _match.some((el) => s >= el[0] && e <= el[1])
+    );
+
+    // eslint-disable-next-line no-param-reassign
+    const matchSum = _match.length ? _match.reduce((t, c) => (t += c[1] - c[0]), 0) : 0;
+    // eslint-disable-next-line no-param-reassign
+    const othersSum = _others.length ? _others.reduce((t, c) => (t += c[1] - c[0]), 0) : 0;
+
+    costs += matchSum - othersSum;
+  }
+
+  return costs;
+}
+
+function calculateTotalCosts(
+  summary: { costs: { name: string; cost: string }[] },
+  attemptStartTime: number
+) {
+  const { costs: buildCosts } = summary;
+  const buildCostsMap = buildCosts.reduce((acc, cost) => {
+    acc[cost.name] = cost;
+    return acc;
+  }, {});
+
+  const result: Record<string, number> = {};
+
+  for (const buildCostName in buildCostsMap) {
+    if (buildCostName === 'bootstrap->beforeCompile') {
+      // start of bootstrap is start of first build, so use attemptStarTime instead
+      result[buildCostName] =
+        buildCostsMap['beforeCompile->afterCompile'].startAt - attemptStartTime;
+    } else {
+      result[buildCostName] = buildCostsMap[buildCostName].costs;
+    }
+  }
+
+  return result;
+}
+
+function calculateLoadersCosts(loaders: { loaders: LoaderTransformData[] }[]) {
+  const filteredLoaders: MinimalLoaderData[] = [];
+  const uniqueLoaders = new Map<
+    string,
+    {
+      files: number;
+      path: string;
+    }
+  >();
+
+  loaders.forEach((data) => {
+    data.loaders.forEach((fl) => {
+      const uniqueLoader = uniqueLoaders.get(fl.loader);
+      if (uniqueLoader) {
+        uniqueLoaders.set(fl.loader, {
+          files: uniqueLoader.files + 1,
+          path: fl.path,
+        });
+      } else {
+        uniqueLoaders.set(fl.loader, { files: 1, path: fl.path });
+      }
+
+      return filteredLoaders.push({
+        loader: fl.loader,
+        startAt: fl.startAt,
+        endAt: fl.endAt,
+        pid: fl.pid,
+      });
+    });
+  });
+
+  const costs: Record<string, number> = {};
+  uniqueLoaders.forEach((_, loaderName: string) => {
+    costs[loaderName] = getLoadersCosts((item) => item.loader === loaderName, filteredLoaders);
+  });
+
+  return costs;
+}
+
+function calculatePluginsCosts(plugins: PluginData) {
+  const pluginCosts: Record<string, number> = {};
+
+  for (const hookName in plugins) {
+    const hookCalls = plugins[hookName];
+
+    hookCalls.forEach((plugin) => {
+      const pluginName = plugin.tapName;
+      const pluginCost = plugin.costs;
+
+      if (pluginCosts[pluginName]) {
+        pluginCosts[pluginName] += pluginCost;
+      } else {
+        pluginCosts[pluginName] = pluginCost;
+      }
+    });
+  }
+
+  return pluginCosts;
+}

package/src/api/benchmark/utils/stats.ts

@@ -1,45 +1,62 @@
-import type { RunStats, Stats } from '../types';
+import type { RunStats, Samples, CompilationStats } from '../types';
 
-export const getSamplesStats = (samples: number[]): Stats => {
-  const n = samples.length;
+function getMeanValue(samples: number[]) {
+  if (samples.length === 0) {
+    return;
+  }
 
   let sum = 0;
 
-  for (let i = 0; i < n; i++) {
+  for (let i = 0; i < samples.length; i++) {
     sum += samples[i];
   }
 
-  const mean = sum / n;
+  return sum / samples.length;
+}
 
-  sum = 0;
+function getCompilationMeanStats(allStats) {
+  const result = {} as CompilationStats;
 
-  for (let i = 0; i < n; i++) {
-    sum += (samples[i] - mean) * (samples[i] - mean);
-  }
+  const stats: CompilationStats = allStats[0];
 
-  const std = Math.sqrt(sum / n);
-  const variance = (100 * std) / mean;
+  for (const section in stats) {
+    for (const metricName in stats[section]) {
+      const samples = allStats.reduce((acc, item) => {
+        acc.push(item[section][metricName]);
+        return acc;
+      }, []);
 
-  return {
-    samples,
-    mean,
-    std,
-    variance,
-  };
-};
+      if (!result[section]) {
+        result[section] = {};
+      }
+      const meanValue = getMeanValue(samples);
+
+      // ignore values less than 10ms
+      if (meanValue > 10) {
+        result[section][metricName] = meanValue;
+      }
+    }
+  }
+
+  return result;
+}
 
 export const getResultStats = ({
-  clientSamples,
-  serverSamples,
+  clientBuildTimeSamples,
+  clientCompilationTimings,
+  clientMaxMemoryRssSamples,
+  serverBuildTimeSamples,
+  serverCompilationTimings,
+  serverMaxMemoryRssSamples,
   maxMemoryRssSamples,
-}: {
-  clientSamples: number[];
-  serverSamples: number[];
-  maxMemoryRssSamples: number[];
-}): RunStats => {
+}: Samples): RunStats => {
   return {
-    client: getSamplesStats(clientSamples),
-    server: getSamplesStats(serverSamples),
-    maxMemoryRss: getSamplesStats(maxMemoryRssSamples),
+    serverBuildTime: getMeanValue(serverBuildTimeSamples),
+    serverCompilationStats: getCompilationMeanStats(serverCompilationTimings),
+    clientBuildTime: getMeanValue(clientBuildTimeSamples),
+    clientCompilationStats: getCompilationMeanStats(clientCompilationTimings),
+    maxMemoryRss: getMeanValue(maxMemoryRssSamples),
+    clientMaxMemoryRss: getMeanValue(clientMaxMemoryRssSamples),
+    serverMaxMemoryRss: getMeanValue(serverMaxMemoryRssSamples),
   };
 };

package/src/api/build/index.ts

@@ -21,6 +21,7 @@ export type Params = WithConfig<{
   env?: Record<string, string>;
   fileCache?: boolean;
   withBuildStats?: boolean;
+  benchmark?: boolean;
   withModulesStats?: boolean;
 
   // `package` target parameters

package/src/api/index.ts

@@ -33,8 +33,8 @@ const app = createApp({
   commands: {
     start: () => import('./start'),
     build: () => import('./build'),
-    benchmark: () => import('./benchmark'),
     analyze: () => import('./analyze'),
+    benchmark: () => import('./benchmark'),
     'start-prod': () => import('./start-prod'),
   },
   providers: [

package/src/api/start/index.ts

@@ -27,6 +27,7 @@ export type Params = WithConfig<{
   noClientRebuild?: boolean;
   resolveSymlinks?: boolean;
   showConfig?: boolean;
+  benchmark?: boolean;
   withBuildStats?: boolean;
   // @todo: not working?
   env?: Record<string, string>;

package/src/builder/webpack/analyzePlugins/rsdoctor.ts

@@ -1,26 +1,23 @@
-import type Config from 'webpack-chain';
-import { RsdoctorWebpackPlugin } from '@rsdoctor/webpack-plugin';
+import type { RsdoctorWebpackPlugin } from '@rsdoctor/webpack-plugin';
 import { AnalyzePlugin } from '../types';
 
+type options = ConstructorParameters<typeof RsdoctorWebpackPlugin<[]>>;
 export class RsdoctorAnalyzePlugin extends AnalyzePlugin {
   requireDeps = [];
 
-  options: [RsdoctorWebpackPlugin<[]>['options']] = [
+  options: options = [
     {
-      features: ['loader', 'plugins', 'resolver'],
+      linter: {
+        level: 'Ignore',
+      },
     },
   ];
 
-  plugin = RsdoctorWebpackPlugin;
-
-  patchConfig = (config: Config): Config => {
-    super.patchConfigInternal(config);
-    // https://github.com/web-infra-dev/rsdoctor/issues/717
-    config.set('experiments', { backCompat: true });
-
-    return config;
-  };
-
   // rsdoctor поднимает dev server
   afterBuild = () => new Promise(() => null);
+
+  get plugin() {
+    // eslint-disable-next-line import/no-unresolved
+    return require('@rsdoctor/webpack-plugin').RsdoctorWebpackMultiplePlugin;
+  }
 }

package/src/builder/webpack/index.ts

@@ -27,7 +27,6 @@ import { buildClientProviders } from './providers/build/client';
 import { buildServerProviders } from './providers/build/server';
 import { CONFIG_MANAGER_TOKEN } from '../../di/tokens';
 import { buildApplicationServerProviders } from './providers/build/application/server';
-import { analyzeSharedProviders } from './providers/analyze/shared';
 
 const BUILDER_NAME = 'webpack';
 
@@ -53,6 +52,14 @@ export const webpackProviders: Provider[] = [
                 ...(shouldBuildServer ? startServerProviders : []),
               ]);
 
+              const configManager = di.get(CONFIG_MANAGER_TOKEN);
+              if (configManager.analyze) {
+                di.register({
+                  provide: WEBPACK_ANALYZE_PLUGIN_NAME_TOKEN,
+                  useValue: configManager.analyze,
+                });
+              }
+
               await runHandlers(di.get({ token: INIT_HANDLER_TOKEN, optional: true, multi: true }));
 
               const getBuildStats = di.get(GET_BUILD_STATS_TOKEN);
@@ -89,9 +96,13 @@ export const webpackProviders: Provider[] = [
                 ...(shouldBuildServer ? buildServerProviders : []),
               ]);
 
-              await runHandlers(di.get({ token: INIT_HANDLER_TOKEN, optional: true, multi: true }));
-
               const configManager = di.get(CONFIG_MANAGER_TOKEN);
+              if (configManager.analyze) {
+                di.register({
+                  provide: WEBPACK_ANALYZE_PLUGIN_NAME_TOKEN,
+                  useValue: configManager.analyze,
+                });
+              }
 
               if (configManager.type === 'application') {
                 registerProviders(di, [
@@ -99,6 +110,8 @@ export const webpackProviders: Provider[] = [
                 ]);
               }
 
+              await runHandlers(di.get({ token: INIT_HANDLER_TOKEN, optional: true, multi: true }));
+
               const getBuildStats = di.get(GET_BUILD_STATS_TOKEN);
 
               await runHandlers(
@@ -113,24 +126,6 @@ export const webpackProviders: Provider[] = [
                 getBuildStats,
               };
             },
-            async analyze({ plugin }) {
-              di.register({
-                provide: WEBPACK_ANALYZE_PLUGIN_NAME_TOKEN,
-                useValue: plugin || 'bundle',
-              });
-
-              registerProviders(di, analyzeSharedProviders);
-
-              await runHandlers(di.get({ token: INIT_HANDLER_TOKEN, optional: true, multi: true }));
-
-              await runHandlers(
-                di.get({ token: PROCESS_HANDLER_TOKEN, optional: true, multi: true })
-              );
-
-              await runHandlers(
-                di.get({ token: CLOSE_HANDLER_TOKEN, optional: true, multi: true })
-              );
-            },
             on(event, callback) {
               di.get(EVENT_EMITTER_TOKEN).on(event, callback);
             },

package/src/builder/webpack/providers/build/client.ts

@@ -6,6 +6,7 @@ import {
   CLIENT_CONFIG_MANAGER_TOKEN,
   CLOSE_HANDLER_TOKEN,
   PROCESS_HANDLER_TOKEN,
+  WEBPACK_ANALYZE_PLUGIN_TOKEN,
   WEBPACK_CLIENT_COMPILER_TOKEN,
   WEBPACK_CLIENT_CONFIG_TOKEN,
 } from '../../tokens';
@@ -27,12 +28,16 @@ export const buildClientProviders: Provider[] = [
   }),
   provide({
     provide: WEBPACK_CLIENT_COMPILER_TOKEN,
-    useFactory: ({ webpackConfig, di }) => {
-      return createCompiler(toWebpackConfig(webpackConfig), di);
+    useFactory: ({ webpackConfig, di, analyzePlugin }) => {
+      return createCompiler(
+        toWebpackConfig(analyzePlugin ? analyzePlugin.patchConfig(webpackConfig) : webpackConfig),
+        di
+      );
     },
     deps: {
       webpackConfig: WEBPACK_CLIENT_CONFIG_TOKEN,
       di: DI_TOKEN,
+      analyzePlugin: { token: WEBPACK_ANALYZE_PLUGIN_TOKEN, optional: true },
     },
   }),
   provide({

package/src/builder/webpack/providers/build/server.ts

@@ -8,6 +8,7 @@ import {
   INIT_HANDLER_TOKEN,
   PROCESS_HANDLER_TOKEN,
   SERVER_CONFIG_MANAGER_TOKEN,
+  WEBPACK_ANALYZE_PLUGIN_TOKEN,
   WEBPACK_SERVER_COMPILER_TOKEN,
   WEBPACK_SERVER_CONFIG_TOKEN,
 } from '../../tokens';
@@ -18,12 +19,16 @@ import { createCompiler } from '../../utils/compiler';
 export const buildServerProviders: Provider[] = [
   provide({
     provide: WEBPACK_SERVER_COMPILER_TOKEN,
-    useFactory: ({ webpackConfig, di }) => {
-      return createCompiler(toWebpackConfig(webpackConfig), di);
+    useFactory: ({ webpackConfig, di, analyzePlugin }) => {
+      return createCompiler(
+        toWebpackConfig(analyzePlugin ? analyzePlugin.patchConfig(webpackConfig) : webpackConfig),
+        di
+      );
     },
     deps: {
       webpackConfig: WEBPACK_SERVER_CONFIG_TOKEN,
       di: DI_TOKEN,
+      analyzePlugin: { token: WEBPACK_ANALYZE_PLUGIN_TOKEN, optional: true },
     },
   }),
   provide({

package/src/builder/webpack/providers/shared.ts

@@ -3,6 +3,8 @@ import { provide } from '@tinkoff/dippy';
 import { EventEmitter } from 'events';
 import { CONFIG_MANAGER_TOKEN, WITH_BUILD_STATS_TOKEN } from '../../../di/tokens';
 import { closeWorkerPool, warmupWorkerPool } from '../../../library/webpack/utils/threadLoader';
+import { calculateBuildTime } from '../utils/calculateBuildTime';
+import { maxMemoryRss } from '../utils/maxMemoryRss';
 import {
   CLOSE_HANDLER_TOKEN,
   EVENT_EMITTER_TOKEN,
@@ -10,10 +12,26 @@ import {
   INIT_HANDLER_TOKEN,
   WEBPACK_CLIENT_COMPILER_TOKEN,
   WEBPACK_SERVER_COMPILER_TOKEN,
+  WEBPACK_ANALYZE_PLUGIN_NAME_TOKEN,
+  WEBPACK_ANALYZE_PLUGIN_TOKEN,
 } from '../tokens';
-import { calculateBuildTime } from '../utils/calculateBuildTime';
 import { emitWebpackEvents } from '../utils/webpackEvents';
-import { maxMemoryRss } from '../utils/maxMemoryRss';
+import { BundleAnalyzePlugin } from '../analyzePlugins/bundle';
+import { StatoscopeAnalyzePlugin } from '../analyzePlugins/statoscope';
+import { WhyBundledAnalyzePlugin } from '../analyzePlugins/whyBundled';
+import { RsdoctorAnalyzePlugin } from '../analyzePlugins/rsdoctor';
+import type { AnalyzePlugin } from '../types';
+
+interface Type<T> extends Function {
+  new (...args: any[]): T;
+}
+
+const pluginMap: Record<string, Type<AnalyzePlugin>> = {
+  bundle: BundleAnalyzePlugin,
+  whybundled: WhyBundledAnalyzePlugin,
+  statoscope: StatoscopeAnalyzePlugin,
+  rsdoctor: RsdoctorAnalyzePlugin,
+};
 
 export const sharedProviders: Provider[] = [
   provide({
@@ -31,8 +49,12 @@ export const sharedProviders: Provider[] = [
       const getMaxMemoryRss = maxMemoryRss();
       return () => {
         return {
-          clientBuildTime: getClientTime?.(),
-          serverBuildTime: getServerTime?.(),
+          client: {
+            buildTime: getClientTime?.(),
+          },
+          server: {
+            buildTime: getServerTime?.(),
+          },
           maxMemoryRss: getMaxMemoryRss?.(),
         };
       };
@@ -43,6 +65,27 @@ export const sharedProviders: Provider[] = [
       serverCompiler: { token: WEBPACK_SERVER_COMPILER_TOKEN, optional: true },
     },
   }),
+  provide({
+    provide: WEBPACK_ANALYZE_PLUGIN_TOKEN,
+    useFactory: ({ pluginName }) => {
+      if (!pluginName) {
+        return;
+      }
+
+      const PluginClass = pluginMap[pluginName];
+
+      if (!PluginClass) {
+        throw new Error(
+          'Set correct value for --analytics cli option, <bundle|whybundled|statoscope|rsdoctor>\n'
+        );
+      }
+
+      return new PluginClass();
+    },
+    deps: {
+      pluginName: WEBPACK_ANALYZE_PLUGIN_NAME_TOKEN,
+    },
+  }),
   provide({
     provide: EVENT_EMITTER_TOKEN,
     useClass: EventEmitter,
@@ -77,13 +120,18 @@ export const sharedProviders: Provider[] = [
   provide({
     provide: CLOSE_HANDLER_TOKEN,
     multi: true,
-    useFactory: ({ configManager }) => {
+    useFactory: ({ configManager, analyzePlugin }) => {
       return async () => {
         await closeWorkerPool(configManager);
+
+        if (analyzePlugin) {
+          return analyzePlugin.afterBuild();
+        }
       };
     },
     deps: {
       configManager: CONFIG_MANAGER_TOKEN,
+      analyzePlugin: { token: WEBPACK_ANALYZE_PLUGIN_TOKEN, optional: true },
     },
   }),
 ];

package/src/builder/webpack/providers/start/shared.ts

@@ -9,6 +9,7 @@ import {
   WEBPACK_COMPILER_TOKEN,
   WEBPACK_SERVER_COMPILER_TOKEN,
   WEBPACK_SERVER_CONFIG_TOKEN,
+  WEBPACK_ANALYZE_PLUGIN_TOKEN,
 } from '../../tokens';
 import { createDevServer } from '../../devServer/setup';
 import { CONFIG_MANAGER_TOKEN, STATIC_SERVER_TOKEN } from '../../../../di/tokens';
@@ -16,8 +17,11 @@ import { CONFIG_MANAGER_TOKEN, STATIC_SERVER_TOKEN } from '../../../../di/tokens
 export const startSharedProviders: Provider[] = [
   provide({
     provide: WEBPACK_COMPILER_TOKEN,
-    useFactory: ({ clientConfig, serverConfig }) => {
-      const configs = [clientConfig, serverConfig].filter(Boolean).map(toWebpackConfig);
+    useFactory: ({ clientConfig, serverConfig, analyzePlugin }) => {
+      const configs = [clientConfig, serverConfig]
+        .filter(Boolean)
+        .map((config) => (analyzePlugin ? analyzePlugin.patchConfig(config) : config))
+        .map(toWebpackConfig);
       const multiCompiler = webpack(configs);
       const { inputFileSystem } = multiCompiler.compilers[0];
 
@@ -51,6 +55,7 @@ export const startSharedProviders: Provider[] = [
     deps: {
       clientConfig: { token: WEBPACK_CLIENT_CONFIG_TOKEN, optional: true },
       serverConfig: { token: WEBPACK_SERVER_CONFIG_TOKEN, optional: true },
+      analyzePlugin: { token: WEBPACK_ANALYZE_PLUGIN_TOKEN, optional: true },
     },
   }),
   provide({

package/src/cli/index.ts

@@ -11,8 +11,8 @@ import buildCommand from '../commands/build/command';
 import { StartCommand } from '../commands/start/command';
 import lintCommand from '../commands/lint/command';
 import taskCommand from '../commands/task/command';
-import analyze from '../commands/analyze/command';
 import generate from '../commands/generate/command';
+import analyze from '../commands/analyze/command';
 import newCommand from '../commands/new/command';
 import updateCommand from '../commands/update/command';
 import addCommand from '../commands/add/command';
@@ -27,15 +27,16 @@ import { getRootFile } from '../utils/getRootFile';
 import { getTramvaiConfig } from '../utils/getTramvaiConfig';
 import { syncJsonFile } from '../utils/syncJsonFile';
 import { AnalyticsService, resolveDependenciesProperties } from '../models/analytics/analytics';
+import AnalyzeCommand from '../commands/analyze/command';
 
 async function loadCommands(): Promise<CommandMap> {
   return [
     buildCommand,
+    AnalyzeCommand,
     StartProdCommand,
     StartCommand,
     lintCommand,
     taskCommand,
-    analyze,
     generate,
     newCommand,
     updateCommand,

package/src/commands/analyze/command.ts

@@ -8,7 +8,7 @@ import { checkReactCompilerDependencies } from '../../validators/commands/checkR
 
 export type Params = {
   target: string;
-  plugin?: 'bundle' | 'whybundled' | 'statoscope';
+  plugin?: 'bundle' | 'whybundled' | 'statoscope' | 'rsdoctor';
   showConfig?: boolean;
 };