@tramvai/cli 5.53.80 → 5.53.94

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;
 };